@supergrowthai/tq 1.0.1-canary.a2ffe03

package/dist/index.js

@@ -0,0 +1,1985 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const types = require("./types.js");
+const mongodb = require("mongodb");
+const mq = require("@supergrowthai/mq");
+const memooseJs = require("memoose-js");
+const ioredis = require("ioredis");
+const moment = require("moment");
+class MemoryCronTasksAdapter {
+  constructor() {
+    this.tasks = /* @__PURE__ */ new Map();
+    this.idCounter = 0;
+  }
+  generateTaskId() {
+    return `cron_task_${++this.idCounter}`;
+  }
+  async insertTasks(tasks) {
+    for (const task of tasks) {
+      if (!task._id) {
+        task._id = this.generateTaskId();
+      }
+      task.created_at = task.created_at || /* @__PURE__ */ new Date();
+      task.status = task.status || "scheduled";
+      this.tasks.set(task._id, task);
+    }
+  }
+  async findScheduledTasks(queueId, limit) {
+    const now = /* @__PURE__ */ new Date();
+    const scheduled = [];
+    for (const task of this.tasks.values()) {
+      if (scheduled.length >= limit) break;
+      if (task.queue_id === queueId && task.status === "scheduled" && (!task.execute_at || task.execute_at <= now)) {
+        scheduled.push(task);
+      }
+    }
+    return scheduled;
+  }
+  async markTasksAsProcessing(taskIds) {
+    for (const id of taskIds) {
+      const task = this.tasks.get(id);
+      if (task) {
+        task.status = "processing";
+        task.processing_started_at = /* @__PURE__ */ new Date();
+      }
+    }
+  }
+  async markTasksAsExecuted(taskIds) {
+    for (const id of taskIds) {
+      const task = this.tasks.get(id);
+      if (task) {
+        task.status = "executed";
+        task.updated_at = /* @__PURE__ */ new Date();
+      }
+    }
+  }
+  async markTasksAsFailed(taskIds) {
+    for (const id of taskIds) {
+      const task = this.tasks.get(id);
+      if (task) {
+        task.status = "failed";
+        task.updated_at = /* @__PURE__ */ new Date();
+        task.retries = (task.retries || 0) + 1;
+      }
+    }
+  }
+}
+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(cacheProvider2, options) {
+    this.cacheProvider = cacheProvider2;
+    this.acquireLocks = /* @__PURE__ */ new Map();
+    this.logger = new Logger("MetricsCollector", LogLevel.INFO);
+    this.cacheProvider = cacheProvider2;
+    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$5 = 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$5.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$5.info("Disconnected from MongoDB");
+    }
+  }
+  async ensureConnection() {
+    if (!this.tasksCollection) {
+      await this.initialize();
+    }
+    return this.tasksCollection;
+  }
+}
+const databaseAdapter = new MongoDbAdapter();
+databaseAdapter.initialize().catch(console.error);
+async function 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 databaseAdapter.addTasksToScheduled(transformedTasks);
+}
+async function getMatureTasks(timestamp) {
+  return await databaseAdapter.getMatureTasks(timestamp);
+}
+async function markTasksAsProcessing(taskIds) {
+  await databaseAdapter.markTasksAsProcessing(taskIds, /* @__PURE__ */ new Date());
+}
+async function markTasksAsExecuted(taskIds) {
+  await databaseAdapter.markTasksAsExecuted(taskIds);
+}
+async function markTasksAsFailed(taskIds) {
+  await databaseAdapter.markTasksAsFailed(taskIds);
+}
+async function updateTasks(updates) {
+  await databaseAdapter.updateTasks(updates);
+}
+async function getTasksByIds(taskIds) {
+  return await databaseAdapter.getTasksByIds(taskIds);
+}
+async function getCleanupStats() {
+  return await databaseAdapter.getCleanupStats();
+}
+async function cleanupTasks() {
+  const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1e3);
+  const now = /* @__PURE__ */ new Date();
+  await databaseAdapter.cleanupTasks(twoDaysAgo, now);
+}
+async function 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 databaseAdapter.updateTasks(updates);
+}
+async function markTasksAsSuccess(tasks) {
+  const taskIds = tasks.map((task) => task._id);
+  await databaseAdapter.markTasksAsExecuted(taskIds);
+}
+async function markTasksAsIgnored(tasks) {
+  const taskIds = tasks.map((task) => task._id);
+  await databaseAdapter.markTasksAsFailed(taskIds);
+}
+const TaskStore = {
+  addTasksToScheduled,
+  getMatureTasks,
+  markTasksAsProcessing,
+  markTasksAsExecuted,
+  markTasksAsFailed,
+  updateTasks,
+  getTasksByIds,
+  getCleanupStats,
+  cleanupTasks,
+  updateTasksForRetry,
+  markTasksAsSuccess,
+  markTasksAsIgnored
+};
+class DisableCachePipeline {
+  constructor() {
+    this.actions = [];
+  }
+  del(key) {
+    this.actions.push(["del", key]);
+    return this;
+  }
+  expire(key, new_ttl_from_now) {
+    this.actions.push(["expire", key, new_ttl_from_now]);
+    return this;
+  }
+  async exec() {
+    return this.actions.map(([action, ...args]) => {
+      switch (action) {
+        case "get":
+        case "del":
+        case "expire":
+        case "set":
+        default:
+          return null;
+      }
+    });
+  }
+  get(key) {
+    this.actions.push(["get", key]);
+    return this;
+  }
+  set(key, data, ttl) {
+    this.actions.push(["set", key, data, ttl]);
+    return this;
+  }
+}
+class DisabledCache {
+  constructor() {
+    this.storesAsObj = false;
+    memooseJs.stats[this.name()] = {};
+  }
+  name() {
+    return "disabled-cache";
+  }
+  pipeline() {
+    return new DisableCachePipeline();
+  }
+  async get(key) {
+    return null;
+  }
+  async mget(...key) {
+    return key.map(() => null);
+  }
+  async mset(...key) {
+    return "OK";
+  }
+  async set(key, data, ttl) {
+    return "OK";
+  }
+  async del(...key) {
+    return key.length;
+  }
+  async expire(key, new_ttl_from_now) {
+    return 1;
+  }
+}
+class RedisClusterCacheProvider {
+  constructor(name, config, connect = true) {
+    this.storesAsObj = false;
+    const { nodes, options } = config;
+    this.client_client = new ioredis.Cluster(nodes, options);
+    this.connect = connect;
+    if (connect)
+      this.connected_promise = this.client_client.connect();
+    else
+      this.connected_promise = Promise.resolve("told not to connect");
+    const errorOrCloseCB = (...args) => {
+      console.log(`Error in RedisClient: ${name}.`, "\r\n", ...args);
+      process.exit(55666);
+    };
+    this.client_client.on("end", errorOrCloseCB.bind(null, "end"));
+    this.client_client.on("error", errorOrCloseCB.bind(null, "error"));
+    this.client_client.on("close", errorOrCloseCB.bind(null, "close"));
+    this.client_client.on("finish", errorOrCloseCB.bind(null, "finish"));
+  }
+  get client() {
+    return this.client_client;
+  }
+  name() {
+    return "redis";
+  }
+  getClientConnectionPromise() {
+    if (this.connect)
+      return this.connected_promise;
+    else
+      throw new Error("shouldnt call as client initialised with connect=false");
+  }
+  get(key) {
+    return this.client_client.get(key);
+  }
+  set(key, value, ttl = -1) {
+    if (ttl > 0)
+      return this.client_client.set(key, value, "EX", ttl);
+    else
+      return this.client_client.set(key, value);
+  }
+  del(...keys) {
+    return this.client_client.del(...keys);
+  }
+  awaitTillReady() {
+    return new Promise((resolve, reject) => {
+      this.client_client.once("ready", resolve);
+      this.client_client.once("error", reject);
+    });
+  }
+  pipeline() {
+    return this.client_client.pipeline();
+  }
+  expire(key, ttl) {
+    return this.client_client.expire(key, ttl);
+  }
+  mget(...keys) {
+    return this.client_client.mget(...keys);
+  }
+  mset(...keyValues) {
+    return this.client_client.mset(...keyValues);
+  }
+  exists(...keys) {
+    return this.client_client.exists(...keys);
+  }
+  lpush(key, ...values) {
+    return this.client_client.lpush(key, ...values);
+  }
+  llen(key) {
+    return this.client_client.llen(key);
+  }
+  scard(key) {
+    return this.client_client.scard(key);
+  }
+  sismember(key, member) {
+    return this.client_client.sismember(key, member);
+  }
+  sadd(key, member) {
+    return this.client_client.sadd(key, member);
+  }
+  srem(key, member) {
+    return this.client_client.srem(key, member);
+  }
+  smembers(key) {
+    return this.client_client.smembers(key);
+  }
+  rpush(key, ...values) {
+    return this.client_client.rpush(key, ...values);
+  }
+  lrange(key, start, stop) {
+    return this.client_client.lrange(key, start, stop);
+  }
+  ping() {
+    return this.client_client.ping();
+  }
+  subscribe(...channels) {
+    return this.client_client.subscribe(...channels);
+  }
+  on(event, listener) {
+    return this.client_client.on(event, listener);
+  }
+  publish(channel, message) {
+    return this.client_client.publish(channel, message);
+  }
+  flushdb() {
+    return this.client_client.flushdb();
+  }
+  lpop(key) {
+    return this.client_client.lpop(key);
+  }
+  decrby(key, count) {
+    return this.client_client.decrby(key, count);
+  }
+}
+class MemoryPipeline {
+  constructor(cache) {
+    this.operations = [];
+    this.cache = cache;
+  }
+  get(key) {
+    this.operations.push(async () => {
+      const entry = this.cache.get(key);
+      if (!entry || entry.expiresAt && entry.expiresAt < Date.now()) {
+        return null;
+      }
+      return entry.value;
+    });
+    return this;
+  }
+  set(key, data, ttl) {
+    this.operations.push(async () => {
+      const entry = {
+        value: data,
+        expiresAt: ttl ? Date.now() + ttl * 1e3 : void 0
+      };
+      this.cache.set(key, entry);
+      return "OK";
+    });
+    return this;
+  }
+  del(key) {
+    this.operations.push(async () => {
+      return this.cache.delete(key) ? 1 : 0;
+    });
+    return this;
+  }
+  expire(key, new_ttl_from_now) {
+    this.operations.push(async () => {
+      const entry = this.cache.get(key);
+      if (!entry) return 0;
+      entry.expiresAt = Date.now() + new_ttl_from_now * 1e3;
+      return 1;
+    });
+    return this;
+  }
+  async exec() {
+    const results = await Promise.all(this.operations.map((op) => op()));
+    this.operations = [];
+    return results;
+  }
+}
+class InMemoryCacheProvider {
+  constructor() {
+    this.storesAsObj = false;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  name() {
+    return "memory";
+  }
+  async get(key) {
+    const entry = this.cache.get(key);
+    if (!entry || this.isExpired(entry)) {
+      if (entry) this.cache.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  async mget(...keys) {
+    return Promise.all(keys.map((key) => this.get(key)));
+  }
+  async mset(...keyValues) {
+    for (const [key, value] of keyValues) {
+      await this.set(key, value);
+    }
+    return "OK";
+  }
+  async set(key, data, ttl) {
+    const entry = {
+      value: data,
+      expiresAt: ttl ? Date.now() + ttl * 1e3 : void 0
+    };
+    this.cache.set(key, entry);
+    return "OK";
+  }
+  async del(...keys) {
+    let count = 0;
+    for (const key of keys) {
+      if (this.cache.delete(key)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  async expire(key, new_ttl_from_now) {
+    const entry = this.cache.get(key);
+    if (!entry) return 0;
+    entry.expiresAt = Date.now() + new_ttl_from_now * 1e3;
+    return 1;
+  }
+  pipeline() {
+    return new MemoryPipeline(this.cache);
+  }
+  isExpired(entry) {
+    return entry.expiresAt !== void 0 && entry.expiresAt < Date.now();
+  }
+}
+class CacheFactory {
+  static create(config) {
+    console.log("Creating cache with config:", JSON.stringify(config));
+    switch (config.provider) {
+      case "redis":
+        if (!config.redis)
+          throw new Error("Redis configuration required");
+        if (config.redis.type === "cluster") {
+          return new RedisClusterCacheProvider("redis", config.redis, false);
+        } else {
+          return new memooseJs.RedisCacheProvider("redis", config.redis, false);
+        }
+      case "memory":
+        return new InMemoryCacheProvider();
+      case "disabled":
+      default:
+        return new DisabledCache();
+    }
+  }
+}
+const configs = {
+  "standalone[redis-cfg]": {
+    provider: "redis",
+    redis: {
+      type: "cluster",
+      nodes: [{
+        host: process.env.REDIS_HOST || "localhost",
+        port: parseInt(process.env.REDIS_PORT || "6379")
+      }],
+      options: {
+        dnsLookup: (address, callback) => callback(null, address),
+        redisOptions: {
+          tls: {}
+        },
+        lazyConnect: true
+      }
+    }
+  },
+  standalone: {
+    provider: "redis",
+    redis: {
+      type: "standalone",
+      host: process.env.REDIS_HOST || "localhost",
+      port: parseInt(process.env.REDIS_PORT || "6379"),
+      lazyConnect: false
+    }
+  },
+  serverless: {
+    provider: "memory"
+    //redis as a service later?
+  }
+};
+const getConfig = () => {
+  const env = process.env.ENV_TYPE || "serverless";
+  return configs[env] || configs.serverless;
+};
+const cacheProvider = CacheFactory.create(getConfig());
+class CacheKeyGeneratorProvider extends memooseJs.CacheKeyGenerator {
+  constructor(function_name, should_sort_args) {
+    super(function_name, should_sort_args);
+    this.fnName = function_name;
+  }
+  for(...args) {
+    const key = super.for(...args);
+    return `{${this.fnName}}:${key}`;
+  }
+}
+const getCacheKeyGenerator = (fn, argsOrder = false) => new CacheKeyGeneratorProvider(fn, argsOrder);
+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);
+const taskIdCacheKeyGen = getCacheKeyGenerator("task-id-gen");
+function tId(task) {
+  if (task._id) return task._id.toString();
+  if (task.task_hash) return task.task_hash;
+  return taskIdCacheKeyGen.for(task.type, task.queue_id, task.created_at, task.payload);
+}
+const logger$4 = 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$4.error(`[${this.taskRunnerId}] Task failed: ${tId(t)} (${t.type})`);
+      },
+      success: (t) => {
+        context.actions.push({
+          type: "success",
+          timestamp: Date.now(),
+          task: t
+        });
+        logger$4.info(`[${this.taskRunnerId}] Task succeeded: ${tId(t)} (${t.type})`);
+      },
+      addTasks: (tasks) => {
+        context.actions.push({
+          type: "addTasks",
+          timestamp: Date.now(),
+          newTasks: tasks
+        });
+        logger$4.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$4.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$4.info(`[${this.taskRunnerId}] Task succeeded: ${taskId} (${task.type})`);
+  }
+  addTasks(tasks) {
+    logger$4.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$4.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$3 = new Logger("AsyncActions", LogLevel.INFO);
+class AsyncActions {
+  constructor(messageQueue, actions, task) {
+    this.messageQueue = messageQueue;
+    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$3.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 TaskStore.markTasksAsFailed(failedTaskIds);
+        logger$3.info(`[AsyncActions] Marked ${results.failedTasks.length} tasks as failed in database`);
+      } catch (err) {
+        logger$3.error(`[AsyncActions] Failed to mark tasks as failed:`, err);
+        throw err;
+      }
+    }
+    if (results.successTasks.length > 0) {
+      try {
+        await TaskStore.markTasksAsSuccess(results.successTasks);
+        logger$3.info(`[AsyncActions] Marked ${results.successTasks.length} tasks as success in database`);
+      } catch (err) {
+        logger$3.error(`[AsyncActions] Failed to mark tasks as success:`, err);
+        throw err;
+      }
+    }
+    if (results.newTasks.length > 0) {
+      logger$3.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 = taskQueue.getExecutor(task.queue_id, task.type);
+        const shouldStoreOnFailure = executor?.store_on_failure ?? false;
+        const id = shouldStoreOnFailure ? { _id: new mongodb.ObjectId() } : {};
+        return { ...id, ...task };
+      });
+      try {
+        await this.messageQueue.addTasks(queue, queueTasks);
+        logger$3.info(`[AsyncActions] Added ${queueTasks.length} immediate tasks to queue ${queue}`);
+      } catch (err) {
+        logger$3.error(`[AsyncActions] Failed to add tasks to queue ${queue}:`, err);
+        throw err;
+      }
+    }
+    if (future.length > 0) {
+      const futureTasks = future.map((task) => {
+        const executor = taskQueue.getExecutor(task.queue_id, task.type);
+        const shouldStoreOnFailure = executor?.store_on_failure ?? false;
+        const id = shouldStoreOnFailure ? { _id: new mongodb.ObjectId() } : {};
+        return { ...id, ...task };
+      });
+      try {
+        await TaskStore.addTasksToScheduled(futureTasks);
+        logger$3.info(`[AsyncActions] Added ${futureTasks.length} future tasks to database`);
+      } catch (err) {
+        logger$3.error(`[AsyncActions] Failed to add tasks to database:`, err);
+        throw err;
+      }
+    }
+  }
+}
+const logger$2 = new Logger("TaskRunner", LogLevel.INFO);
+const lock$1 = new LockManager(cacheProvider, { prefix: "task_lock_", defaultTimeout: 30 * 60 });
+async function taskRunner(messageQueue, taskRunnerId, tasksRaw, asyncTaskManager2) {
+  logger$2.info(`[${taskRunnerId}] Starting task runner`);
+  logger$2.info(`[${taskRunnerId}] Processing ${tasksRaw.length} provided tasks`);
+  const tasks = await lock$1.filterLocked(tasksRaw, tId);
+  logger$2.info(`[${taskRunnerId}] Found ${tasks.length} not locked tasks to process`);
+  await Promise.all(tasks.map((t) => lock$1.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;
+  }, []);
+  logger$2.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) {
+      logger$2.warn(`[${taskRunnerId}] No tasks found for type: ${taskGroup.type}`);
+      continue;
+    }
+    const executor = taskQueue.getExecutor(firstTask.queue_id, taskGroup.type);
+    if (!executor) {
+      logger$2.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: ""
+          /*generate random id*/
+        };
+        actions.addIgnoredTask(taskWithId);
+      }
+      continue;
+    }
+    if (executor.asyncConfig?.handoffTimeout && asyncTaskManager2 && !asyncTaskManager2.canAcceptTask()) {
+      logger$2.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),
+        // 3 minutes
+        status: "scheduled"
+      }));
+      await TaskStore.updateTasksForRetry(rescheduledTasks);
+      continue;
+    }
+    logger$2.info(`[${taskRunnerId}] Processing ${taskGroup.tasks.length} tasks of type: ${taskGroup.type}`);
+    if (executor.multiple) {
+      await executor.onTasks(taskGroup.tasks, actions).catch((err) => logger$2.error(`[${taskRunnerId}] executor.onTasks failed: ${err}`));
+    } else {
+      if (executor.parallel) {
+        const chunks = chunk(taskGroup.tasks, executor.chunkSize);
+        logger$2.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) => logger$2.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) => logger$2.error(`[${taskRunnerId}] executor.onTask failed: ${err}`));
+          } else {
+            const startTime = Date.now();
+            const taskActions = actions.forkForTask(task);
+            const taskPromise = executor.onTask(task, taskActions).catch((err) => {
+              logger$2.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") {
+              logger$2.info(`[${taskRunnerId}] Task ${tId(task)} (${task.type}) exceeded ${timeoutMs}ms, marking for async handoff`);
+              if (!asyncTaskManager2) {
+                throw new Error(`Task ${task.type} exceeded timeout but AsyncTaskManager not initialized!`);
+              }
+              if (!task._id) {
+                logger$2.error(`[${taskRunnerId}] Cannot hand off task without _id (type: ${task.type}). Task will continue but won't be tracked.`);
+              } else {
+                const asyncActions = new AsyncActions(messageQueue, actions, task);
+                const asyncPromise = taskPromise.finally(async () => {
+                  try {
+                    await asyncActions.onPromiseFulfilled();
+                  } catch (err) {
+                    logger$2.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);
+  logger$2.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) => lock$1.release(tId(t))));
+  return { ...results, asyncTasks };
+}
+function getEnabledQueues() {
+  let enabledQueues = process.env.ENABLED_QUEUES ? JSON.parse(process.env.ENABLED_QUEUES) : ["queue-all"];
+  if (enabledQueues.length === 0) throw new Error("No queues enabled");
+  enabledQueues = enabledQueues.map(mq.getEnvironmentQueueName);
+  const queues = taskQueue.getQueues().filter((queue) => enabledQueues.includes(queue));
+  return queues.map(mq.getEnvironmentQueueName);
+}
+const METRICS_KEY_PREFIX = "task_metrics:";
+const DISCARDED_TASKS_KEY = `${METRICS_KEY_PREFIX}discarded_tasks`;
+const queueStats = /* @__PURE__ */ new Map();
+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 logger$1 = new Logger("TaskHandler", LogLevel.INFO);
+const lock = new LockManager(cacheProvider, {
+  prefix: "mature_task_lock_",
+  defaultTimeout: 20
+});
+let asyncTaskManager = null;
+async function trackDiscardedTasks(count) {
+  try {
+    const now = moment.utc();
+    const hourKey = `${DISCARDED_TASKS_KEY}:${now.format("YYYY-MM-DD-HH")}`;
+    const currentHourCountStr = await cacheProvider.get(hourKey) || "0";
+    const currentHourCount = parseInt(currentHourCountStr, 10);
+    const newCount = currentHourCount + count;
+    await cacheProvider.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 cacheProvider.get(pastHourKey) || "0";
+          total += parseInt(pastHourCountStr, 10);
+        }
+        logger$1.info(`Added ${count} discarded tasks to metrics. Last 24h total: ${total}`);
+      } else {
+        logger$1.info(`Added ${count} discarded tasks to current hour metrics.`);
+      }
+    } catch (error) {
+      logger$1.info(`Added ${count} discarded tasks to current hour metrics.`);
+    }
+  } catch (error) {
+    logger$1.error(`Failed to track discarded tasks: ${error}`);
+  }
+}
+let matureTaskTimer = null;
+const getRetryCount = (task) => {
+  if (typeof task.retries === "number") return task.retries;
+  const executor = taskQueue.getExecutor(task.queue_id, task.type);
+  return executor?.default_retries ?? 3;
+};
+async function addTasks(messageQueue, 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 = taskQueue.getExecutor(task.queue_id, task.type);
+      const shouldStoreOnFailure = executor?.store_on_failure ?? false;
+      const id = shouldStoreOnFailure ? { _id: new mongodb.ObjectId() } : {};
+      return { ...id, ...task };
+    });
+    await messageQueue.addTasks(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 = taskQueue.getExecutor(task.queue_id, task.type);
+      const shouldStoreOnFailure = executor?.store_on_failure ?? false;
+      const id = shouldStoreOnFailure ? { _id: new mongodb.ObjectId() } : {};
+      return { ...id, ...task };
+    });
+    await TaskStore.addTasksToScheduled(tasks2);
+  }
+}
+async function postProcessTasks(messageQueue, {
+  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 = 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 = taskQueue.getExecutor(task.queue_id, task.type)?.store_on_failure;
+      if (shouldStoreOnFailure) {
+        tasksToRetry.push({
+          ...task,
+          _id: new mongodb.ObjectId(),
+          status: "scheduled",
+          execute_at: new Date(executeAt),
+          execution_stats: {
+            ...task.execution_stats || {},
+            retry_count: taskRetryCount + 1
+          }
+        });
+      } else {
+        await addTasks(messageQueue, [{
+          ...task,
+          status: "scheduled",
+          execute_at: new Date(executeAt),
+          execution_stats: {
+            ...task.execution_stats || {},
+            retry_count: taskRetryCount + 1
+          }
+        }]);
+      }
+    } else {
+      discardedTasksCount++;
+      logger$1.info(`Discarding task of type ${task.type} after ${taskRetryCount} retries`);
+    }
+  }
+  if (discardedTasksCount > 0) {
+    await trackDiscardedTasks(discardedTasksCount);
+  }
+  if (tasksToRetry.length > 0) {
+    await TaskStore.updateTasksForRetry(tasksToRetry);
+  }
+  if (newTasks.length > 0) {
+    await addTasks(messageQueue, newTasks);
+  }
+  if (finalFailedTasks.length > 0) {
+    const taskIds = finalFailedTasks.map((task) => task._id);
+    await TaskStore.markTasksAsFailed(taskIds);
+  }
+  if (successTasks.length > 0) {
+    await TaskStore.markTasksAsSuccess(successTasks);
+  }
+}
+async function reportQueueStats(queueName, forceSend = false) {
+  const stats = 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 {
+    logger$1.info(`Sent stats for ${queueName}`);
+  } catch (err) {
+    logger$1.error(`Failed to send stats: ${err}`);
+  }
+  if (!forceSend) {
+    stats.success = 0;
+    stats.failed = 0;
+    stats.async = 0;
+    stats.ignored = 0;
+  }
+}
+function startConsumingTasks(messageQueue, streamName) {
+  return messageQueue.consumeTasks(streamName, async (id, tasks) => {
+    logger$1.debug(`Processing ${tasks.length} tasks for stream ${streamName}`);
+    const {
+      failedTasks,
+      newTasks,
+      successTasks,
+      asyncTasks,
+      ignoredTasks
+    } = await taskRunner(messageQueue, id, tasks, asyncTaskManager || void 0).catch((err) => {
+      logger$1.error("Failed to execute tasks?", err);
+      return { failedTasks: [], newTasks: [], successTasks: [], asyncTasks: [], ignoredTasks: [] };
+    });
+    if (asyncTasks.length > 0 && !asyncTaskManager) {
+      throw new Error("Async tasks detected but AsyncTaskManager not initialized!");
+    }
+    if (asyncTasks.length > 0) {
+      logger$1.info(`Handling ${asyncTasks.length} async tasks for stream ${streamName}`);
+      for (const asyncTask of asyncTasks) {
+        const accepted = asyncTaskManager.handoffTask(asyncTask.task, asyncTask.promise);
+        if (!accepted) {
+          logger$1.warn(`Async queue full, requeueing task ${asyncTask.task._id} with 30s delay`);
+          await addTasks(messageQueue, [{
+            ...asyncTask.task,
+            execute_at: new Date(Date.now() + 3e4)
+            // 30 second delay
+          }]);
+        }
+      }
+    }
+    if (ignoredTasks.length > 0) {
+      logger$1.warn(`Storing ${ignoredTasks.length} ignored tasks with no executor for stream ${streamName}`);
+      await TaskStore.markTasksAsIgnored(ignoredTasks).catch((err) => {
+        logger$1.error("Failed to mark tasks as ignored", err);
+      });
+    }
+    await postProcessTasks(messageQueue, { failedTasks, newTasks, successTasks }).catch((err) => {
+      logger$1.error("Failed to postProcessTasks", err);
+    });
+    if (!queueStats.has(streamName)) {
+      queueStats.set(streamName, {
+        success: 0,
+        failed: 0,
+        async: 0,
+        ignored: 0
+      });
+    }
+    const stats = queueStats.get(streamName);
+    stats.success += successTasks.length;
+    stats.failed += failedTasks.length;
+    stats.async += asyncTasks.length;
+    stats.ignored += ignoredTasks.length;
+    await reportQueueStats(streamName);
+    logger$1.debug(`Completed processing for stream ${streamName}: ${successTasks.length} succeeded, ${failedTasks.length} failed, ${newTasks.length} new tasks, ${ignoredTasks.length} ignored`);
+    return { failedTasks, newTasks, successTasks };
+  });
+}
+function processMatureTasks(messageQueue) {
+  const LOCK_ID = "task_processor";
+  if (matureTaskTimer) clearInterval(matureTaskTimer);
+  matureTaskTimer = setInterval(async () => {
+    if (await lock.isLocked(LOCK_ID)) {
+      logger$1.info("Mature task runner locked");
+      return;
+    }
+    try {
+      await lock.acquire(LOCK_ID);
+      const matureTasks = await TaskStore.getMatureTasks(Date.now());
+      logger$1.debug(`Found ${matureTasks.length} mature tasks to process`);
+      await addTasks(messageQueue, matureTasks);
+    } catch (error) {
+      logger$1.error(`Error processing tasks: ${error}`);
+    } finally {
+      await lock.release(LOCK_ID);
+    }
+  }, 5e3);
+}
+function taskProcessServer(messageQueue) {
+  const queues = getEnabledQueues();
+  for (let i = 0; i < queues.length; i++) {
+    logger$1.info(`Starting consumer for queue: ${queues[i]}`);
+    startConsumingTasks(messageQueue, queues[i]);
+  }
+  logger$1.info("Starting mature tasks processor");
+  processMatureTasks(messageQueue);
+}
+function processBatch(messageQueue, queueId, processor, limit) {
+  return messageQueue.processBatch(queueId, processor, limit);
+}
+function setAsyncTaskManager(manager) {
+  asyncTaskManager = manager;
+  logger$1.info("Async task manager set");
+}
+const taskHandler = {
+  processBatch,
+  processMatureTasks,
+  startConsumingTasks,
+  postProcessTasks,
+  addTasks,
+  taskProcessServer,
+  setAsyncTaskManager
+};
+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;
+  }
+}
+class TaskQueue {
+  constructor() {
+    this.queueTaskExecutorMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Registers a task executor with a message queue and queue name
+   * @param messageQueue The message queue to register with
+   * @param queueName The name of the queue
+   * @param taskType The type of task
+   * @param executor The executor for the task
+   */
+  register(messageQueue, queueName, taskType, executor) {
+    queueName = mq.getEnvironmentQueueName(queueName);
+    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 taskQueue = new TaskQueue();
+exports.CronTaskType = types.CronTaskType;
+exports.Actions = Actions;
+exports.AsyncActions = AsyncActions;
+exports.AsyncTaskManager = AsyncTaskManager;
+exports.MemoryCronTasksAdapter = MemoryCronTasksAdapter;
+exports.MongoDbAdapter = MongoDbAdapter;
+exports.TaskQueue = TaskQueue;
+exports.TaskStore = TaskStore;
+exports.databaseAdapter = databaseAdapter;
+exports.default = taskQueue;
+exports.getEnabledQueues = getEnabledQueues;
+exports.tId = tId;
+exports.taskHandler = taskHandler;
+exports.taskRunner = taskRunner;
+//# sourceMappingURL=index.js.map