@nicnocquee/dataqueue 1.26.0 → 1.31.0

package/dist/index.js

@@ -0,0 +1,3953 @@
+import { AsyncLocalStorage } from 'async_hooks';
+import { randomUUID } from 'crypto';
+import { Worker } from 'worker_threads';
+import { Pool } from 'pg';
+import { parse } from 'pg-connection-string';
+import fs from 'fs';
+import { createRequire } from 'module';
+import { Cron } from 'croner';
+
+// src/types.ts
+var JobEventType = /* @__PURE__ */ ((JobEventType2) => {
+  JobEventType2["Added"] = "added";
+  JobEventType2["Processing"] = "processing";
+  JobEventType2["Completed"] = "completed";
+  JobEventType2["Failed"] = "failed";
+  JobEventType2["Cancelled"] = "cancelled";
+  JobEventType2["Retried"] = "retried";
+  JobEventType2["Edited"] = "edited";
+  JobEventType2["Prolonged"] = "prolonged";
+  JobEventType2["Waiting"] = "waiting";
+  return JobEventType2;
+})(JobEventType || {});
+var FailureReason = /* @__PURE__ */ ((FailureReason5) => {
+  FailureReason5["Timeout"] = "timeout";
+  FailureReason5["HandlerError"] = "handler_error";
+  FailureReason5["NoHandler"] = "no_handler";
+  return FailureReason5;
+})(FailureReason || {});
+var WaitSignal = class extends Error {
+  constructor(type, waitUntil, tokenId, stepData) {
+    super("WaitSignal");
+    this.type = type;
+    this.waitUntil = waitUntil;
+    this.tokenId = tokenId;
+    this.stepData = stepData;
+    this.isWaitSignal = true;
+    this.name = "WaitSignal";
+  }
+};
+var logStorage = new AsyncLocalStorage();
+var setLogContext = (verbose) => {
+  logStorage.enterWith({ verbose });
+};
+var getLogContext = () => {
+  return logStorage.getStore();
+};
+var log = (message) => {
+  const context = getLogContext();
+  if (context?.verbose) {
+    console.log(message);
+  }
+};
+
+// src/backends/postgres.ts
+var PostgresBackend = class {
+  constructor(pool) {
+    this.pool = pool;
+  }
+  /** Expose the raw pool for advanced usage. */
+  getPool() {
+    return this.pool;
+  }
+  // ── Events ──────────────────────────────────────────────────────────
+  async recordJobEvent(jobId, eventType, metadata) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(
+        `INSERT INTO job_events (job_id, event_type, metadata) VALUES ($1, $2, $3)`,
+        [jobId, eventType, metadata ? JSON.stringify(metadata) : null]
+      );
+    } catch (error) {
+      log(`Error recording job event for job ${jobId}: ${error}`);
+    } finally {
+      client.release();
+    }
+  }
+  async getJobEvents(jobId) {
+    const client = await this.pool.connect();
+    try {
+      const res = await client.query(
+        `SELECT id, job_id AS "jobId", event_type AS "eventType", metadata, created_at AS "createdAt" FROM job_events WHERE job_id = $1 ORDER BY created_at ASC`,
+        [jobId]
+      );
+      return res.rows;
+    } finally {
+      client.release();
+    }
+  }
+  // ── Job CRUD ──────────────────────────────────────────────────────────
+  async addJob({
+    jobType,
+    payload,
+    maxAttempts = 3,
+    priority = 0,
+    runAt = null,
+    timeoutMs = void 0,
+    forceKillOnTimeout = false,
+    tags = void 0,
+    idempotencyKey = void 0
+  }) {
+    const client = await this.pool.connect();
+    try {
+      let result;
+      const onConflict = idempotencyKey ? `ON CONFLICT (idempotency_key) WHERE idempotency_key IS NOT NULL DO NOTHING` : "";
+      if (runAt) {
+        result = await client.query(
+          `INSERT INTO job_queue 
+            (job_type, payload, max_attempts, priority, run_at, timeout_ms, force_kill_on_timeout, tags, idempotency_key) 
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) 
+           ${onConflict}
+           RETURNING id`,
+          [
+            jobType,
+            payload,
+            maxAttempts,
+            priority,
+            runAt,
+            timeoutMs ?? null,
+            forceKillOnTimeout ?? false,
+            tags ?? null,
+            idempotencyKey ?? null
+          ]
+        );
+      } else {
+        result = await client.query(
+          `INSERT INTO job_queue 
+            (job_type, payload, max_attempts, priority, timeout_ms, force_kill_on_timeout, tags, idempotency_key) 
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8) 
+           ${onConflict}
+           RETURNING id`,
+          [
+            jobType,
+            payload,
+            maxAttempts,
+            priority,
+            timeoutMs ?? null,
+            forceKillOnTimeout ?? false,
+            tags ?? null,
+            idempotencyKey ?? null
+          ]
+        );
+      }
+      if (result.rows.length === 0 && idempotencyKey) {
+        const existing = await client.query(
+          `SELECT id FROM job_queue WHERE idempotency_key = $1`,
+          [idempotencyKey]
+        );
+        if (existing.rows.length > 0) {
+          log(
+            `Job with idempotency key "${idempotencyKey}" already exists (id: ${existing.rows[0].id}), returning existing job`
+          );
+          return existing.rows[0].id;
+        }
+        throw new Error(
+          `Failed to insert job and could not find existing job with idempotency key "${idempotencyKey}"`
+        );
+      }
+      const jobId = result.rows[0].id;
+      log(
+        `Added job ${jobId}: payload ${JSON.stringify(payload)}, ${runAt ? `runAt ${runAt.toISOString()}, ` : ""}priority ${priority}, maxAttempts ${maxAttempts}, jobType ${jobType}, tags ${JSON.stringify(tags)}${idempotencyKey ? `, idempotencyKey "${idempotencyKey}"` : ""}`
+      );
+      await this.recordJobEvent(jobId, "added" /* Added */, {
+        jobType,
+        payload,
+        tags,
+        idempotencyKey
+      });
+      return jobId;
+    } catch (error) {
+      log(`Error adding job: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async getJob(id) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason", tags, idempotency_key AS "idempotencyKey", wait_until AS "waitUntil", wait_token_id AS "waitTokenId", step_data AS "stepData", progress FROM job_queue WHERE id = $1`,
+        [id]
+      );
+      if (result.rows.length === 0) {
+        log(`Job ${id} not found`);
+        return null;
+      }
+      log(`Found job ${id}`);
+      const job = result.rows[0];
+      return {
+        ...job,
+        payload: job.payload,
+        timeoutMs: job.timeoutMs,
+        forceKillOnTimeout: job.forceKillOnTimeout,
+        failureReason: job.failureReason
+      };
+    } catch (error) {
+      log(`Error getting job ${id}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async getJobsByStatus(status, limit = 100, offset = 0) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason", idempotency_key AS "idempotencyKey", wait_until AS "waitUntil", wait_token_id AS "waitTokenId", step_data AS "stepData", progress FROM job_queue WHERE status = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3`,
+        [status, limit, offset]
+      );
+      log(`Found ${result.rows.length} jobs by status ${status}`);
+      return result.rows.map((job) => ({
+        ...job,
+        payload: job.payload,
+        timeoutMs: job.timeoutMs,
+        forceKillOnTimeout: job.forceKillOnTimeout,
+        failureReason: job.failureReason
+      }));
+    } catch (error) {
+      log(`Error getting jobs by status ${status}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async getAllJobs(limit = 100, offset = 0) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason", idempotency_key AS "idempotencyKey", wait_until AS "waitUntil", wait_token_id AS "waitTokenId", step_data AS "stepData", progress FROM job_queue ORDER BY created_at DESC LIMIT $1 OFFSET $2`,
+        [limit, offset]
+      );
+      log(`Found ${result.rows.length} jobs (all)`);
+      return result.rows.map((job) => ({
+        ...job,
+        payload: job.payload,
+        timeoutMs: job.timeoutMs,
+        forceKillOnTimeout: job.forceKillOnTimeout
+      }));
+    } catch (error) {
+      log(`Error getting all jobs: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async getJobs(filters, limit = 100, offset = 0) {
+    const client = await this.pool.connect();
+    try {
+      let query = `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason", tags, idempotency_key AS "idempotencyKey", wait_until AS "waitUntil", wait_token_id AS "waitTokenId", step_data AS "stepData", progress FROM job_queue`;
+      const params = [];
+      const where = [];
+      let paramIdx = 1;
+      if (filters) {
+        if (filters.jobType) {
+          where.push(`job_type = $${paramIdx++}`);
+          params.push(filters.jobType);
+        }
+        if (filters.priority !== void 0) {
+          where.push(`priority = $${paramIdx++}`);
+          params.push(filters.priority);
+        }
+        if (filters.runAt) {
+          if (filters.runAt instanceof Date) {
+            where.push(`run_at = $${paramIdx++}`);
+            params.push(filters.runAt);
+          } else if (typeof filters.runAt === "object" && (filters.runAt.gt !== void 0 || filters.runAt.gte !== void 0 || filters.runAt.lt !== void 0 || filters.runAt.lte !== void 0 || filters.runAt.eq !== void 0)) {
+            const ops = filters.runAt;
+            if (ops.gt) {
+              where.push(`run_at > $${paramIdx++}`);
+              params.push(ops.gt);
+            }
+            if (ops.gte) {
+              where.push(`run_at >= $${paramIdx++}`);
+              params.push(ops.gte);
+            }
+            if (ops.lt) {
+              where.push(`run_at < $${paramIdx++}`);
+              params.push(ops.lt);
+            }
+            if (ops.lte) {
+              where.push(`run_at <= $${paramIdx++}`);
+              params.push(ops.lte);
+            }
+            if (ops.eq) {
+              where.push(`run_at = $${paramIdx++}`);
+              params.push(ops.eq);
+            }
+          }
+        }
+        if (filters.tags && filters.tags.values && filters.tags.values.length > 0) {
+          const mode = filters.tags.mode || "all";
+          const tagValues = filters.tags.values;
+          switch (mode) {
+            case "exact":
+              where.push(`tags = $${paramIdx++}`);
+              params.push(tagValues);
+              break;
+            case "all":
+              where.push(`tags @> $${paramIdx++}`);
+              params.push(tagValues);
+              break;
+            case "any":
+              where.push(`tags && $${paramIdx++}`);
+              params.push(tagValues);
+              break;
+            case "none":
+              where.push(`NOT (tags && $${paramIdx++})`);
+              params.push(tagValues);
+              break;
+            default:
+              where.push(`tags @> $${paramIdx++}`);
+              params.push(tagValues);
+          }
+        }
+        if (filters.cursor !== void 0) {
+          where.push(`id < $${paramIdx++}`);
+          params.push(filters.cursor);
+        }
+      }
+      if (where.length > 0) {
+        query += ` WHERE ${where.join(" AND ")}`;
+      }
+      paramIdx = params.length + 1;
+      query += ` ORDER BY id DESC LIMIT $${paramIdx++}`;
+      if (!filters?.cursor) {
+        query += ` OFFSET $${paramIdx}`;
+        params.push(limit, offset);
+      } else {
+        params.push(limit);
+      }
+      const result = await client.query(query, params);
+      log(`Found ${result.rows.length} jobs`);
+      return result.rows.map((job) => ({
+        ...job,
+        payload: job.payload,
+        timeoutMs: job.timeoutMs,
+        forceKillOnTimeout: job.forceKillOnTimeout,
+        failureReason: job.failureReason
+      }));
+    } catch (error) {
+      log(`Error getting jobs: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async getJobsByTags(tags, mode = "all", limit = 100, offset = 0) {
+    const client = await this.pool.connect();
+    try {
+      let query = `SELECT id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_failed_at AS "lastFailedAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason", tags, idempotency_key AS "idempotencyKey", wait_until AS "waitUntil", wait_token_id AS "waitTokenId", step_data AS "stepData", progress
+         FROM job_queue`;
+      let params = [];
+      switch (mode) {
+        case "exact":
+          query += " WHERE tags = $1";
+          params = [tags];
+          break;
+        case "all":
+          query += " WHERE tags @> $1";
+          params = [tags];
+          break;
+        case "any":
+          query += " WHERE tags && $1";
+          params = [tags];
+          break;
+        case "none":
+          query += " WHERE NOT (tags && $1)";
+          params = [tags];
+          break;
+        default:
+          query += " WHERE tags @> $1";
+          params = [tags];
+      }
+      query += " ORDER BY created_at DESC LIMIT $2 OFFSET $3";
+      params.push(limit, offset);
+      const result = await client.query(query, params);
+      log(
+        `Found ${result.rows.length} jobs by tags ${JSON.stringify(tags)} (mode: ${mode})`
+      );
+      return result.rows.map((job) => ({
+        ...job,
+        payload: job.payload,
+        timeoutMs: job.timeoutMs,
+        forceKillOnTimeout: job.forceKillOnTimeout,
+        failureReason: job.failureReason
+      }));
+    } catch (error) {
+      log(
+        `Error getting jobs by tags ${JSON.stringify(tags)} (mode: ${mode}): ${error}`
+      );
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  // ── Processing lifecycle ──────────────────────────────────────────────
+  async getNextBatch(workerId, batchSize = 10, jobType) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      let jobTypeFilter = "";
+      const params = [workerId, batchSize];
+      if (jobType) {
+        if (Array.isArray(jobType)) {
+          jobTypeFilter = ` AND job_type = ANY($3)`;
+          params.push(jobType);
+        } else {
+          jobTypeFilter = ` AND job_type = $3`;
+          params.push(jobType);
+        }
+      }
+      const result = await client.query(
+        `
+        UPDATE job_queue
+        SET status = 'processing', 
+            locked_at = NOW(), 
+            locked_by = $1,
+            attempts = CASE WHEN status = 'waiting' THEN attempts ELSE attempts + 1 END,
+            updated_at = NOW(),
+            pending_reason = NULL,
+            started_at = COALESCE(started_at, NOW()),
+            last_retried_at = CASE WHEN status != 'waiting' AND attempts > 0 THEN NOW() ELSE last_retried_at END,
+            wait_until = NULL
+        WHERE id IN (
+          SELECT id FROM job_queue
+          WHERE (
+            (
+              (status = 'pending' OR (status = 'failed' AND next_attempt_at <= NOW()))
+              AND (attempts < max_attempts)
+              AND run_at <= NOW()
+            )
+            OR (
+              status = 'waiting'
+              AND wait_until IS NOT NULL
+              AND wait_until <= NOW()
+              AND wait_token_id IS NULL
+            )
+          )
+          ${jobTypeFilter}
+          ORDER BY priority DESC, created_at ASC
+          LIMIT $2
+          FOR UPDATE SKIP LOCKED
+        )
+        RETURNING id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason", idempotency_key AS "idempotencyKey", wait_until AS "waitUntil", wait_token_id AS "waitTokenId", step_data AS "stepData", progress
+      `,
+        params
+      );
+      log(`Found ${result.rows.length} jobs to process`);
+      await client.query("COMMIT");
+      if (result.rows.length > 0) {
+        await this.recordJobEventsBatch(
+          result.rows.map((row) => ({
+            jobId: row.id,
+            eventType: "processing" /* Processing */
+          }))
+        );
+      }
+      return result.rows.map((job) => ({
+        ...job,
+        payload: job.payload,
+        timeoutMs: job.timeoutMs,
+        forceKillOnTimeout: job.forceKillOnTimeout
+      }));
+    } catch (error) {
+      log(`Error getting next batch: ${error}`);
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async completeJob(jobId) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `
+        UPDATE job_queue
+        SET status = 'completed', updated_at = NOW(), completed_at = NOW(),
+            step_data = NULL, wait_until = NULL, wait_token_id = NULL
+        WHERE id = $1 AND status = 'processing'
+      `,
+        [jobId]
+      );
+      if (result.rowCount === 0) {
+        log(
+          `Job ${jobId} could not be completed (not in processing state or does not exist)`
+        );
+      }
+      await this.recordJobEvent(jobId, "completed" /* Completed */);
+      log(`Completed job ${jobId}`);
+    } catch (error) {
+      log(`Error completing job ${jobId}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async failJob(jobId, error, failureReason) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `
+        UPDATE job_queue
+        SET status = 'failed', 
+            updated_at = NOW(),
+            next_attempt_at = CASE 
+              WHEN attempts < max_attempts THEN NOW() + (POWER(2, attempts) * INTERVAL '1 minute')
+              ELSE NULL
+            END,
+            error_history = COALESCE(error_history, '[]'::jsonb) || $2::jsonb,
+            failure_reason = $3,
+            last_failed_at = NOW()
+        WHERE id = $1 AND status IN ('processing', 'pending')
+      `,
+        [
+          jobId,
+          JSON.stringify([
+            {
+              message: error.message || String(error),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          ]),
+          failureReason ?? null
+        ]
+      );
+      if (result.rowCount === 0) {
+        log(
+          `Job ${jobId} could not be failed (not in processing/pending state or does not exist)`
+        );
+      }
+      await this.recordJobEvent(jobId, "failed" /* Failed */, {
+        message: error.message || String(error),
+        failureReason
+      });
+      log(`Failed job ${jobId}`);
+    } catch (err) {
+      log(`Error failing job ${jobId}: ${err}`);
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  async prolongJob(jobId) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(
+        `
+        UPDATE job_queue
+        SET locked_at = NOW(), updated_at = NOW()
+        WHERE id = $1 AND status = 'processing'
+      `,
+        [jobId]
+      );
+      await this.recordJobEvent(jobId, "prolonged" /* Prolonged */);
+      log(`Prolonged job ${jobId}`);
+    } catch (error) {
+      log(`Error prolonging job ${jobId}: ${error}`);
+    } finally {
+      client.release();
+    }
+  }
+  // ── Progress ──────────────────────────────────────────────────────────
+  async updateProgress(jobId, progress) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(
+        `UPDATE job_queue SET progress = $2, updated_at = NOW() WHERE id = $1`,
+        [jobId, progress]
+      );
+      log(`Updated progress for job ${jobId}: ${progress}%`);
+    } catch (error) {
+      log(`Error updating progress for job ${jobId}: ${error}`);
+    } finally {
+      client.release();
+    }
+  }
+  // ── Job management ────────────────────────────────────────────────────
+  async retryJob(jobId) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `
+        UPDATE job_queue
+        SET status = 'pending', 
+            updated_at = NOW(),
+            locked_at = NULL,
+            locked_by = NULL,
+            next_attempt_at = NOW(),
+            last_retried_at = NOW()
+        WHERE id = $1 AND status IN ('failed', 'processing')
+      `,
+        [jobId]
+      );
+      if (result.rowCount === 0) {
+        log(
+          `Job ${jobId} could not be retried (not in failed/processing state or does not exist)`
+        );
+      }
+      await this.recordJobEvent(jobId, "retried" /* Retried */);
+      log(`Retried job ${jobId}`);
+    } catch (error) {
+      log(`Error retrying job ${jobId}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async cancelJob(jobId) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(
+        `
+        UPDATE job_queue
+        SET status = 'cancelled', updated_at = NOW(), last_cancelled_at = NOW(),
+            wait_until = NULL, wait_token_id = NULL
+        WHERE id = $1 AND status IN ('pending', 'waiting')
+      `,
+        [jobId]
+      );
+      await this.recordJobEvent(jobId, "cancelled" /* Cancelled */);
+      log(`Cancelled job ${jobId}`);
+    } catch (error) {
+      log(`Error cancelling job ${jobId}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async cancelAllUpcomingJobs(filters) {
+    const client = await this.pool.connect();
+    try {
+      let query = `
+        UPDATE job_queue
+        SET status = 'cancelled', updated_at = NOW()
+        WHERE status = 'pending'`;
+      const params = [];
+      let paramIdx = 1;
+      if (filters) {
+        if (filters.jobType) {
+          query += ` AND job_type = $${paramIdx++}`;
+          params.push(filters.jobType);
+        }
+        if (filters.priority !== void 0) {
+          query += ` AND priority = $${paramIdx++}`;
+          params.push(filters.priority);
+        }
+        if (filters.runAt) {
+          if (filters.runAt instanceof Date) {
+            query += ` AND run_at = $${paramIdx++}`;
+            params.push(filters.runAt);
+          } else if (typeof filters.runAt === "object") {
+            const ops = filters.runAt;
+            if (ops.gt) {
+              query += ` AND run_at > $${paramIdx++}`;
+              params.push(ops.gt);
+            }
+            if (ops.gte) {
+              query += ` AND run_at >= $${paramIdx++}`;
+              params.push(ops.gte);
+            }
+            if (ops.lt) {
+              query += ` AND run_at < $${paramIdx++}`;
+              params.push(ops.lt);
+            }
+            if (ops.lte) {
+              query += ` AND run_at <= $${paramIdx++}`;
+              params.push(ops.lte);
+            }
+            if (ops.eq) {
+              query += ` AND run_at = $${paramIdx++}`;
+              params.push(ops.eq);
+            }
+          }
+        }
+        if (filters.tags && filters.tags.values && filters.tags.values.length > 0) {
+          const mode = filters.tags.mode || "all";
+          const tagValues = filters.tags.values;
+          switch (mode) {
+            case "exact":
+              query += ` AND tags = $${paramIdx++}`;
+              params.push(tagValues);
+              break;
+            case "all":
+              query += ` AND tags @> $${paramIdx++}`;
+              params.push(tagValues);
+              break;
+            case "any":
+              query += ` AND tags && $${paramIdx++}`;
+              params.push(tagValues);
+              break;
+            case "none":
+              query += ` AND NOT (tags && $${paramIdx++})`;
+              params.push(tagValues);
+              break;
+            default:
+              query += ` AND tags @> $${paramIdx++}`;
+              params.push(tagValues);
+          }
+        }
+      }
+      query += "\nRETURNING id";
+      const result = await client.query(query, params);
+      log(`Cancelled ${result.rowCount} jobs`);
+      return result.rowCount || 0;
+    } catch (error) {
+      log(`Error cancelling upcoming jobs: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async editJob(jobId, updates) {
+    const client = await this.pool.connect();
+    try {
+      const updateFields = [];
+      const params = [];
+      let paramIdx = 1;
+      if (updates.payload !== void 0) {
+        updateFields.push(`payload = $${paramIdx++}`);
+        params.push(updates.payload);
+      }
+      if (updates.maxAttempts !== void 0) {
+        updateFields.push(`max_attempts = $${paramIdx++}`);
+        params.push(updates.maxAttempts);
+      }
+      if (updates.priority !== void 0) {
+        updateFields.push(`priority = $${paramIdx++}`);
+        params.push(updates.priority);
+      }
+      if (updates.runAt !== void 0) {
+        if (updates.runAt === null) {
+          updateFields.push(`run_at = NOW()`);
+        } else {
+          updateFields.push(`run_at = $${paramIdx++}`);
+          params.push(updates.runAt);
+        }
+      }
+      if (updates.timeoutMs !== void 0) {
+        updateFields.push(`timeout_ms = $${paramIdx++}`);
+        params.push(updates.timeoutMs ?? null);
+      }
+      if (updates.tags !== void 0) {
+        updateFields.push(`tags = $${paramIdx++}`);
+        params.push(updates.tags ?? null);
+      }
+      if (updateFields.length === 0) {
+        log(`No fields to update for job ${jobId}`);
+        return;
+      }
+      updateFields.push(`updated_at = NOW()`);
+      params.push(jobId);
+      const query = `
+        UPDATE job_queue
+        SET ${updateFields.join(", ")}
+        WHERE id = $${paramIdx} AND status = 'pending'
+      `;
+      await client.query(query, params);
+      const metadata = {};
+      if (updates.payload !== void 0) metadata.payload = updates.payload;
+      if (updates.maxAttempts !== void 0)
+        metadata.maxAttempts = updates.maxAttempts;
+      if (updates.priority !== void 0) metadata.priority = updates.priority;
+      if (updates.runAt !== void 0) metadata.runAt = updates.runAt;
+      if (updates.timeoutMs !== void 0)
+        metadata.timeoutMs = updates.timeoutMs;
+      if (updates.tags !== void 0) metadata.tags = updates.tags;
+      await this.recordJobEvent(jobId, "edited" /* Edited */, metadata);
+      log(`Edited job ${jobId}: ${JSON.stringify(metadata)}`);
+    } catch (error) {
+      log(`Error editing job ${jobId}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async editAllPendingJobs(filters = void 0, updates) {
+    const client = await this.pool.connect();
+    try {
+      const updateFields = [];
+      const params = [];
+      let paramIdx = 1;
+      if (updates.payload !== void 0) {
+        updateFields.push(`payload = $${paramIdx++}`);
+        params.push(updates.payload);
+      }
+      if (updates.maxAttempts !== void 0) {
+        updateFields.push(`max_attempts = $${paramIdx++}`);
+        params.push(updates.maxAttempts);
+      }
+      if (updates.priority !== void 0) {
+        updateFields.push(`priority = $${paramIdx++}`);
+        params.push(updates.priority);
+      }
+      if (updates.runAt !== void 0) {
+        if (updates.runAt === null) {
+          updateFields.push(`run_at = NOW()`);
+        } else {
+          updateFields.push(`run_at = $${paramIdx++}`);
+          params.push(updates.runAt);
+        }
+      }
+      if (updates.timeoutMs !== void 0) {
+        updateFields.push(`timeout_ms = $${paramIdx++}`);
+        params.push(updates.timeoutMs ?? null);
+      }
+      if (updates.tags !== void 0) {
+        updateFields.push(`tags = $${paramIdx++}`);
+        params.push(updates.tags ?? null);
+      }
+      if (updateFields.length === 0) {
+        log(`No fields to update for batch edit`);
+        return 0;
+      }
+      updateFields.push(`updated_at = NOW()`);
+      let query = `
+        UPDATE job_queue
+        SET ${updateFields.join(", ")}
+        WHERE status = 'pending'`;
+      if (filters) {
+        if (filters.jobType) {
+          query += ` AND job_type = $${paramIdx++}`;
+          params.push(filters.jobType);
+        }
+        if (filters.priority !== void 0) {
+          query += ` AND priority = $${paramIdx++}`;
+          params.push(filters.priority);
+        }
+        if (filters.runAt) {
+          if (filters.runAt instanceof Date) {
+            query += ` AND run_at = $${paramIdx++}`;
+            params.push(filters.runAt);
+          } else if (typeof filters.runAt === "object") {
+            const ops = filters.runAt;
+            if (ops.gt) {
+              query += ` AND run_at > $${paramIdx++}`;
+              params.push(ops.gt);
+            }
+            if (ops.gte) {
+              query += ` AND run_at >= $${paramIdx++}`;
+              params.push(ops.gte);
+            }
+            if (ops.lt) {
+              query += ` AND run_at < $${paramIdx++}`;
+              params.push(ops.lt);
+            }
+            if (ops.lte) {
+              query += ` AND run_at <= $${paramIdx++}`;
+              params.push(ops.lte);
+            }
+            if (ops.eq) {
+              query += ` AND run_at = $${paramIdx++}`;
+              params.push(ops.eq);
+            }
+          }
+        }
+        if (filters.tags && filters.tags.values && filters.tags.values.length > 0) {
+          const mode = filters.tags.mode || "all";
+          const tagValues = filters.tags.values;
+          switch (mode) {
+            case "exact":
+              query += ` AND tags = $${paramIdx++}`;
+              params.push(tagValues);
+              break;
+            case "all":
+              query += ` AND tags @> $${paramIdx++}`;
+              params.push(tagValues);
+              break;
+            case "any":
+              query += ` AND tags && $${paramIdx++}`;
+              params.push(tagValues);
+              break;
+            case "none":
+              query += ` AND NOT (tags && $${paramIdx++})`;
+              params.push(tagValues);
+              break;
+            default:
+              query += ` AND tags @> $${paramIdx++}`;
+              params.push(tagValues);
+          }
+        }
+      }
+      query += "\nRETURNING id";
+      const result = await client.query(query, params);
+      const editedCount = result.rowCount || 0;
+      const metadata = {};
+      if (updates.payload !== void 0) metadata.payload = updates.payload;
+      if (updates.maxAttempts !== void 0)
+        metadata.maxAttempts = updates.maxAttempts;
+      if (updates.priority !== void 0) metadata.priority = updates.priority;
+      if (updates.runAt !== void 0) metadata.runAt = updates.runAt;
+      if (updates.timeoutMs !== void 0)
+        metadata.timeoutMs = updates.timeoutMs;
+      if (updates.tags !== void 0) metadata.tags = updates.tags;
+      for (const row of result.rows) {
+        await this.recordJobEvent(row.id, "edited" /* Edited */, metadata);
+      }
+      log(`Edited ${editedCount} pending jobs: ${JSON.stringify(metadata)}`);
+      return editedCount;
+    } catch (error) {
+      log(`Error editing pending jobs: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async cleanupOldJobs(daysToKeep = 30) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `
+        DELETE FROM job_queue
+        WHERE status = 'completed'
+        AND updated_at < NOW() - INTERVAL '1 day' * $1::int
+        RETURNING id
+      `,
+        [daysToKeep]
+      );
+      log(`Deleted ${result.rowCount} old jobs`);
+      return result.rowCount || 0;
+    } catch (error) {
+      log(`Error cleaning up old jobs: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async cleanupOldJobEvents(daysToKeep = 30) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `
+        DELETE FROM job_events
+        WHERE created_at < NOW() - INTERVAL '1 day' * $1::int
+        RETURNING id
+      `,
+        [daysToKeep]
+      );
+      log(`Deleted ${result.rowCount} old job events`);
+      return result.rowCount || 0;
+    } catch (error) {
+      log(`Error cleaning up old job events: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async reclaimStuckJobs(maxProcessingTimeMinutes = 10) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `
+        UPDATE job_queue
+        SET status = 'pending', locked_at = NULL, locked_by = NULL, updated_at = NOW()
+        WHERE status = 'processing'
+          AND locked_at < NOW() - GREATEST(
+            INTERVAL '1 minute' * $1::int,
+            INTERVAL '1 millisecond' * COALESCE(timeout_ms, 0)
+          )
+        RETURNING id
+        `,
+        [maxProcessingTimeMinutes]
+      );
+      log(`Reclaimed ${result.rowCount} stuck jobs`);
+      return result.rowCount || 0;
+    } catch (error) {
+      log(`Error reclaiming stuck jobs: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  // ── Internal helpers ──────────────────────────────────────────────────
+  /**
+   * Batch-insert multiple job events in a single query.
+   * More efficient than individual recordJobEvent calls.
+   */
+  async recordJobEventsBatch(events) {
+    if (events.length === 0) return;
+    const client = await this.pool.connect();
+    try {
+      const values = [];
+      const params = [];
+      let paramIdx = 1;
+      for (const event of events) {
+        values.push(`($${paramIdx++}, $${paramIdx++}, $${paramIdx++})`);
+        params.push(
+          event.jobId,
+          event.eventType,
+          event.metadata ? JSON.stringify(event.metadata) : null
+        );
+      }
+      await client.query(
+        `INSERT INTO job_events (job_id, event_type, metadata) VALUES ${values.join(", ")}`,
+        params
+      );
+    } catch (error) {
+      log(`Error recording batch job events: ${error}`);
+    } finally {
+      client.release();
+    }
+  }
+  // ── Cron schedules ──────────────────────────────────────────────────
+  /** Create a cron schedule and return its ID. */
+  async addCronSchedule(input) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `INSERT INTO cron_schedules
+          (schedule_name, cron_expression, job_type, payload, max_attempts,
+           priority, timeout_ms, force_kill_on_timeout, tags, timezone,
+           allow_overlap, next_run_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+         RETURNING id`,
+        [
+          input.scheduleName,
+          input.cronExpression,
+          input.jobType,
+          input.payload,
+          input.maxAttempts,
+          input.priority,
+          input.timeoutMs,
+          input.forceKillOnTimeout,
+          input.tags ?? null,
+          input.timezone,
+          input.allowOverlap,
+          input.nextRunAt
+        ]
+      );
+      const id = result.rows[0].id;
+      log(`Added cron schedule ${id}: "${input.scheduleName}"`);
+      return id;
+    } catch (error) {
+      if (error?.code === "23505") {
+        throw new Error(
+          `Cron schedule with name "${input.scheduleName}" already exists`
+        );
+      }
+      log(`Error adding cron schedule: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /** Get a cron schedule by ID. */
+  async getCronSchedule(id) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `SELECT id, schedule_name AS "scheduleName", cron_expression AS "cronExpression",
+                job_type AS "jobType", payload, max_attempts AS "maxAttempts",
+                priority, timeout_ms AS "timeoutMs",
+                force_kill_on_timeout AS "forceKillOnTimeout", tags,
+                timezone, allow_overlap AS "allowOverlap", status,
+                last_enqueued_at AS "lastEnqueuedAt", last_job_id AS "lastJobId",
+                next_run_at AS "nextRunAt",
+                created_at AS "createdAt", updated_at AS "updatedAt"
+         FROM cron_schedules WHERE id = $1`,
+        [id]
+      );
+      if (result.rows.length === 0) return null;
+      return result.rows[0];
+    } catch (error) {
+      log(`Error getting cron schedule ${id}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /** Get a cron schedule by its unique name. */
+  async getCronScheduleByName(name) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `SELECT id, schedule_name AS "scheduleName", cron_expression AS "cronExpression",
+                job_type AS "jobType", payload, max_attempts AS "maxAttempts",
+                priority, timeout_ms AS "timeoutMs",
+                force_kill_on_timeout AS "forceKillOnTimeout", tags,
+                timezone, allow_overlap AS "allowOverlap", status,
+                last_enqueued_at AS "lastEnqueuedAt", last_job_id AS "lastJobId",
+                next_run_at AS "nextRunAt",
+                created_at AS "createdAt", updated_at AS "updatedAt"
+         FROM cron_schedules WHERE schedule_name = $1`,
+        [name]
+      );
+      if (result.rows.length === 0) return null;
+      return result.rows[0];
+    } catch (error) {
+      log(`Error getting cron schedule by name "${name}": ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /** List cron schedules, optionally filtered by status. */
+  async listCronSchedules(status) {
+    const client = await this.pool.connect();
+    try {
+      let query = `SELECT id, schedule_name AS "scheduleName", cron_expression AS "cronExpression",
+                job_type AS "jobType", payload, max_attempts AS "maxAttempts",
+                priority, timeout_ms AS "timeoutMs",
+                force_kill_on_timeout AS "forceKillOnTimeout", tags,
+                timezone, allow_overlap AS "allowOverlap", status,
+                last_enqueued_at AS "lastEnqueuedAt", last_job_id AS "lastJobId",
+                next_run_at AS "nextRunAt",
+                created_at AS "createdAt", updated_at AS "updatedAt"
+         FROM cron_schedules`;
+      const params = [];
+      if (status) {
+        query += ` WHERE status = $1`;
+        params.push(status);
+      }
+      query += ` ORDER BY created_at ASC`;
+      const result = await client.query(query, params);
+      return result.rows;
+    } catch (error) {
+      log(`Error listing cron schedules: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /** Delete a cron schedule by ID. */
+  async removeCronSchedule(id) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(`DELETE FROM cron_schedules WHERE id = $1`, [id]);
+      log(`Removed cron schedule ${id}`);
+    } catch (error) {
+      log(`Error removing cron schedule ${id}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /** Pause a cron schedule. */
+  async pauseCronSchedule(id) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(
+        `UPDATE cron_schedules SET status = 'paused', updated_at = NOW() WHERE id = $1`,
+        [id]
+      );
+      log(`Paused cron schedule ${id}`);
+    } catch (error) {
+      log(`Error pausing cron schedule ${id}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /** Resume a paused cron schedule. */
+  async resumeCronSchedule(id) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(
+        `UPDATE cron_schedules SET status = 'active', updated_at = NOW() WHERE id = $1`,
+        [id]
+      );
+      log(`Resumed cron schedule ${id}`);
+    } catch (error) {
+      log(`Error resuming cron schedule ${id}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /** Edit a cron schedule. */
+  async editCronSchedule(id, updates, nextRunAt) {
+    const client = await this.pool.connect();
+    try {
+      const updateFields = [];
+      const params = [];
+      let paramIdx = 1;
+      if (updates.cronExpression !== void 0) {
+        updateFields.push(`cron_expression = $${paramIdx++}`);
+        params.push(updates.cronExpression);
+      }
+      if (updates.payload !== void 0) {
+        updateFields.push(`payload = $${paramIdx++}`);
+        params.push(updates.payload);
+      }
+      if (updates.maxAttempts !== void 0) {
+        updateFields.push(`max_attempts = $${paramIdx++}`);
+        params.push(updates.maxAttempts);
+      }
+      if (updates.priority !== void 0) {
+        updateFields.push(`priority = $${paramIdx++}`);
+        params.push(updates.priority);
+      }
+      if (updates.timeoutMs !== void 0) {
+        updateFields.push(`timeout_ms = $${paramIdx++}`);
+        params.push(updates.timeoutMs);
+      }
+      if (updates.forceKillOnTimeout !== void 0) {
+        updateFields.push(`force_kill_on_timeout = $${paramIdx++}`);
+        params.push(updates.forceKillOnTimeout);
+      }
+      if (updates.tags !== void 0) {
+        updateFields.push(`tags = $${paramIdx++}`);
+        params.push(updates.tags);
+      }
+      if (updates.timezone !== void 0) {
+        updateFields.push(`timezone = $${paramIdx++}`);
+        params.push(updates.timezone);
+      }
+      if (updates.allowOverlap !== void 0) {
+        updateFields.push(`allow_overlap = $${paramIdx++}`);
+        params.push(updates.allowOverlap);
+      }
+      if (nextRunAt !== void 0) {
+        updateFields.push(`next_run_at = $${paramIdx++}`);
+        params.push(nextRunAt);
+      }
+      if (updateFields.length === 0) {
+        log(`No fields to update for cron schedule ${id}`);
+        return;
+      }
+      updateFields.push(`updated_at = NOW()`);
+      params.push(id);
+      const query = `UPDATE cron_schedules SET ${updateFields.join(", ")} WHERE id = $${paramIdx}`;
+      await client.query(query, params);
+      log(`Edited cron schedule ${id}`);
+    } catch (error) {
+      log(`Error editing cron schedule ${id}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /**
+   * Atomically fetch all active cron schedules whose nextRunAt <= NOW().
+   * Uses FOR UPDATE SKIP LOCKED to prevent duplicate enqueuing across workers.
+   */
+  async getDueCronSchedules() {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `SELECT id, schedule_name AS "scheduleName", cron_expression AS "cronExpression",
+                job_type AS "jobType", payload, max_attempts AS "maxAttempts",
+                priority, timeout_ms AS "timeoutMs",
+                force_kill_on_timeout AS "forceKillOnTimeout", tags,
+                timezone, allow_overlap AS "allowOverlap", status,
+                last_enqueued_at AS "lastEnqueuedAt", last_job_id AS "lastJobId",
+                next_run_at AS "nextRunAt",
+                created_at AS "createdAt", updated_at AS "updatedAt"
+         FROM cron_schedules
+         WHERE status = 'active'
+           AND next_run_at IS NOT NULL
+           AND next_run_at <= NOW()
+         ORDER BY next_run_at ASC
+         FOR UPDATE SKIP LOCKED`
+      );
+      log(`Found ${result.rows.length} due cron schedules`);
+      return result.rows;
+    } catch (error) {
+      if (error?.code === "42P01") {
+        log("cron_schedules table does not exist, skipping cron enqueue");
+        return [];
+      }
+      log(`Error getting due cron schedules: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /**
+   * Update a cron schedule after a job has been enqueued.
+   * Sets lastEnqueuedAt, lastJobId, and advances nextRunAt.
+   */
+  async updateCronScheduleAfterEnqueue(id, lastEnqueuedAt, lastJobId, nextRunAt) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(
+        `UPDATE cron_schedules
+         SET last_enqueued_at = $2,
+             last_job_id = $3,
+             next_run_at = $4,
+             updated_at = NOW()
+         WHERE id = $1`,
+        [id, lastEnqueuedAt, lastJobId, nextRunAt]
+      );
+      log(
+        `Updated cron schedule ${id}: lastJobId=${lastJobId}, nextRunAt=${nextRunAt?.toISOString() ?? "null"}`
+      );
+    } catch (error) {
+      log(`Error updating cron schedule ${id} after enqueue: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  // ── Internal helpers ──────────────────────────────────────────────────
+  async setPendingReasonForUnpickedJobs(reason, jobType) {
+    const client = await this.pool.connect();
+    try {
+      let jobTypeFilter = "";
+      const params = [reason];
+      if (jobType) {
+        if (Array.isArray(jobType)) {
+          jobTypeFilter = ` AND job_type = ANY($2)`;
+          params.push(jobType);
+        } else {
+          jobTypeFilter = ` AND job_type = $2`;
+          params.push(jobType);
+        }
+      }
+      await client.query(
+        `UPDATE job_queue SET pending_reason = $1 WHERE status = 'pending'${jobTypeFilter}`,
+        params
+      );
+    } finally {
+      client.release();
+    }
+  }
+};
+var recordJobEvent = async (pool, jobId, eventType, metadata) => new PostgresBackend(pool).recordJobEvent(jobId, eventType, metadata);
+var waitJob = async (pool, jobId, options) => {
+  const client = await pool.connect();
+  try {
+    const result = await client.query(
+      `
+      UPDATE job_queue
+      SET status = 'waiting',
+          wait_until = $2,
+          wait_token_id = $3,
+          step_data = $4,
+          locked_at = NULL,
+          locked_by = NULL,
+          updated_at = NOW()
+      WHERE id = $1 AND status = 'processing'
+    `,
+      [
+        jobId,
+        options.waitUntil ?? null,
+        options.waitTokenId ?? null,
+        JSON.stringify(options.stepData)
+      ]
+    );
+    if (result.rowCount === 0) {
+      log(
+        `Job ${jobId} could not be set to waiting (may have been reclaimed or is no longer processing)`
+      );
+      return;
+    }
+    await recordJobEvent(pool, jobId, "waiting" /* Waiting */, {
+      waitUntil: options.waitUntil?.toISOString() ?? null,
+      waitTokenId: options.waitTokenId ?? null
+    });
+    log(`Job ${jobId} set to waiting`);
+  } catch (error) {
+    log(`Error setting job ${jobId} to waiting: ${error}`);
+    throw error;
+  } finally {
+    client.release();
+  }
+};
+var updateStepData = async (pool, jobId, stepData) => {
+  const client = await pool.connect();
+  try {
+    await client.query(
+      `UPDATE job_queue SET step_data = $2, updated_at = NOW() WHERE id = $1`,
+      [jobId, JSON.stringify(stepData)]
+    );
+  } catch (error) {
+    log(`Error updating step_data for job ${jobId}: ${error}`);
+  } finally {
+    client.release();
+  }
+};
+var MAX_TIMEOUT_MS = 365 * 24 * 60 * 60 * 1e3;
+function parseTimeoutString(timeout) {
+  const match = timeout.match(/^(\d+)(s|m|h|d)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid timeout format: "${timeout}". Expected format like "10m", "1h", "24h", "7d".`
+    );
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  let ms;
+  switch (unit) {
+    case "s":
+      ms = value * 1e3;
+      break;
+    case "m":
+      ms = value * 60 * 1e3;
+      break;
+    case "h":
+      ms = value * 60 * 60 * 1e3;
+      break;
+    case "d":
+      ms = value * 24 * 60 * 60 * 1e3;
+      break;
+    default:
+      throw new Error(`Unknown timeout unit: "${unit}"`);
+  }
+  if (!Number.isFinite(ms) || ms > MAX_TIMEOUT_MS) {
+    throw new Error(
+      `Timeout value "${timeout}" is too large. Maximum allowed is 365 days.`
+    );
+  }
+  return ms;
+}
+var createWaitpoint = async (pool, jobId, options) => {
+  const client = await pool.connect();
+  try {
+    const id = `wp_${randomUUID()}`;
+    let timeoutAt = null;
+    if (options?.timeout) {
+      const ms = parseTimeoutString(options.timeout);
+      timeoutAt = new Date(Date.now() + ms);
+    }
+    await client.query(
+      `INSERT INTO waitpoints (id, job_id, status, timeout_at, tags) VALUES ($1, $2, 'waiting', $3, $4)`,
+      [id, jobId, timeoutAt, options?.tags ?? null]
+    );
+    log(`Created waitpoint ${id} for job ${jobId}`);
+    return { id };
+  } catch (error) {
+    log(`Error creating waitpoint: ${error}`);
+    throw error;
+  } finally {
+    client.release();
+  }
+};
+var completeWaitpoint = async (pool, tokenId, data) => {
+  const client = await pool.connect();
+  try {
+    await client.query("BEGIN");
+    const wpResult = await client.query(
+      `UPDATE waitpoints SET status = 'completed', output = $2, completed_at = NOW()
+       WHERE id = $1 AND status = 'waiting'
+       RETURNING job_id`,
+      [tokenId, data != null ? JSON.stringify(data) : null]
+    );
+    if (wpResult.rows.length === 0) {
+      await client.query("ROLLBACK");
+      log(`Waitpoint ${tokenId} not found or already completed`);
+      return;
+    }
+    const jobId = wpResult.rows[0].job_id;
+    if (jobId != null) {
+      await client.query(
+        `UPDATE job_queue
+         SET status = 'pending', wait_token_id = NULL, wait_until = NULL, updated_at = NOW()
+         WHERE id = $1 AND status = 'waiting'`,
+        [jobId]
+      );
+    }
+    await client.query("COMMIT");
+    log(`Completed waitpoint ${tokenId} for job ${jobId}`);
+  } catch (error) {
+    await client.query("ROLLBACK");
+    log(`Error completing waitpoint ${tokenId}: ${error}`);
+    throw error;
+  } finally {
+    client.release();
+  }
+};
+var getWaitpoint = async (pool, tokenId) => {
+  const client = await pool.connect();
+  try {
+    const result = await client.query(
+      `SELECT id, job_id AS "jobId", status, output, timeout_at AS "timeoutAt", created_at AS "createdAt", completed_at AS "completedAt", tags FROM waitpoints WHERE id = $1`,
+      [tokenId]
+    );
+    if (result.rows.length === 0) return null;
+    return result.rows[0];
+  } catch (error) {
+    log(`Error getting waitpoint ${tokenId}: ${error}`);
+    throw error;
+  } finally {
+    client.release();
+  }
+};
+var expireTimedOutWaitpoints = async (pool) => {
+  const client = await pool.connect();
+  try {
+    await client.query("BEGIN");
+    const result = await client.query(
+      `UPDATE waitpoints
+       SET status = 'timed_out'
+       WHERE status = 'waiting' AND timeout_at IS NOT NULL AND timeout_at <= NOW()
+       RETURNING id, job_id`
+    );
+    for (const row of result.rows) {
+      if (row.job_id != null) {
+        await client.query(
+          `UPDATE job_queue
+           SET status = 'pending', wait_token_id = NULL, wait_until = NULL, updated_at = NOW()
+           WHERE id = $1 AND status = 'waiting'`,
+          [row.job_id]
+        );
+      }
+    }
+    await client.query("COMMIT");
+    const count = result.rowCount || 0;
+    if (count > 0) {
+      log(`Expired ${count} timed-out waitpoints`);
+    }
+    return count;
+  } catch (error) {
+    await client.query("ROLLBACK");
+    log(`Error expiring timed-out waitpoints: ${error}`);
+    throw error;
+  } finally {
+    client.release();
+  }
+};
+function tryExtractPool(backend) {
+  if (backend instanceof PostgresBackend) {
+    return backend.getPool();
+  }
+  return null;
+}
+function buildBasicContext(backend, jobId, baseCtx) {
+  const waitError = () => new Error(
+    "Wait features (waitFor, waitUntil, createToken, waitForToken, ctx.run) are currently only supported with the PostgreSQL backend."
+  );
+  return {
+    prolong: baseCtx.prolong,
+    onTimeout: baseCtx.onTimeout,
+    run: async (_stepName, fn) => {
+      return fn();
+    },
+    waitFor: async () => {
+      throw waitError();
+    },
+    waitUntil: async () => {
+      throw waitError();
+    },
+    createToken: async () => {
+      throw waitError();
+    },
+    waitForToken: async () => {
+      throw waitError();
+    },
+    setProgress: async (percent) => {
+      if (percent < 0 || percent > 100)
+        throw new Error("Progress must be between 0 and 100");
+      await backend.updateProgress(jobId, Math.round(percent));
+    }
+  };
+}
+function validateHandlerSerializable(handler, jobType) {
+  try {
+    const handlerString = handler.toString();
+    if (handlerString.includes("this.") && !handlerString.match(/\([^)]*this[^)]*\)/)) {
+      throw new Error(
+        `Handler for job type "${jobType}" uses 'this' context which cannot be serialized. Use a regular function or avoid 'this' references when forceKillOnTimeout is enabled.`
+      );
+    }
+    if (handlerString.includes("[native code]")) {
+      throw new Error(
+        `Handler for job type "${jobType}" contains native code which cannot be serialized. Ensure your handler is a plain function when forceKillOnTimeout is enabled.`
+      );
+    }
+    try {
+      new Function("return " + handlerString);
+    } catch (parseError) {
+      throw new Error(
+        `Handler for job type "${jobType}" cannot be serialized: ${parseError instanceof Error ? parseError.message : String(parseError)}. When using forceKillOnTimeout, handlers must be serializable functions without closures over external variables.`
+      );
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error(
+      `Failed to validate handler serialization for job type "${jobType}": ${String(error)}`
+    );
+  }
+}
+async function runHandlerInWorker(handler, payload, timeoutMs, jobType) {
+  validateHandlerSerializable(handler, jobType);
+  return new Promise((resolve, reject) => {
+    const workerCode = `
+      (function() {
+        const { parentPort, workerData } = require('worker_threads');
+        const { handlerCode, payload, timeoutMs } = workerData;
+        
+        // Create an AbortController for the handler
+        const controller = new AbortController();
+        const signal = controller.signal;
+        
+        // Set up timeout
+        const timeoutId = setTimeout(() => {
+          controller.abort();
+          parentPort.postMessage({ type: 'timeout' });
+        }, timeoutMs);
+        
+        try {
+          // Execute the handler
+          // Note: This uses Function constructor which requires the handler to be serializable.
+          // The handler should be validated before reaching this point.
+          let handlerFn;
+          try {
+            // Wrap handlerCode in parentheses to ensure it's treated as an expression
+            // This handles both arrow functions and regular functions
+            const wrappedCode = handlerCode.trim().startsWith('async') || handlerCode.trim().startsWith('function')
+              ? handlerCode
+              : '(' + handlerCode + ')';
+            handlerFn = new Function('return ' + wrappedCode)();
+          } catch (parseError) {
+            clearTimeout(timeoutId);
+            parentPort.postMessage({
+              type: 'error',
+              error: {
+                message: 'Handler cannot be deserialized in worker thread. ' +
+                  'Ensure your handler is a standalone function without closures over external variables. ' +
+                  'Original error: ' + (parseError instanceof Error ? parseError.message : String(parseError)),
+                stack: parseError instanceof Error ? parseError.stack : undefined,
+                name: 'SerializationError',
+              },
+            });
+            return;
+          }
+          
+          // Ensure handlerFn is actually a function
+          if (typeof handlerFn !== 'function') {
+            clearTimeout(timeoutId);
+            parentPort.postMessage({
+              type: 'error',
+              error: {
+                message: 'Handler deserialization did not produce a function. ' +
+                  'Ensure your handler is a valid function when forceKillOnTimeout is enabled.',
+                name: 'SerializationError',
+              },
+            });
+            return;
+          }
+          
+          handlerFn(payload, signal)
+            .then(() => {
+              clearTimeout(timeoutId);
+              parentPort.postMessage({ type: 'success' });
+            })
+            .catch((error) => {
+              clearTimeout(timeoutId);
+              parentPort.postMessage({
+                type: 'error',
+                error: {
+                  message: error.message,
+                  stack: error.stack,
+                  name: error.name,
+                },
+              });
+            });
+        } catch (error) {
+          clearTimeout(timeoutId);
+          parentPort.postMessage({
+            type: 'error',
+            error: {
+              message: error.message,
+              stack: error.stack,
+              name: error.name,
+            },
+          });
+        }
+      })();
+    `;
+    const worker = new Worker(workerCode, {
+      eval: true,
+      workerData: {
+        handlerCode: handler.toString(),
+        payload,
+        timeoutMs
+      }
+    });
+    let resolved = false;
+    worker.on("message", (message) => {
+      if (resolved) return;
+      resolved = true;
+      if (message.type === "success") {
+        resolve();
+      } else if (message.type === "timeout") {
+        const timeoutError = new Error(
+          `Job timed out after ${timeoutMs} ms and was forcefully terminated`
+        );
+        timeoutError.failureReason = "timeout" /* Timeout */;
+        reject(timeoutError);
+      } else if (message.type === "error") {
+        const error = new Error(message.error.message);
+        error.stack = message.error.stack;
+        error.name = message.error.name;
+        reject(error);
+      }
+    });
+    worker.on("error", (error) => {
+      if (resolved) return;
+      resolved = true;
+      reject(error);
+    });
+    worker.on("exit", (code) => {
+      if (resolved) return;
+      if (code !== 0) {
+        resolved = true;
+        reject(new Error(`Worker stopped with exit code ${code}`));
+      }
+    });
+    setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        worker.terminate().then(() => {
+          const timeoutError = new Error(
+            `Job timed out after ${timeoutMs} ms and was forcefully terminated`
+          );
+          timeoutError.failureReason = "timeout" /* Timeout */;
+          reject(timeoutError);
+        }).catch((err) => {
+          reject(err);
+        });
+      }
+    }, timeoutMs + 100);
+  });
+}
+function calculateWaitUntil(duration) {
+  const now = Date.now();
+  let ms = 0;
+  if (duration.seconds) ms += duration.seconds * 1e3;
+  if (duration.minutes) ms += duration.minutes * 60 * 1e3;
+  if (duration.hours) ms += duration.hours * 60 * 60 * 1e3;
+  if (duration.days) ms += duration.days * 24 * 60 * 60 * 1e3;
+  if (duration.weeks) ms += duration.weeks * 7 * 24 * 60 * 60 * 1e3;
+  if (duration.months) ms += duration.months * 30 * 24 * 60 * 60 * 1e3;
+  if (duration.years) ms += duration.years * 365 * 24 * 60 * 60 * 1e3;
+  if (ms <= 0) {
+    throw new Error(
+      "waitFor duration must be positive. Provide at least one positive duration field."
+    );
+  }
+  return new Date(now + ms);
+}
+async function resolveCompletedWaits(pool, stepData) {
+  for (const key of Object.keys(stepData)) {
+    if (!key.startsWith("__wait_")) continue;
+    const entry = stepData[key];
+    if (!entry || typeof entry !== "object" || entry.completed) continue;
+    if (entry.type === "duration" || entry.type === "date") {
+      stepData[key] = { ...entry, completed: true };
+    } else if (entry.type === "token" && entry.tokenId) {
+      const wp = await getWaitpoint(pool, entry.tokenId);
+      if (wp && wp.status === "completed") {
+        stepData[key] = {
+          ...entry,
+          completed: true,
+          result: { ok: true, output: wp.output }
+        };
+      } else if (wp && wp.status === "timed_out") {
+        stepData[key] = {
+          ...entry,
+          completed: true,
+          result: { ok: false, error: "Token timed out" }
+        };
+      }
+    }
+  }
+}
+function buildWaitContext(backend, pool, jobId, stepData, baseCtx) {
+  let waitCounter = 0;
+  const ctx = {
+    prolong: baseCtx.prolong,
+    onTimeout: baseCtx.onTimeout,
+    run: async (stepName, fn) => {
+      const cached = stepData[stepName];
+      if (cached && typeof cached === "object" && cached.__completed) {
+        log(`Step "${stepName}" replayed from cache for job ${jobId}`);
+        return cached.result;
+      }
+      const result = await fn();
+      stepData[stepName] = { __completed: true, result };
+      await updateStepData(pool, jobId, stepData);
+      return result;
+    },
+    waitFor: async (duration) => {
+      const waitKey = `__wait_${waitCounter++}`;
+      const cached = stepData[waitKey];
+      if (cached && typeof cached === "object" && cached.completed) {
+        log(`Wait "${waitKey}" already completed for job ${jobId}, skipping`);
+        return;
+      }
+      const waitUntilDate = calculateWaitUntil(duration);
+      stepData[waitKey] = { type: "duration", completed: false };
+      throw new WaitSignal("duration", waitUntilDate, void 0, stepData);
+    },
+    waitUntil: async (date) => {
+      const waitKey = `__wait_${waitCounter++}`;
+      const cached = stepData[waitKey];
+      if (cached && typeof cached === "object" && cached.completed) {
+        log(`Wait "${waitKey}" already completed for job ${jobId}, skipping`);
+        return;
+      }
+      stepData[waitKey] = { type: "date", completed: false };
+      throw new WaitSignal("date", date, void 0, stepData);
+    },
+    createToken: async (options) => {
+      const token = await createWaitpoint(pool, jobId, options);
+      return token;
+    },
+    waitForToken: async (tokenId) => {
+      const waitKey = `__wait_${waitCounter++}`;
+      const cached = stepData[waitKey];
+      if (cached && typeof cached === "object" && cached.completed) {
+        log(
+          `Token wait "${waitKey}" already completed for job ${jobId}, returning cached result`
+        );
+        return cached.result;
+      }
+      const wp = await getWaitpoint(pool, tokenId);
+      if (wp && wp.status === "completed") {
+        const result = {
+          ok: true,
+          output: wp.output
+        };
+        stepData[waitKey] = {
+          type: "token",
+          tokenId,
+          completed: true,
+          result
+        };
+        await updateStepData(pool, jobId, stepData);
+        return result;
+      }
+      if (wp && wp.status === "timed_out") {
+        const result = {
+          ok: false,
+          error: "Token timed out"
+        };
+        stepData[waitKey] = {
+          type: "token",
+          tokenId,
+          completed: true,
+          result
+        };
+        await updateStepData(pool, jobId, stepData);
+        return result;
+      }
+      stepData[waitKey] = { type: "token", tokenId, completed: false };
+      throw new WaitSignal("token", void 0, tokenId, stepData);
+    },
+    setProgress: async (percent) => {
+      if (percent < 0 || percent > 100)
+        throw new Error("Progress must be between 0 and 100");
+      await backend.updateProgress(jobId, Math.round(percent));
+    }
+  };
+  return ctx;
+}
+async function processJobWithHandlers(backend, job, jobHandlers) {
+  const handler = jobHandlers[job.jobType];
+  if (!handler) {
+    await backend.setPendingReasonForUnpickedJobs(
+      `No handler registered for job type: ${job.jobType}`,
+      job.jobType
+    );
+    await backend.failJob(
+      job.id,
+      new Error(`No handler registered for job type: ${job.jobType}`),
+      "no_handler" /* NoHandler */
+    );
+    return;
+  }
+  const stepData = { ...job.stepData || {} };
+  const pool = tryExtractPool(backend);
+  const hasStepHistory = Object.keys(stepData).some(
+    (k) => k.startsWith("__wait_")
+  );
+  if (hasStepHistory && pool) {
+    await resolveCompletedWaits(pool, stepData);
+    await updateStepData(pool, job.id, stepData);
+  }
+  const timeoutMs = job.timeoutMs ?? void 0;
+  const forceKillOnTimeout = job.forceKillOnTimeout ?? false;
+  let timeoutId;
+  const controller = new AbortController();
+  try {
+    if (forceKillOnTimeout && timeoutMs && timeoutMs > 0) {
+      await runHandlerInWorker(handler, job.payload, timeoutMs, job.jobType);
+    } else {
+      let onTimeoutCallback;
+      let timeoutReject;
+      const armTimeout = (ms) => {
+        if (timeoutId) clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => {
+          if (onTimeoutCallback) {
+            try {
+              const extension = onTimeoutCallback();
+              if (typeof extension === "number" && extension > 0) {
+                backend.prolongJob(job.id).catch(() => {
+                });
+                armTimeout(extension);
+                return;
+              }
+            } catch (callbackError) {
+              log(
+                `onTimeout callback threw for job ${job.id}: ${callbackError}`
+              );
+            }
+          }
+          controller.abort();
+          const timeoutError = new Error(`Job timed out after ${ms} ms`);
+          timeoutError.failureReason = "timeout" /* Timeout */;
+          if (timeoutReject) {
+            timeoutReject(timeoutError);
+          }
+        }, ms);
+      };
+      const hasTimeout = timeoutMs != null && timeoutMs > 0;
+      const baseCtx = hasTimeout ? {
+        prolong: (ms) => {
+          const duration = ms ?? timeoutMs;
+          if (duration != null && duration > 0) {
+            armTimeout(duration);
+            backend.prolongJob(job.id).catch(() => {
+            });
+          }
+        },
+        onTimeout: (callback) => {
+          onTimeoutCallback = callback;
+        }
+      } : {
+        prolong: () => {
+          log("prolong() called but ignored: job has no timeout set");
+        },
+        onTimeout: () => {
+          log("onTimeout() called but ignored: job has no timeout set");
+        }
+      };
+      const ctx = pool ? buildWaitContext(backend, pool, job.id, stepData, baseCtx) : buildBasicContext(backend, job.id, baseCtx);
+      if (forceKillOnTimeout && !hasTimeout) {
+        log(
+          `forceKillOnTimeout is set but no timeoutMs for job ${job.id}, running without force kill`
+        );
+      }
+      const jobPromise = handler(job.payload, controller.signal, ctx);
+      if (hasTimeout) {
+        await Promise.race([
+          jobPromise,
+          new Promise((_, reject) => {
+            timeoutReject = reject;
+            armTimeout(timeoutMs);
+          })
+        ]);
+      } else {
+        await jobPromise;
+      }
+    }
+    if (timeoutId) clearTimeout(timeoutId);
+    await backend.completeJob(job.id);
+  } catch (error) {
+    if (timeoutId) clearTimeout(timeoutId);
+    if (error instanceof WaitSignal) {
+      if (!pool) {
+        await backend.failJob(
+          job.id,
+          new Error(
+            "WaitSignal received but wait features require the PostgreSQL backend."
+          ),
+          "handler_error" /* HandlerError */
+        );
+        return;
+      }
+      log(
+        `Job ${job.id} entering wait: type=${error.type}, waitUntil=${error.waitUntil?.toISOString() ?? "none"}, tokenId=${error.tokenId ?? "none"}`
+      );
+      await waitJob(pool, job.id, {
+        waitUntil: error.waitUntil,
+        waitTokenId: error.tokenId,
+        stepData: error.stepData
+      });
+      return;
+    }
+    console.error(`Error processing job ${job.id}:`, error);
+    let failureReason = "handler_error" /* HandlerError */;
+    if (error && typeof error === "object" && "failureReason" in error && error.failureReason === "timeout" /* Timeout */) {
+      failureReason = "timeout" /* Timeout */;
+    }
+    await backend.failJob(
+      job.id,
+      error instanceof Error ? error : new Error(String(error)),
+      failureReason
+    );
+  }
+}
+async function processBatchWithHandlers(backend, workerId, batchSize, jobType, jobHandlers, concurrency, onError) {
+  const jobs = await backend.getNextBatch(
+    workerId,
+    batchSize,
+    jobType
+  );
+  if (!concurrency || concurrency >= jobs.length) {
+    await Promise.all(
+      jobs.map((job) => processJobWithHandlers(backend, job, jobHandlers))
+    );
+    return jobs.length;
+  }
+  let idx = 0;
+  let running = 0;
+  let finished = 0;
+  return new Promise((resolve, reject) => {
+    const next = () => {
+      if (finished === jobs.length) return resolve(jobs.length);
+      while (running < concurrency && idx < jobs.length) {
+        const job = jobs[idx++];
+        running++;
+        processJobWithHandlers(backend, job, jobHandlers).then(() => {
+          running--;
+          finished++;
+          next();
+        }).catch((err) => {
+          running--;
+          finished++;
+          if (onError) {
+            onError(err instanceof Error ? err : new Error(String(err)));
+          }
+          next();
+        });
+      }
+    };
+    next();
+  });
+}
+var createProcessor = (backend, handlers, options = {}, onBeforeBatch) => {
+  const {
+    workerId = `worker-${Math.random().toString(36).substring(2, 9)}`,
+    batchSize = 10,
+    pollInterval = 5e3,
+    onError = (error) => console.error("Job processor error:", error),
+    jobType,
+    concurrency = 3
+  } = options;
+  let running = false;
+  let intervalId = null;
+  let currentBatchPromise = null;
+  setLogContext(options.verbose ?? false);
+  const processJobs = async () => {
+    if (!running) return 0;
+    if (onBeforeBatch) {
+      try {
+        await onBeforeBatch();
+      } catch (hookError) {
+        log(`onBeforeBatch hook error: ${hookError}`);
+        if (onError) {
+          onError(
+            hookError instanceof Error ? hookError : new Error(String(hookError))
+          );
+        }
+      }
+    }
+    log(
+      `Processing jobs with workerId: ${workerId}${jobType ? ` and jobType: ${Array.isArray(jobType) ? jobType.join(",") : jobType}` : ""}`
+    );
+    try {
+      const processed = await processBatchWithHandlers(
+        backend,
+        workerId,
+        batchSize,
+        jobType,
+        handlers,
+        concurrency,
+        onError
+      );
+      return processed;
+    } catch (error) {
+      onError(error instanceof Error ? error : new Error(String(error)));
+    }
+    return 0;
+  };
+  return {
+    /**
+     * Start the job processor in the background.
+     * - This will run periodically (every pollInterval milliseconds or 5 seconds if not provided) and process jobs as they become available.
+     * - You have to call the stop method to stop the processor.
+     */
+    startInBackground: () => {
+      if (running) return;
+      log(`Starting job processor with workerId: ${workerId}`);
+      running = true;
+      const scheduleNext = (immediate) => {
+        if (!running) return;
+        if (immediate) {
+          intervalId = setTimeout(loop, 0);
+        } else {
+          intervalId = setTimeout(loop, pollInterval);
+        }
+      };
+      const loop = async () => {
+        if (!running) return;
+        currentBatchPromise = processJobs();
+        const processed = await currentBatchPromise;
+        currentBatchPromise = null;
+        scheduleNext(processed === batchSize);
+      };
+      loop();
+    },
+    /**
+     * Stop the job processor that runs in the background.
+     * Does not wait for in-flight jobs.
+     */
+    stop: () => {
+      log(`Stopping job processor with workerId: ${workerId}`);
+      running = false;
+      if (intervalId) {
+        clearTimeout(intervalId);
+        intervalId = null;
+      }
+    },
+    /**
+     * Stop the job processor and wait for all in-flight jobs to complete.
+     * Useful for graceful shutdown (e.g., SIGTERM handling).
+     */
+    stopAndDrain: async (drainTimeoutMs = 3e4) => {
+      log(`Stopping and draining job processor with workerId: ${workerId}`);
+      running = false;
+      if (intervalId) {
+        clearTimeout(intervalId);
+        intervalId = null;
+      }
+      if (currentBatchPromise) {
+        await Promise.race([
+          currentBatchPromise.catch(() => {
+          }),
+          new Promise((resolve) => setTimeout(resolve, drainTimeoutMs))
+        ]);
+        currentBatchPromise = null;
+      }
+      log(`Job processor ${workerId} drained`);
+    },
+    /**
+     * Start the job processor synchronously.
+     * - This will process all jobs immediately and then stop.
+     * - The pollInterval is ignored.
+     */
+    start: async () => {
+      log(`Starting job processor with workerId: ${workerId}`);
+      running = true;
+      const processed = await processJobs();
+      running = false;
+      return processed;
+    },
+    isRunning: () => running
+  };
+};
+function loadPemOrFile(value) {
+  if (!value) return void 0;
+  if (value.startsWith("file://")) {
+    const filePath = value.slice(7);
+    return fs.readFileSync(filePath, "utf8");
+  }
+  return value;
+}
+var createPool = (config) => {
+  let searchPath;
+  let ssl = void 0;
+  let customCA;
+  let sslmode;
+  if (config.connectionString) {
+    try {
+      const url = new URL(config.connectionString);
+      searchPath = url.searchParams.get("search_path") || void 0;
+      sslmode = url.searchParams.get("sslmode") || void 0;
+      if (sslmode === "no-verify") {
+        ssl = { rejectUnauthorized: false };
+      }
+    } catch (e) {
+      const parsed = parse(config.connectionString);
+      if (parsed.options) {
+        const match = parsed.options.match(/search_path=([^\s]+)/);
+        if (match) {
+          searchPath = match[1];
+        }
+      }
+      sslmode = typeof parsed.sslmode === "string" ? parsed.sslmode : void 0;
+      if (sslmode === "no-verify") {
+        ssl = { rejectUnauthorized: false };
+      }
+    }
+  }
+  if (config.ssl) {
+    if (typeof config.ssl.ca === "string") {
+      customCA = config.ssl.ca;
+    } else if (typeof process.env.PGSSLROOTCERT === "string") {
+      customCA = process.env.PGSSLROOTCERT;
+    } else {
+      customCA = void 0;
+    }
+    const caValue = typeof customCA === "string" ? loadPemOrFile(customCA) : void 0;
+    ssl = {
+      ...ssl,
+      ...caValue ? { ca: caValue } : {},
+      cert: loadPemOrFile(
+        typeof config.ssl.cert === "string" ? config.ssl.cert : process.env.PGSSLCERT
+      ),
+      key: loadPemOrFile(
+        typeof config.ssl.key === "string" ? config.ssl.key : process.env.PGSSLKEY
+      ),
+      rejectUnauthorized: config.ssl.rejectUnauthorized !== void 0 ? config.ssl.rejectUnauthorized : true
+    };
+  }
+  if (sslmode && customCA) {
+    const warning = `
+
+\x1B[33m**************************************************
+\u26A0\uFE0F  WARNING: SSL CONFIGURATION ISSUE
+**************************************************
+Both sslmode ('${sslmode}') is set in the connection string
+and a custom CA is provided (via config.ssl.ca or PGSSLROOTCERT).
+This combination may cause connection failures or unexpected behavior.
+
+Recommended: Remove sslmode from the connection string when using a custom CA.
+**************************************************\x1B[0m
+`;
+    console.warn(warning);
+  }
+  const pool = new Pool({
+    ...config,
+    ...ssl ? { ssl } : {}
+  });
+  if (searchPath) {
+    pool.on("connect", (client) => {
+      client.query(`SET search_path TO ${searchPath}`);
+    });
+  }
+  return pool;
+};
+
+// src/backends/redis-scripts.ts
+var SCORE_RANGE = "1000000000000000";
+var ADD_JOB_SCRIPT = `
+local prefix = KEYS[1]
+local jobType = ARGV[1]
+local payloadJson = ARGV[2]
+local maxAttempts = tonumber(ARGV[3])
+local priority = tonumber(ARGV[4])
+local runAtMs = ARGV[5]  -- "0" means now
+local timeoutMs = ARGV[6] -- "null" string if not set
+local forceKillOnTimeout = ARGV[7]
+local tagsJson = ARGV[8] -- "null" or JSON array string
+local idempotencyKey = ARGV[9] -- "null" string if not set
+local nowMs = tonumber(ARGV[10])
+
+-- Idempotency check
+if idempotencyKey ~= "null" then
+  local existing = redis.call('GET', prefix .. 'idempotency:' .. idempotencyKey)
+  if existing then
+    return existing
+  end
+end
+
+-- Generate ID
+local id = redis.call('INCR', prefix .. 'id_seq')
+local jobKey = prefix .. 'job:' .. id
+local runAt = runAtMs ~= "0" and tonumber(runAtMs) or nowMs
+
+-- Store the job hash
+redis.call('HMSET', jobKey,
+  'id', id,
+  'jobType', jobType,
+  'payload', payloadJson,
+  'status', 'pending',
+  'maxAttempts', maxAttempts,
+  'attempts', 0,
+  'priority', priority,
+  'runAt', runAt,
+  'timeoutMs', timeoutMs,
+  'forceKillOnTimeout', forceKillOnTimeout,
+  'createdAt', nowMs,
+  'updatedAt', nowMs,
+  'lockedAt', 'null',
+  'lockedBy', 'null',
+  'nextAttemptAt', 'null',
+  'pendingReason', 'null',
+  'errorHistory', '[]',
+  'failureReason', 'null',
+  'completedAt', 'null',
+  'startedAt', 'null',
+  'lastRetriedAt', 'null',
+  'lastFailedAt', 'null',
+  'lastCancelledAt', 'null',
+  'tags', tagsJson,
+  'idempotencyKey', idempotencyKey
+)
+
+-- Status index
+redis.call('SADD', prefix .. 'status:pending', id)
+
+-- Type index
+redis.call('SADD', prefix .. 'type:' .. jobType, id)
+
+-- Tag indexes
+if tagsJson ~= "null" then
+  local tags = cjson.decode(tagsJson)
+  for _, tag in ipairs(tags) do
+    redis.call('SADD', prefix .. 'tag:' .. tag, id)
+  end
+  -- Store tags for exact-match queries
+  for _, tag in ipairs(tags) do
+    redis.call('SADD', prefix .. 'job:' .. id .. ':tags', tag)
+  end
+end
+
+-- Idempotency mapping
+if idempotencyKey ~= "null" then
+  redis.call('SET', prefix .. 'idempotency:' .. idempotencyKey, id)
+end
+
+-- All-jobs sorted set (for ordering by createdAt)
+redis.call('ZADD', prefix .. 'all', nowMs, id)
+
+-- Queue or delayed
+if runAt <= nowMs then
+  -- Ready now: add to queue with priority score
+  local score = priority * ${SCORE_RANGE} + (${SCORE_RANGE} - nowMs)
+  redis.call('ZADD', prefix .. 'queue', score, id)
+else
+  -- Future: add to delayed set
+  redis.call('ZADD', prefix .. 'delayed', runAt, id)
+end
+
+return id
+`;
+var GET_NEXT_BATCH_SCRIPT = `
+local prefix = KEYS[1]
+local workerId = ARGV[1]
+local batchSize = tonumber(ARGV[2])
+local nowMs = tonumber(ARGV[3])
+local jobTypeFilter = ARGV[4] -- "null" or JSON array or single string
+
+-- 1. Move ready delayed jobs into queue
+local delayed = redis.call('ZRANGEBYSCORE', prefix .. 'delayed', '-inf', nowMs, 'LIMIT', 0, 200)
+for _, jobId in ipairs(delayed) do
+  local jk = prefix .. 'job:' .. jobId
+  local status = redis.call('HGET', jk, 'status')
+  local attempts = tonumber(redis.call('HGET', jk, 'attempts'))
+  local maxAttempts = tonumber(redis.call('HGET', jk, 'maxAttempts'))
+  if status == 'pending' and attempts < maxAttempts then
+    local pri = tonumber(redis.call('HGET', jk, 'priority') or '0')
+    local ca = tonumber(redis.call('HGET', jk, 'createdAt'))
+    local score = pri * ${SCORE_RANGE} + (${SCORE_RANGE} - ca)
+    redis.call('ZADD', prefix .. 'queue', score, jobId)
+  end
+  redis.call('ZREM', prefix .. 'delayed', jobId)
+end
+
+-- 2. Move ready retry jobs into queue
+local retries = redis.call('ZRANGEBYSCORE', prefix .. 'retry', '-inf', nowMs, 'LIMIT', 0, 200)
+for _, jobId in ipairs(retries) do
+  local jk = prefix .. 'job:' .. jobId
+  local status = redis.call('HGET', jk, 'status')
+  local attempts = tonumber(redis.call('HGET', jk, 'attempts'))
+  local maxAttempts = tonumber(redis.call('HGET', jk, 'maxAttempts'))
+  if status == 'failed' and attempts < maxAttempts then
+    local pri = tonumber(redis.call('HGET', jk, 'priority') or '0')
+    local ca = tonumber(redis.call('HGET', jk, 'createdAt'))
+    local score = pri * ${SCORE_RANGE} + (${SCORE_RANGE} - ca)
+    redis.call('ZADD', prefix .. 'queue', score, jobId)
+    redis.call('SREM', prefix .. 'status:failed', jobId)
+    redis.call('SADD', prefix .. 'status:pending', jobId)
+    redis.call('HMSET', jk, 'status', 'pending')
+  end
+  redis.call('ZREM', prefix .. 'retry', jobId)
+end
+
+-- 3. Parse job type filter
+local filterTypes = nil
+if jobTypeFilter ~= "null" then
+  -- Could be a JSON array or a plain string
+  local ok, decoded = pcall(cjson.decode, jobTypeFilter)
+  if ok and type(decoded) == 'table' then
+    filterTypes = {}
+    for _, t in ipairs(decoded) do filterTypes[t] = true end
+  else
+    filterTypes = { [jobTypeFilter] = true }
+  end
+end
+
+-- 4. Pop candidates from queue (highest score first)
+-- We pop more than batchSize because some may be filtered out
+local popCount = batchSize * 3
+local candidates = redis.call('ZPOPMAX', prefix .. 'queue', popCount)
+-- candidates: [member1, score1, member2, score2, ...]
+
+local results = {}
+local jobsClaimed = 0
+local putBack = {}   -- {score, id} pairs to put back
+
+for i = 1, #candidates, 2 do
+  local jobId = candidates[i]
+  local score = candidates[i + 1]
+  local jk = prefix .. 'job:' .. jobId
+
+  if jobsClaimed >= batchSize then
+    -- We have enough; put the rest back
+    table.insert(putBack, score)
+    table.insert(putBack, jobId)
+  else
+    -- Check job type filter
+    local jt = redis.call('HGET', jk, 'jobType')
+    if filterTypes and not filterTypes[jt] then
+      -- Doesn't match filter: put back
+      table.insert(putBack, score)
+      table.insert(putBack, jobId)
+    else
+      -- Check run_at
+      local runAt = tonumber(redis.call('HGET', jk, 'runAt'))
+      if runAt > nowMs then
+        -- Not ready yet: move to delayed
+        redis.call('ZADD', prefix .. 'delayed', runAt, jobId)
+      else
+        -- Claim this job
+        local attempts = tonumber(redis.call('HGET', jk, 'attempts'))
+        local startedAt = redis.call('HGET', jk, 'startedAt')
+        local lastRetriedAt = redis.call('HGET', jk, 'lastRetriedAt')
+        if startedAt == 'null' then startedAt = nowMs end
+        if attempts > 0 then lastRetriedAt = nowMs end
+
+        redis.call('HMSET', jk,
+          'status', 'processing',
+          'lockedAt', nowMs,
+          'lockedBy', workerId,
+          'attempts', attempts + 1,
+          'updatedAt', nowMs,
+          'pendingReason', 'null',
+          'startedAt', startedAt,
+          'lastRetriedAt', lastRetriedAt
+        )
+
+        -- Update status sets
+        redis.call('SREM', prefix .. 'status:pending', jobId)
+        redis.call('SADD', prefix .. 'status:processing', jobId)
+
+        -- Return job data as flat array
+        local data = redis.call('HGETALL', jk)
+        for _, v in ipairs(data) do
+          table.insert(results, v)
+        end
+        -- Separator
+        table.insert(results, '__JOB_SEP__')
+        jobsClaimed = jobsClaimed + 1
+      end
+    end
+  end
+end
+
+-- Put back jobs we didn't claim
+if #putBack > 0 then
+  redis.call('ZADD', prefix .. 'queue', unpack(putBack))
+end
+
+return results
+`;
+var COMPLETE_JOB_SCRIPT = `
+local prefix = KEYS[1]
+local jobId = ARGV[1]
+local nowMs = ARGV[2]
+local jk = prefix .. 'job:' .. jobId
+
+redis.call('HMSET', jk,
+  'status', 'completed',
+  'updatedAt', nowMs,
+  'completedAt', nowMs
+)
+redis.call('SREM', prefix .. 'status:processing', jobId)
+redis.call('SADD', prefix .. 'status:completed', jobId)
+
+return 1
+`;
+var FAIL_JOB_SCRIPT = `
+local prefix = KEYS[1]
+local jobId = ARGV[1]
+local errorJson = ARGV[2]
+local failureReason = ARGV[3]
+local nowMs = tonumber(ARGV[4])
+local jk = prefix .. 'job:' .. jobId
+
+local attempts = tonumber(redis.call('HGET', jk, 'attempts'))
+local maxAttempts = tonumber(redis.call('HGET', jk, 'maxAttempts'))
+
+-- Compute next_attempt_at: 2^attempts minutes from now
+local nextAttemptAt = 'null'
+if attempts < maxAttempts then
+  local delayMs = math.pow(2, attempts) * 60000
+  nextAttemptAt = nowMs + delayMs
+end
+
+-- Append to error_history
+local history = redis.call('HGET', jk, 'errorHistory') or '[]'
+local ok, arr = pcall(cjson.decode, history)
+if not ok then arr = {} end
+local newErrors = cjson.decode(errorJson)
+for _, e in ipairs(newErrors) do
+  table.insert(arr, e)
+end
+
+redis.call('HMSET', jk,
+  'status', 'failed',
+  'updatedAt', nowMs,
+  'nextAttemptAt', tostring(nextAttemptAt),
+  'errorHistory', cjson.encode(arr),
+  'failureReason', failureReason,
+  'lastFailedAt', nowMs
+)
+redis.call('SREM', prefix .. 'status:processing', jobId)
+redis.call('SADD', prefix .. 'status:failed', jobId)
+
+-- Schedule retry if applicable
+if nextAttemptAt ~= 'null' then
+  redis.call('ZADD', prefix .. 'retry', nextAttemptAt, jobId)
+end
+
+return 1
+`;
+var RETRY_JOB_SCRIPT = `
+local prefix = KEYS[1]
+local jobId = ARGV[1]
+local nowMs = tonumber(ARGV[2])
+local jk = prefix .. 'job:' .. jobId
+
+local oldStatus = redis.call('HGET', jk, 'status')
+
+redis.call('HMSET', jk,
+  'status', 'pending',
+  'updatedAt', nowMs,
+  'lockedAt', 'null',
+  'lockedBy', 'null',
+  'nextAttemptAt', nowMs,
+  'lastRetriedAt', nowMs
+)
+
+-- Remove from old status, add to pending
+if oldStatus then
+  redis.call('SREM', prefix .. 'status:' .. oldStatus, jobId)
+end
+redis.call('SADD', prefix .. 'status:pending', jobId)
+
+-- Remove from retry sorted set if present
+redis.call('ZREM', prefix .. 'retry', jobId)
+
+-- Add to queue (ready now)
+local priority = tonumber(redis.call('HGET', jk, 'priority') or '0')
+local createdAt = tonumber(redis.call('HGET', jk, 'createdAt'))
+local score = priority * ${SCORE_RANGE} + (${SCORE_RANGE} - createdAt)
+redis.call('ZADD', prefix .. 'queue', score, jobId)
+
+return 1
+`;
+var CANCEL_JOB_SCRIPT = `
+local prefix = KEYS[1]
+local jobId = ARGV[1]
+local nowMs = ARGV[2]
+local jk = prefix .. 'job:' .. jobId
+
+local status = redis.call('HGET', jk, 'status')
+if status ~= 'pending' then return 0 end
+
+redis.call('HMSET', jk,
+  'status', 'cancelled',
+  'updatedAt', nowMs,
+  'lastCancelledAt', nowMs
+)
+redis.call('SREM', prefix .. 'status:pending', jobId)
+redis.call('SADD', prefix .. 'status:cancelled', jobId)
+-- Remove from queue / delayed
+redis.call('ZREM', prefix .. 'queue', jobId)
+redis.call('ZREM', prefix .. 'delayed', jobId)
+
+return 1
+`;
+var PROLONG_JOB_SCRIPT = `
+local prefix = KEYS[1]
+local jobId = ARGV[1]
+local nowMs = ARGV[2]
+local jk = prefix .. 'job:' .. jobId
+
+local status = redis.call('HGET', jk, 'status')
+if status ~= 'processing' then return 0 end
+
+redis.call('HMSET', jk,
+  'lockedAt', nowMs,
+  'updatedAt', nowMs
+)
+
+return 1
+`;
+var RECLAIM_STUCK_JOBS_SCRIPT = `
+local prefix = KEYS[1]
+local maxAgeMs = tonumber(ARGV[1])
+local nowMs = tonumber(ARGV[2])
+
+local processing = redis.call('SMEMBERS', prefix .. 'status:processing')
+local count = 0
+
+for _, jobId in ipairs(processing) do
+  local jk = prefix .. 'job:' .. jobId
+  local lockedAt = redis.call('HGET', jk, 'lockedAt')
+  if lockedAt and lockedAt ~= 'null' then
+    local lockedAtNum = tonumber(lockedAt)
+    if lockedAtNum then
+      -- Use the greater of maxAgeMs and the job's own timeoutMs
+      local jobMaxAge = maxAgeMs
+      local timeoutMs = redis.call('HGET', jk, 'timeoutMs')
+      if timeoutMs and timeoutMs ~= 'null' then
+        local tMs = tonumber(timeoutMs)
+        if tMs and tMs > jobMaxAge then
+          jobMaxAge = tMs
+        end
+      end
+      local cutoff = nowMs - jobMaxAge
+      if lockedAtNum < cutoff then
+        redis.call('HMSET', jk,
+          'status', 'pending',
+          'lockedAt', 'null',
+          'lockedBy', 'null',
+          'updatedAt', nowMs
+        )
+        redis.call('SREM', prefix .. 'status:processing', jobId)
+        redis.call('SADD', prefix .. 'status:pending', jobId)
+
+        -- Re-add to queue
+        local priority = tonumber(redis.call('HGET', jk, 'priority') or '0')
+        local createdAt = tonumber(redis.call('HGET', jk, 'createdAt'))
+        local score = priority * ${SCORE_RANGE} + (${SCORE_RANGE} - createdAt)
+        redis.call('ZADD', prefix .. 'queue', score, jobId)
+
+        count = count + 1
+      end
+    end
+  end
+end
+
+return count
+`;
+var CLEANUP_OLD_JOBS_SCRIPT = `
+local prefix = KEYS[1]
+local cutoffMs = tonumber(ARGV[1])
+
+local completed = redis.call('SMEMBERS', prefix .. 'status:completed')
+local count = 0
+
+for _, jobId in ipairs(completed) do
+  local jk = prefix .. 'job:' .. jobId
+  local updatedAt = tonumber(redis.call('HGET', jk, 'updatedAt'))
+  if updatedAt and updatedAt < cutoffMs then
+    -- Remove all indexes
+    local jobType = redis.call('HGET', jk, 'jobType')
+    local tagsJson = redis.call('HGET', jk, 'tags')
+    local idempotencyKey = redis.call('HGET', jk, 'idempotencyKey')
+
+    redis.call('DEL', jk)
+    redis.call('SREM', prefix .. 'status:completed', jobId)
+    redis.call('ZREM', prefix .. 'all', jobId)
+    if jobType then
+      redis.call('SREM', prefix .. 'type:' .. jobType, jobId)
+    end
+    if tagsJson and tagsJson ~= 'null' then
+      local ok, tags = pcall(cjson.decode, tagsJson)
+      if ok and type(tags) == 'table' then
+        for _, tag in ipairs(tags) do
+          redis.call('SREM', prefix .. 'tag:' .. tag, jobId)
+        end
+      end
+      redis.call('DEL', prefix .. 'job:' .. jobId .. ':tags')
+    end
+    if idempotencyKey and idempotencyKey ~= 'null' then
+      redis.call('DEL', prefix .. 'idempotency:' .. idempotencyKey)
+    end
+    -- Delete events
+    redis.call('DEL', prefix .. 'events:' .. jobId)
+
+    count = count + 1
+  end
+end
+
+return count
+`;
+
+// src/backends/redis.ts
+function hashToObject(arr) {
+  const obj = {};
+  for (let i = 0; i < arr.length; i += 2) {
+    obj[arr[i]] = arr[i + 1];
+  }
+  return obj;
+}
+function deserializeJob(h) {
+  const nullish = (v) => v === void 0 || v === "null" || v === "" ? null : v;
+  const numOrNull = (v) => {
+    const n = nullish(v);
+    return n === null ? null : Number(n);
+  };
+  const dateOrNull = (v) => {
+    const n = numOrNull(v);
+    return n === null ? null : new Date(n);
+  };
+  let errorHistory = [];
+  try {
+    const raw = h.errorHistory;
+    if (raw && raw !== "[]") {
+      errorHistory = JSON.parse(raw);
+    }
+  } catch {
+  }
+  let tags;
+  try {
+    const raw = h.tags;
+    if (raw && raw !== "null") {
+      tags = JSON.parse(raw);
+    }
+  } catch {
+  }
+  let payload;
+  try {
+    payload = JSON.parse(h.payload);
+  } catch {
+    payload = h.payload;
+  }
+  return {
+    id: Number(h.id),
+    jobType: h.jobType,
+    payload,
+    status: h.status,
+    createdAt: new Date(Number(h.createdAt)),
+    updatedAt: new Date(Number(h.updatedAt)),
+    lockedAt: dateOrNull(h.lockedAt),
+    lockedBy: nullish(h.lockedBy),
+    attempts: Number(h.attempts),
+    maxAttempts: Number(h.maxAttempts),
+    nextAttemptAt: dateOrNull(h.nextAttemptAt),
+    priority: Number(h.priority),
+    runAt: new Date(Number(h.runAt)),
+    pendingReason: nullish(h.pendingReason),
+    errorHistory,
+    timeoutMs: numOrNull(h.timeoutMs),
+    forceKillOnTimeout: h.forceKillOnTimeout === "true" || h.forceKillOnTimeout === "1" ? true : h.forceKillOnTimeout === "false" || h.forceKillOnTimeout === "0" ? false : null,
+    failureReason: nullish(h.failureReason) ?? null,
+    completedAt: dateOrNull(h.completedAt),
+    startedAt: dateOrNull(h.startedAt),
+    lastRetriedAt: dateOrNull(h.lastRetriedAt),
+    lastFailedAt: dateOrNull(h.lastFailedAt),
+    lastCancelledAt: dateOrNull(h.lastCancelledAt),
+    tags,
+    idempotencyKey: nullish(h.idempotencyKey),
+    progress: numOrNull(h.progress)
+  };
+}
+var RedisBackend = class {
+  constructor(redisConfig) {
+    let IORedis;
+    try {
+      const _require = createRequire(import.meta.url);
+      IORedis = _require("ioredis");
+    } catch {
+      throw new Error(
+        'Redis backend requires the "ioredis" package. Install it with: npm install ioredis'
+      );
+    }
+    this.prefix = redisConfig.keyPrefix ?? "dq:";
+    if (redisConfig.url) {
+      this.client = new IORedis(redisConfig.url, {
+        ...redisConfig.tls ? { tls: redisConfig.tls } : {},
+        ...redisConfig.db !== void 0 ? { db: redisConfig.db } : {}
+      });
+    } else {
+      this.client = new IORedis({
+        host: redisConfig.host ?? "127.0.0.1",
+        port: redisConfig.port ?? 6379,
+        password: redisConfig.password,
+        db: redisConfig.db ?? 0,
+        ...redisConfig.tls ? { tls: redisConfig.tls } : {}
+      });
+    }
+  }
+  /** Expose the raw ioredis client for advanced usage. */
+  getClient() {
+    return this.client;
+  }
+  nowMs() {
+    return Date.now();
+  }
+  // ── Events ──────────────────────────────────────────────────────────
+  async recordJobEvent(jobId, eventType, metadata) {
+    try {
+      const eventId = await this.client.incr(`${this.prefix}event_id_seq`);
+      const event = JSON.stringify({
+        id: eventId,
+        jobId,
+        eventType,
+        createdAt: this.nowMs(),
+        metadata: metadata ?? null
+      });
+      await this.client.rpush(`${this.prefix}events:${jobId}`, event);
+    } catch (error) {
+      log(`Error recording job event for job ${jobId}: ${error}`);
+    }
+  }
+  async getJobEvents(jobId) {
+    const raw = await this.client.lrange(
+      `${this.prefix}events:${jobId}`,
+      0,
+      -1
+    );
+    return raw.map((r) => {
+      const e = JSON.parse(r);
+      return {
+        ...e,
+        createdAt: new Date(e.createdAt)
+      };
+    });
+  }
+  // ── Job CRUD ──────────────────────────────────────────────────────────
+  async addJob({
+    jobType,
+    payload,
+    maxAttempts = 3,
+    priority = 0,
+    runAt = null,
+    timeoutMs = void 0,
+    forceKillOnTimeout = false,
+    tags = void 0,
+    idempotencyKey = void 0
+  }) {
+    const now = this.nowMs();
+    const runAtMs = runAt ? runAt.getTime() : 0;
+    const result = await this.client.eval(
+      ADD_JOB_SCRIPT,
+      1,
+      this.prefix,
+      jobType,
+      JSON.stringify(payload),
+      maxAttempts,
+      priority,
+      runAtMs.toString(),
+      timeoutMs !== void 0 ? timeoutMs.toString() : "null",
+      forceKillOnTimeout ? "true" : "false",
+      tags ? JSON.stringify(tags) : "null",
+      idempotencyKey ?? "null",
+      now
+    );
+    const jobId = Number(result);
+    log(
+      `Added job ${jobId}: payload ${JSON.stringify(payload)}, ${runAt ? `runAt ${runAt.toISOString()}, ` : ""}priority ${priority}, maxAttempts ${maxAttempts}, jobType ${jobType}, tags ${JSON.stringify(tags)}${idempotencyKey ? `, idempotencyKey "${idempotencyKey}"` : ""}`
+    );
+    await this.recordJobEvent(jobId, "added" /* Added */, {
+      jobType,
+      payload,
+      tags,
+      idempotencyKey
+    });
+    return jobId;
+  }
+  async getJob(id) {
+    const data = await this.client.hgetall(`${this.prefix}job:${id}`);
+    if (!data || Object.keys(data).length === 0) {
+      log(`Job ${id} not found`);
+      return null;
+    }
+    log(`Found job ${id}`);
+    return deserializeJob(data);
+  }
+  async getJobsByStatus(status, limit = 100, offset = 0) {
+    const ids = await this.client.smembers(`${this.prefix}status:${status}`);
+    if (ids.length === 0) return [];
+    const jobs = await this.loadJobsByIds(ids);
+    jobs.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    return jobs.slice(offset, offset + limit);
+  }
+  async getAllJobs(limit = 100, offset = 0) {
+    const ids = await this.client.zrevrange(
+      `${this.prefix}all`,
+      offset,
+      offset + limit - 1
+    );
+    if (ids.length === 0) return [];
+    return this.loadJobsByIds(ids);
+  }
+  async getJobs(filters, limit = 100, offset = 0) {
+    let candidateIds;
+    if (filters?.jobType) {
+      candidateIds = await this.client.smembers(
+        `${this.prefix}type:${filters.jobType}`
+      );
+    } else {
+      candidateIds = await this.client.zrevrange(`${this.prefix}all`, 0, -1);
+    }
+    if (candidateIds.length === 0) return [];
+    if (filters?.tags && filters.tags.values.length > 0) {
+      candidateIds = await this.filterByTags(
+        candidateIds,
+        filters.tags.values,
+        filters.tags.mode || "all"
+      );
+    }
+    let jobs = await this.loadJobsByIds(candidateIds);
+    if (filters) {
+      if (filters.priority !== void 0) {
+        jobs = jobs.filter((j) => j.priority === filters.priority);
+      }
+      if (filters.runAt) {
+        jobs = this.filterByRunAt(jobs, filters.runAt);
+      }
+    }
+    jobs.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    return jobs.slice(offset, offset + limit);
+  }
+  async getJobsByTags(tags, mode = "all", limit = 100, offset = 0) {
+    const allIds = await this.client.zrevrange(`${this.prefix}all`, 0, -1);
+    if (allIds.length === 0) return [];
+    const filtered = await this.filterByTags(allIds, tags, mode);
+    if (filtered.length === 0) return [];
+    const jobs = await this.loadJobsByIds(filtered);
+    jobs.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    return jobs.slice(offset, offset + limit);
+  }
+  // ── Processing lifecycle ──────────────────────────────────────────────
+  async getNextBatch(workerId, batchSize = 10, jobType) {
+    const now = this.nowMs();
+    const jobTypeFilter = jobType === void 0 ? "null" : Array.isArray(jobType) ? JSON.stringify(jobType) : jobType;
+    const result = await this.client.eval(
+      GET_NEXT_BATCH_SCRIPT,
+      1,
+      this.prefix,
+      workerId,
+      batchSize,
+      now,
+      jobTypeFilter
+    );
+    if (!result || result.length === 0) {
+      log("Found 0 jobs to process");
+      return [];
+    }
+    const jobs = [];
+    let current = [];
+    for (const item of result) {
+      if (item === "__JOB_SEP__") {
+        if (current.length > 0) {
+          const h = hashToObject(current);
+          jobs.push(deserializeJob(h));
+        }
+        current = [];
+      } else {
+        current.push(item);
+      }
+    }
+    log(`Found ${jobs.length} jobs to process`);
+    for (const job of jobs) {
+      await this.recordJobEvent(job.id, "processing" /* Processing */);
+    }
+    return jobs;
+  }
+  async completeJob(jobId) {
+    const now = this.nowMs();
+    await this.client.eval(COMPLETE_JOB_SCRIPT, 1, this.prefix, jobId, now);
+    await this.recordJobEvent(jobId, "completed" /* Completed */);
+    log(`Completed job ${jobId}`);
+  }
+  async failJob(jobId, error, failureReason) {
+    const now = this.nowMs();
+    const errorJson = JSON.stringify([
+      {
+        message: error.message || String(error),
+        timestamp: new Date(now).toISOString()
+      }
+    ]);
+    await this.client.eval(
+      FAIL_JOB_SCRIPT,
+      1,
+      this.prefix,
+      jobId,
+      errorJson,
+      failureReason ?? "null",
+      now
+    );
+    await this.recordJobEvent(jobId, "failed" /* Failed */, {
+      message: error.message || String(error),
+      failureReason
+    });
+    log(`Failed job ${jobId}`);
+  }
+  async prolongJob(jobId) {
+    try {
+      const now = this.nowMs();
+      await this.client.eval(PROLONG_JOB_SCRIPT, 1, this.prefix, jobId, now);
+      await this.recordJobEvent(jobId, "prolonged" /* Prolonged */);
+      log(`Prolonged job ${jobId}`);
+    } catch (error) {
+      log(`Error prolonging job ${jobId}: ${error}`);
+    }
+  }
+  // ── Progress ──────────────────────────────────────────────────────────
+  async updateProgress(jobId, progress) {
+    try {
+      const now = this.nowMs();
+      await this.client.hset(
+        `${this.prefix}job:${jobId}`,
+        "progress",
+        progress.toString(),
+        "updatedAt",
+        now.toString()
+      );
+      log(`Updated progress for job ${jobId}: ${progress}%`);
+    } catch (error) {
+      log(`Error updating progress for job ${jobId}: ${error}`);
+    }
+  }
+  // ── Job management ────────────────────────────────────────────────────
+  async retryJob(jobId) {
+    const now = this.nowMs();
+    await this.client.eval(RETRY_JOB_SCRIPT, 1, this.prefix, jobId, now);
+    await this.recordJobEvent(jobId, "retried" /* Retried */);
+    log(`Retried job ${jobId}`);
+  }
+  async cancelJob(jobId) {
+    const now = this.nowMs();
+    await this.client.eval(CANCEL_JOB_SCRIPT, 1, this.prefix, jobId, now);
+    await this.recordJobEvent(jobId, "cancelled" /* Cancelled */);
+    log(`Cancelled job ${jobId}`);
+  }
+  async cancelAllUpcomingJobs(filters) {
+    let ids = await this.client.smembers(`${this.prefix}status:pending`);
+    if (ids.length === 0) return 0;
+    if (filters) {
+      ids = await this.applyFilters(ids, filters);
+    }
+    const now = this.nowMs();
+    let count = 0;
+    for (const id of ids) {
+      const result = await this.client.eval(
+        CANCEL_JOB_SCRIPT,
+        1,
+        this.prefix,
+        id,
+        now
+      );
+      if (Number(result) === 1) count++;
+    }
+    log(`Cancelled ${count} jobs`);
+    return count;
+  }
+  async editJob(jobId, updates) {
+    const jk = `${this.prefix}job:${jobId}`;
+    const status = await this.client.hget(jk, "status");
+    if (status !== "pending") {
+      log(`Job ${jobId} is not pending (status: ${status}), skipping edit`);
+      return;
+    }
+    const now = this.nowMs();
+    const fields = [];
+    const metadata = {};
+    if (updates.payload !== void 0) {
+      fields.push("payload", JSON.stringify(updates.payload));
+      metadata.payload = updates.payload;
+    }
+    if (updates.maxAttempts !== void 0) {
+      fields.push("maxAttempts", updates.maxAttempts.toString());
+      metadata.maxAttempts = updates.maxAttempts;
+    }
+    if (updates.priority !== void 0) {
+      fields.push("priority", updates.priority.toString());
+      metadata.priority = updates.priority;
+      const createdAt = await this.client.hget(jk, "createdAt");
+      const score = updates.priority * 1e15 + (1e15 - Number(createdAt));
+      const inQueue = await this.client.zscore(
+        `${this.prefix}queue`,
+        jobId.toString()
+      );
+      if (inQueue !== null) {
+        await this.client.zadd(`${this.prefix}queue`, score, jobId.toString());
+      }
+    }
+    if (updates.runAt !== void 0) {
+      if (updates.runAt === null) {
+        fields.push("runAt", now.toString());
+      } else {
+        fields.push("runAt", updates.runAt.getTime().toString());
+      }
+      metadata.runAt = updates.runAt;
+    }
+    if (updates.timeoutMs !== void 0) {
+      fields.push(
+        "timeoutMs",
+        updates.timeoutMs !== null ? updates.timeoutMs.toString() : "null"
+      );
+      metadata.timeoutMs = updates.timeoutMs;
+    }
+    if (updates.tags !== void 0) {
+      const oldTagsJson = await this.client.hget(jk, "tags");
+      if (oldTagsJson && oldTagsJson !== "null") {
+        try {
+          const oldTags = JSON.parse(oldTagsJson);
+          for (const tag of oldTags) {
+            await this.client.srem(
+              `${this.prefix}tag:${tag}`,
+              jobId.toString()
+            );
+          }
+        } catch {
+        }
+      }
+      await this.client.del(`${this.prefix}job:${jobId}:tags`);
+      if (updates.tags !== null) {
+        for (const tag of updates.tags) {
+          await this.client.sadd(`${this.prefix}tag:${tag}`, jobId.toString());
+          await this.client.sadd(`${this.prefix}job:${jobId}:tags`, tag);
+        }
+        fields.push("tags", JSON.stringify(updates.tags));
+      } else {
+        fields.push("tags", "null");
+      }
+      metadata.tags = updates.tags;
+    }
+    if (fields.length === 0) {
+      log(`No fields to update for job ${jobId}`);
+      return;
+    }
+    fields.push("updatedAt", now.toString());
+    await this.client.hmset(jk, ...fields);
+    await this.recordJobEvent(jobId, "edited" /* Edited */, metadata);
+    log(`Edited job ${jobId}: ${JSON.stringify(metadata)}`);
+  }
+  async editAllPendingJobs(filters, updates) {
+    let ids = await this.client.smembers(`${this.prefix}status:pending`);
+    if (ids.length === 0) return 0;
+    if (filters) {
+      ids = await this.applyFilters(ids, filters);
+    }
+    let count = 0;
+    for (const id of ids) {
+      await this.editJob(Number(id), updates);
+      count++;
+    }
+    log(`Edited ${count} pending jobs`);
+    return count;
+  }
+  async cleanupOldJobs(daysToKeep = 30) {
+    const cutoffMs = this.nowMs() - daysToKeep * 24 * 60 * 60 * 1e3;
+    const result = await this.client.eval(
+      CLEANUP_OLD_JOBS_SCRIPT,
+      1,
+      this.prefix,
+      cutoffMs
+    );
+    log(`Deleted ${result} old jobs`);
+    return Number(result);
+  }
+  async cleanupOldJobEvents(daysToKeep = 30) {
+    log(
+      `cleanupOldJobEvents is a no-op for Redis backend (events are cleaned up with their jobs)`
+    );
+    return 0;
+  }
+  async reclaimStuckJobs(maxProcessingTimeMinutes = 10) {
+    const maxAgeMs = maxProcessingTimeMinutes * 60 * 1e3;
+    const now = this.nowMs();
+    const result = await this.client.eval(
+      RECLAIM_STUCK_JOBS_SCRIPT,
+      1,
+      this.prefix,
+      maxAgeMs,
+      now
+    );
+    log(`Reclaimed ${result} stuck jobs`);
+    return Number(result);
+  }
+  // ── Internal helpers ──────────────────────────────────────────────────
+  async setPendingReasonForUnpickedJobs(reason, jobType) {
+    let ids = await this.client.smembers(`${this.prefix}status:pending`);
+    if (ids.length === 0) return;
+    if (jobType) {
+      const types = Array.isArray(jobType) ? jobType : [jobType];
+      const typeSet = /* @__PURE__ */ new Set();
+      for (const t of types) {
+        const typeIds = await this.client.smembers(`${this.prefix}type:${t}`);
+        for (const id of typeIds) typeSet.add(id);
+      }
+      ids = ids.filter((id) => typeSet.has(id));
+    }
+    for (const id of ids) {
+      await this.client.hset(
+        `${this.prefix}job:${id}`,
+        "pendingReason",
+        reason
+      );
+    }
+  }
+  // ── Private helpers ───────────────────────────────────────────────────
+  async loadJobsByIds(ids) {
+    const pipeline = this.client.pipeline();
+    for (const id of ids) {
+      pipeline.hgetall(`${this.prefix}job:${id}`);
+    }
+    const results = await pipeline.exec();
+    const jobs = [];
+    if (results) {
+      for (const [err, data] of results) {
+        if (!err && data && typeof data === "object" && Object.keys(data).length > 0) {
+          jobs.push(
+            deserializeJob(data)
+          );
+        }
+      }
+    }
+    return jobs;
+  }
+  async filterByTags(candidateIds, tags, mode) {
+    const candidateSet = new Set(candidateIds.map(String));
+    if (mode === "exact") {
+      const tagSet = new Set(tags);
+      const result = [];
+      for (const id of candidateIds) {
+        const jobTags = await this.client.smembers(
+          `${this.prefix}job:${id}:tags`
+        );
+        if (jobTags.length === tagSet.size && jobTags.every((t) => tagSet.has(t))) {
+          result.push(id);
+        }
+      }
+      return result;
+    }
+    if (mode === "all") {
+      let intersection = new Set(candidateIds.map(String));
+      for (const tag of tags) {
+        const tagMembers = await this.client.smembers(
+          `${this.prefix}tag:${tag}`
+        );
+        const tagSet = new Set(tagMembers.map(String));
+        intersection = new Set(
+          [...intersection].filter((id) => tagSet.has(id))
+        );
+      }
+      return [...intersection].filter((id) => candidateSet.has(id));
+    }
+    if (mode === "any") {
+      const union = /* @__PURE__ */ new Set();
+      for (const tag of tags) {
+        const tagMembers = await this.client.smembers(
+          `${this.prefix}tag:${tag}`
+        );
+        for (const id of tagMembers) union.add(String(id));
+      }
+      return [...union].filter((id) => candidateSet.has(id));
+    }
+    if (mode === "none") {
+      const exclude = /* @__PURE__ */ new Set();
+      for (const tag of tags) {
+        const tagMembers = await this.client.smembers(
+          `${this.prefix}tag:${tag}`
+        );
+        for (const id of tagMembers) exclude.add(String(id));
+      }
+      return candidateIds.filter((id) => !exclude.has(String(id)));
+    }
+    return this.filterByTags(candidateIds, tags, "all");
+  }
+  filterByRunAt(jobs, runAt) {
+    if (runAt instanceof Date) {
+      return jobs.filter((j) => j.runAt.getTime() === runAt.getTime());
+    }
+    return jobs.filter((j) => {
+      const t = j.runAt.getTime();
+      if (runAt.gt && !(t > runAt.gt.getTime())) return false;
+      if (runAt.gte && !(t >= runAt.gte.getTime())) return false;
+      if (runAt.lt && !(t < runAt.lt.getTime())) return false;
+      if (runAt.lte && !(t <= runAt.lte.getTime())) return false;
+      if (runAt.eq && t !== runAt.eq.getTime()) return false;
+      return true;
+    });
+  }
+  // ── Cron schedules ──────────────────────────────────────────────────
+  /** Create a cron schedule and return its ID. */
+  async addCronSchedule(input) {
+    const existingId = await this.client.get(
+      `${this.prefix}cron_name:${input.scheduleName}`
+    );
+    if (existingId !== null) {
+      throw new Error(
+        `Cron schedule with name "${input.scheduleName}" already exists`
+      );
+    }
+    const id = await this.client.incr(`${this.prefix}cron_id_seq`);
+    const now = this.nowMs();
+    const key = `${this.prefix}cron:${id}`;
+    const fields = [
+      "id",
+      id.toString(),
+      "scheduleName",
+      input.scheduleName,
+      "cronExpression",
+      input.cronExpression,
+      "jobType",
+      input.jobType,
+      "payload",
+      JSON.stringify(input.payload),
+      "maxAttempts",
+      input.maxAttempts.toString(),
+      "priority",
+      input.priority.toString(),
+      "timeoutMs",
+      input.timeoutMs !== null ? input.timeoutMs.toString() : "null",
+      "forceKillOnTimeout",
+      input.forceKillOnTimeout ? "true" : "false",
+      "tags",
+      input.tags ? JSON.stringify(input.tags) : "null",
+      "timezone",
+      input.timezone,
+      "allowOverlap",
+      input.allowOverlap ? "true" : "false",
+      "status",
+      "active",
+      "lastEnqueuedAt",
+      "null",
+      "lastJobId",
+      "null",
+      "nextRunAt",
+      input.nextRunAt ? input.nextRunAt.getTime().toString() : "null",
+      "createdAt",
+      now.toString(),
+      "updatedAt",
+      now.toString()
+    ];
+    await this.client.hmset(key, ...fields);
+    await this.client.set(
+      `${this.prefix}cron_name:${input.scheduleName}`,
+      id.toString()
+    );
+    await this.client.sadd(`${this.prefix}crons`, id.toString());
+    await this.client.sadd(`${this.prefix}cron_status:active`, id.toString());
+    if (input.nextRunAt) {
+      await this.client.zadd(
+        `${this.prefix}cron_due`,
+        input.nextRunAt.getTime(),
+        id.toString()
+      );
+    }
+    log(`Added cron schedule ${id}: "${input.scheduleName}"`);
+    return id;
+  }
+  /** Get a cron schedule by ID. */
+  async getCronSchedule(id) {
+    const data = await this.client.hgetall(`${this.prefix}cron:${id}`);
+    if (!data || Object.keys(data).length === 0) return null;
+    return this.deserializeCronSchedule(data);
+  }
+  /** Get a cron schedule by its unique name. */
+  async getCronScheduleByName(name) {
+    const id = await this.client.get(`${this.prefix}cron_name:${name}`);
+    if (id === null) return null;
+    return this.getCronSchedule(Number(id));
+  }
+  /** List cron schedules, optionally filtered by status. */
+  async listCronSchedules(status) {
+    let ids;
+    if (status) {
+      ids = await this.client.smembers(`${this.prefix}cron_status:${status}`);
+    } else {
+      ids = await this.client.smembers(`${this.prefix}crons`);
+    }
+    if (ids.length === 0) return [];
+    const pipeline = this.client.pipeline();
+    for (const id of ids) {
+      pipeline.hgetall(`${this.prefix}cron:${id}`);
+    }
+    const results = await pipeline.exec();
+    const schedules = [];
+    if (results) {
+      for (const [err, data] of results) {
+        if (!err && data && typeof data === "object" && Object.keys(data).length > 0) {
+          schedules.push(
+            this.deserializeCronSchedule(data)
+          );
+        }
+      }
+    }
+    schedules.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+    return schedules;
+  }
+  /** Delete a cron schedule by ID. */
+  async removeCronSchedule(id) {
+    const data = await this.client.hgetall(`${this.prefix}cron:${id}`);
+    if (!data || Object.keys(data).length === 0) return;
+    const name = data.scheduleName;
+    const status = data.status;
+    await this.client.del(`${this.prefix}cron:${id}`);
+    await this.client.del(`${this.prefix}cron_name:${name}`);
+    await this.client.srem(`${this.prefix}crons`, id.toString());
+    await this.client.srem(
+      `${this.prefix}cron_status:${status}`,
+      id.toString()
+    );
+    await this.client.zrem(`${this.prefix}cron_due`, id.toString());
+    log(`Removed cron schedule ${id}`);
+  }
+  /** Pause a cron schedule. */
+  async pauseCronSchedule(id) {
+    const now = this.nowMs();
+    await this.client.hset(
+      `${this.prefix}cron:${id}`,
+      "status",
+      "paused",
+      "updatedAt",
+      now.toString()
+    );
+    await this.client.srem(`${this.prefix}cron_status:active`, id.toString());
+    await this.client.sadd(`${this.prefix}cron_status:paused`, id.toString());
+    await this.client.zrem(`${this.prefix}cron_due`, id.toString());
+    log(`Paused cron schedule ${id}`);
+  }
+  /** Resume a paused cron schedule. */
+  async resumeCronSchedule(id) {
+    const now = this.nowMs();
+    await this.client.hset(
+      `${this.prefix}cron:${id}`,
+      "status",
+      "active",
+      "updatedAt",
+      now.toString()
+    );
+    await this.client.srem(`${this.prefix}cron_status:paused`, id.toString());
+    await this.client.sadd(`${this.prefix}cron_status:active`, id.toString());
+    const nextRunAt = await this.client.hget(
+      `${this.prefix}cron:${id}`,
+      "nextRunAt"
+    );
+    if (nextRunAt && nextRunAt !== "null") {
+      await this.client.zadd(
+        `${this.prefix}cron_due`,
+        Number(nextRunAt),
+        id.toString()
+      );
+    }
+    log(`Resumed cron schedule ${id}`);
+  }
+  /** Edit a cron schedule. */
+  async editCronSchedule(id, updates, nextRunAt) {
+    const now = this.nowMs();
+    const fields = [];
+    if (updates.cronExpression !== void 0) {
+      fields.push("cronExpression", updates.cronExpression);
+    }
+    if (updates.payload !== void 0) {
+      fields.push("payload", JSON.stringify(updates.payload));
+    }
+    if (updates.maxAttempts !== void 0) {
+      fields.push("maxAttempts", updates.maxAttempts.toString());
+    }
+    if (updates.priority !== void 0) {
+      fields.push("priority", updates.priority.toString());
+    }
+    if (updates.timeoutMs !== void 0) {
+      fields.push(
+        "timeoutMs",
+        updates.timeoutMs !== null ? updates.timeoutMs.toString() : "null"
+      );
+    }
+    if (updates.forceKillOnTimeout !== void 0) {
+      fields.push(
+        "forceKillOnTimeout",
+        updates.forceKillOnTimeout ? "true" : "false"
+      );
+    }
+    if (updates.tags !== void 0) {
+      fields.push(
+        "tags",
+        updates.tags !== null ? JSON.stringify(updates.tags) : "null"
+      );
+    }
+    if (updates.timezone !== void 0) {
+      fields.push("timezone", updates.timezone);
+    }
+    if (updates.allowOverlap !== void 0) {
+      fields.push("allowOverlap", updates.allowOverlap ? "true" : "false");
+    }
+    if (nextRunAt !== void 0) {
+      const val = nextRunAt !== null ? nextRunAt.getTime().toString() : "null";
+      fields.push("nextRunAt", val);
+      if (nextRunAt !== null) {
+        await this.client.zadd(
+          `${this.prefix}cron_due`,
+          nextRunAt.getTime(),
+          id.toString()
+        );
+      } else {
+        await this.client.zrem(`${this.prefix}cron_due`, id.toString());
+      }
+    }
+    if (fields.length === 0) {
+      log(`No fields to update for cron schedule ${id}`);
+      return;
+    }
+    fields.push("updatedAt", now.toString());
+    await this.client.hmset(`${this.prefix}cron:${id}`, ...fields);
+    log(`Edited cron schedule ${id}`);
+  }
+  /**
+   * Fetch all active cron schedules whose nextRunAt <= now.
+   * Uses a sorted set (cron_due) for efficient range query.
+   */
+  async getDueCronSchedules() {
+    const now = this.nowMs();
+    const ids = await this.client.zrangebyscore(
+      `${this.prefix}cron_due`,
+      0,
+      now
+    );
+    if (ids.length === 0) {
+      log("Found 0 due cron schedules");
+      return [];
+    }
+    const schedules = [];
+    for (const id of ids) {
+      const data = await this.client.hgetall(`${this.prefix}cron:${id}`);
+      if (data && Object.keys(data).length > 0 && data.status === "active") {
+        schedules.push(this.deserializeCronSchedule(data));
+      }
+    }
+    log(`Found ${schedules.length} due cron schedules`);
+    return schedules;
+  }
+  /**
+   * Update a cron schedule after a job has been enqueued.
+   * Sets lastEnqueuedAt, lastJobId, and advances nextRunAt.
+   */
+  async updateCronScheduleAfterEnqueue(id, lastEnqueuedAt, lastJobId, nextRunAt) {
+    const fields = [
+      "lastEnqueuedAt",
+      lastEnqueuedAt.getTime().toString(),
+      "lastJobId",
+      lastJobId.toString(),
+      "nextRunAt",
+      nextRunAt ? nextRunAt.getTime().toString() : "null",
+      "updatedAt",
+      this.nowMs().toString()
+    ];
+    await this.client.hmset(`${this.prefix}cron:${id}`, ...fields);
+    if (nextRunAt) {
+      await this.client.zadd(
+        `${this.prefix}cron_due`,
+        nextRunAt.getTime(),
+        id.toString()
+      );
+    } else {
+      await this.client.zrem(`${this.prefix}cron_due`, id.toString());
+    }
+    log(
+      `Updated cron schedule ${id}: lastJobId=${lastJobId}, nextRunAt=${nextRunAt?.toISOString() ?? "null"}`
+    );
+  }
+  /** Deserialize a Redis hash into a CronScheduleRecord. */
+  deserializeCronSchedule(h) {
+    const nullish = (v) => v === void 0 || v === "null" || v === "" ? null : v;
+    const numOrNull = (v) => {
+      const n = nullish(v);
+      return n === null ? null : Number(n);
+    };
+    const dateOrNull = (v) => {
+      const n = numOrNull(v);
+      return n === null ? null : new Date(n);
+    };
+    let payload;
+    try {
+      payload = JSON.parse(h.payload);
+    } catch {
+      payload = h.payload;
+    }
+    let tags;
+    try {
+      const raw = h.tags;
+      if (raw && raw !== "null") {
+        tags = JSON.parse(raw);
+      }
+    } catch {
+    }
+    return {
+      id: Number(h.id),
+      scheduleName: h.scheduleName,
+      cronExpression: h.cronExpression,
+      jobType: h.jobType,
+      payload,
+      maxAttempts: Number(h.maxAttempts),
+      priority: Number(h.priority),
+      timeoutMs: numOrNull(h.timeoutMs),
+      forceKillOnTimeout: h.forceKillOnTimeout === "true",
+      tags,
+      timezone: h.timezone,
+      allowOverlap: h.allowOverlap === "true",
+      status: h.status,
+      lastEnqueuedAt: dateOrNull(h.lastEnqueuedAt),
+      lastJobId: numOrNull(h.lastJobId),
+      nextRunAt: dateOrNull(h.nextRunAt),
+      createdAt: new Date(Number(h.createdAt)),
+      updatedAt: new Date(Number(h.updatedAt))
+    };
+  }
+  // ── Private helpers (filters) ─────────────────────────────────────────
+  async applyFilters(ids, filters) {
+    let result = ids;
+    if (filters.jobType) {
+      const typeIds = new Set(
+        await this.client.smembers(`${this.prefix}type:${filters.jobType}`)
+      );
+      result = result.filter((id) => typeIds.has(id));
+    }
+    if (filters.tags && filters.tags.values.length > 0) {
+      result = await this.filterByTags(
+        result,
+        filters.tags.values,
+        filters.tags.mode || "all"
+      );
+    }
+    if (filters.priority !== void 0 || filters.runAt) {
+      const jobs = await this.loadJobsByIds(result);
+      let filtered = jobs;
+      if (filters.priority !== void 0) {
+        filtered = filtered.filter((j) => j.priority === filters.priority);
+      }
+      if (filters.runAt) {
+        filtered = this.filterByRunAt(filtered, filters.runAt);
+      }
+      result = filtered.map((j) => j.id.toString());
+    }
+    return result;
+  }
+};
+function getNextCronOccurrence(cronExpression, timezone = "UTC", after, CronImpl = Cron) {
+  const cron = new CronImpl(cronExpression, { timezone });
+  const next = cron.nextRun(after ?? /* @__PURE__ */ new Date());
+  return next ?? null;
+}
+function validateCronExpression(cronExpression, CronImpl = Cron) {
+  try {
+    new CronImpl(cronExpression);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/handler-validation.ts
+function validateHandlerSerializable2(handler, jobType) {
+  try {
+    const handlerString = handler.toString();
+    const typeLabel = jobType ? `job type "${jobType}"` : "handler";
+    if (handlerString.includes("this.") && !handlerString.match(/\([^)]*this[^)]*\)/)) {
+      return {
+        isSerializable: false,
+        error: `Handler for ${typeLabel} uses 'this' context which cannot be serialized. Use a regular function or avoid 'this' references when forceKillOnTimeout is enabled.`
+      };
+    }
+    if (handlerString.includes("[native code]")) {
+      return {
+        isSerializable: false,
+        error: `Handler for ${typeLabel} contains native code which cannot be serialized. Ensure your handler is a plain function when forceKillOnTimeout is enabled.`
+      };
+    }
+    try {
+      new Function("return " + handlerString);
+    } catch (parseError) {
+      return {
+        isSerializable: false,
+        error: `Handler for ${typeLabel} cannot be serialized: ${parseError instanceof Error ? parseError.message : String(parseError)}. When using forceKillOnTimeout, handlers must be serializable functions without closures over external variables.`
+      };
+    }
+    const hasPotentialClosure = /const\s+\w+\s*=\s*[^;]+;\s*async\s*\(/.test(handlerString) || /let\s+\w+\s*=\s*[^;]+;\s*async\s*\(/.test(handlerString);
+    if (hasPotentialClosure) {
+      return {
+        isSerializable: true,
+        // Still serializable, but might have issues
+        error: `Warning: Handler for ${typeLabel} may have closures over external variables. Test thoroughly with forceKillOnTimeout enabled. If the handler fails to execute in a worker thread, ensure all dependencies are imported within the handler function.`
+      };
+    }
+    return { isSerializable: true };
+  } catch (error) {
+    return {
+      isSerializable: false,
+      error: `Failed to validate handler serialization${jobType ? ` for job type "${jobType}"` : ""}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function testHandlerSerialization(handler, jobType) {
+  const basicValidation = validateHandlerSerializable2(handler, jobType);
+  if (!basicValidation.isSerializable) {
+    return basicValidation;
+  }
+  try {
+    const handlerString = handler.toString();
+    const handlerFn = new Function("return " + handlerString)();
+    const testPromise = handlerFn({}, new AbortController().signal);
+    const timeoutPromise = new Promise(
+      (_, reject) => setTimeout(() => reject(new Error("Handler test timeout")), 100)
+    );
+    try {
+      await Promise.race([testPromise, timeoutPromise]);
+    } catch (execError) {
+      if (execError instanceof Error && execError.message === "Handler test timeout") {
+        return { isSerializable: true };
+      }
+    }
+    return { isSerializable: true };
+  } catch (error) {
+    return {
+      isSerializable: false,
+      error: `Handler failed serialization test: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
+// src/index.ts
+var initJobQueue = (config) => {
+  const backendType = config.backend ?? "postgres";
+  setLogContext(config.verbose ?? false);
+  let backend;
+  let pool;
+  if (backendType === "postgres") {
+    const pgConfig = config;
+    pool = createPool(pgConfig.databaseConfig);
+    backend = new PostgresBackend(pool);
+  } else if (backendType === "redis") {
+    const redisConfig = config.redisConfig;
+    backend = new RedisBackend(redisConfig);
+  } else {
+    throw new Error(`Unknown backend: ${backendType}`);
+  }
+  const requirePool = () => {
+    if (!pool) {
+      throw new Error(
+        'Wait/Token features require the PostgreSQL backend. Configure with backend: "postgres" to use these features.'
+      );
+    }
+    return pool;
+  };
+  const enqueueDueCronJobsImpl = async () => {
+    const dueSchedules = await backend.getDueCronSchedules();
+    let count = 0;
+    for (const schedule of dueSchedules) {
+      if (!schedule.allowOverlap && schedule.lastJobId !== null) {
+        const lastJob = await backend.getJob(schedule.lastJobId);
+        if (lastJob && (lastJob.status === "pending" || lastJob.status === "processing" || lastJob.status === "waiting")) {
+          const nextRunAt2 = getNextCronOccurrence(
+            schedule.cronExpression,
+            schedule.timezone
+          );
+          await backend.updateCronScheduleAfterEnqueue(
+            schedule.id,
+            /* @__PURE__ */ new Date(),
+            schedule.lastJobId,
+            nextRunAt2
+          );
+          continue;
+        }
+      }
+      const jobId = await backend.addJob({
+        jobType: schedule.jobType,
+        payload: schedule.payload,
+        maxAttempts: schedule.maxAttempts,
+        priority: schedule.priority,
+        timeoutMs: schedule.timeoutMs ?? void 0,
+        forceKillOnTimeout: schedule.forceKillOnTimeout,
+        tags: schedule.tags
+      });
+      const nextRunAt = getNextCronOccurrence(
+        schedule.cronExpression,
+        schedule.timezone
+      );
+      await backend.updateCronScheduleAfterEnqueue(
+        schedule.id,
+        /* @__PURE__ */ new Date(),
+        jobId,
+        nextRunAt
+      );
+      count++;
+    }
+    return count;
+  };
+  return {
+    // Job queue operations
+    addJob: withLogContext(
+      (job) => backend.addJob(job),
+      config.verbose ?? false
+    ),
+    getJob: withLogContext(
+      (id) => backend.getJob(id),
+      config.verbose ?? false
+    ),
+    getJobsByStatus: withLogContext(
+      (status, limit, offset) => backend.getJobsByStatus(status, limit, offset),
+      config.verbose ?? false
+    ),
+    getAllJobs: withLogContext(
+      (limit, offset) => backend.getAllJobs(limit, offset),
+      config.verbose ?? false
+    ),
+    getJobs: withLogContext(
+      (filters, limit, offset) => backend.getJobs(filters, limit, offset),
+      config.verbose ?? false
+    ),
+    retryJob: (jobId) => backend.retryJob(jobId),
+    cleanupOldJobs: (daysToKeep) => backend.cleanupOldJobs(daysToKeep),
+    cleanupOldJobEvents: (daysToKeep) => backend.cleanupOldJobEvents(daysToKeep),
+    cancelJob: withLogContext(
+      (jobId) => backend.cancelJob(jobId),
+      config.verbose ?? false
+    ),
+    editJob: withLogContext(
+      (jobId, updates) => backend.editJob(jobId, updates),
+      config.verbose ?? false
+    ),
+    editAllPendingJobs: withLogContext(
+      (filters, updates) => backend.editAllPendingJobs(
+        filters,
+        updates
+      ),
+      config.verbose ?? false
+    ),
+    cancelAllUpcomingJobs: withLogContext(
+      (filters) => backend.cancelAllUpcomingJobs(filters),
+      config.verbose ?? false
+    ),
+    reclaimStuckJobs: withLogContext(
+      (maxProcessingTimeMinutes) => backend.reclaimStuckJobs(maxProcessingTimeMinutes),
+      config.verbose ?? false
+    ),
+    getJobsByTags: withLogContext(
+      (tags, mode = "all", limit, offset) => backend.getJobsByTags(tags, mode, limit, offset),
+      config.verbose ?? false
+    ),
+    // Job processing — automatically enqueues due cron jobs before each batch
+    createProcessor: (handlers, options) => createProcessor(backend, handlers, options, async () => {
+      await enqueueDueCronJobsImpl();
+    }),
+    // Job events
+    getJobEvents: withLogContext(
+      (jobId) => backend.getJobEvents(jobId),
+      config.verbose ?? false
+    ),
+    // Wait / Token support (PostgreSQL-only for now)
+    createToken: withLogContext(
+      (options) => createWaitpoint(requirePool(), null, options),
+      config.verbose ?? false
+    ),
+    completeToken: withLogContext(
+      (tokenId, data) => completeWaitpoint(requirePool(), tokenId, data),
+      config.verbose ?? false
+    ),
+    getToken: withLogContext(
+      (tokenId) => getWaitpoint(requirePool(), tokenId),
+      config.verbose ?? false
+    ),
+    expireTimedOutTokens: withLogContext(
+      () => expireTimedOutWaitpoints(requirePool()),
+      config.verbose ?? false
+    ),
+    // Cron schedule operations
+    addCronJob: withLogContext(
+      (options) => {
+        if (!validateCronExpression(options.cronExpression)) {
+          return Promise.reject(
+            new Error(`Invalid cron expression: "${options.cronExpression}"`)
+          );
+        }
+        const nextRunAt = getNextCronOccurrence(
+          options.cronExpression,
+          options.timezone ?? "UTC"
+        );
+        const input = {
+          scheduleName: options.scheduleName,
+          cronExpression: options.cronExpression,
+          jobType: options.jobType,
+          payload: options.payload,
+          maxAttempts: options.maxAttempts ?? 3,
+          priority: options.priority ?? 0,
+          timeoutMs: options.timeoutMs ?? null,
+          forceKillOnTimeout: options.forceKillOnTimeout ?? false,
+          tags: options.tags,
+          timezone: options.timezone ?? "UTC",
+          allowOverlap: options.allowOverlap ?? false,
+          nextRunAt
+        };
+        return backend.addCronSchedule(input);
+      },
+      config.verbose ?? false
+    ),
+    getCronJob: withLogContext(
+      (id) => backend.getCronSchedule(id),
+      config.verbose ?? false
+    ),
+    getCronJobByName: withLogContext(
+      (name) => backend.getCronScheduleByName(name),
+      config.verbose ?? false
+    ),
+    listCronJobs: withLogContext(
+      (status) => backend.listCronSchedules(status),
+      config.verbose ?? false
+    ),
+    removeCronJob: withLogContext(
+      (id) => backend.removeCronSchedule(id),
+      config.verbose ?? false
+    ),
+    pauseCronJob: withLogContext(
+      (id) => backend.pauseCronSchedule(id),
+      config.verbose ?? false
+    ),
+    resumeCronJob: withLogContext(
+      (id) => backend.resumeCronSchedule(id),
+      config.verbose ?? false
+    ),
+    editCronJob: withLogContext(
+      async (id, updates) => {
+        if (updates.cronExpression !== void 0 && !validateCronExpression(updates.cronExpression)) {
+          throw new Error(
+            `Invalid cron expression: "${updates.cronExpression}"`
+          );
+        }
+        let nextRunAt;
+        if (updates.cronExpression !== void 0 || updates.timezone !== void 0) {
+          const existing = await backend.getCronSchedule(id);
+          const expr = updates.cronExpression ?? existing?.cronExpression ?? "";
+          const tz = updates.timezone ?? existing?.timezone ?? "UTC";
+          nextRunAt = getNextCronOccurrence(expr, tz);
+        }
+        await backend.editCronSchedule(id, updates, nextRunAt);
+      },
+      config.verbose ?? false
+    ),
+    enqueueDueCronJobs: withLogContext(
+      () => enqueueDueCronJobsImpl(),
+      config.verbose ?? false
+    ),
+    // Advanced access
+    getPool: () => {
+      if (backendType !== "postgres") {
+        throw new Error(
+          "getPool() is only available with the PostgreSQL backend."
+        );
+      }
+      return backend.getPool();
+    },
+    getRedisClient: () => {
+      if (backendType !== "redis") {
+        throw new Error(
+          "getRedisClient() is only available with the Redis backend."
+        );
+      }
+      return backend.getClient();
+    }
+  };
+};
+var withLogContext = (fn, verbose) => (...args) => {
+  setLogContext(verbose);
+  return fn(...args);
+};
+
+export { FailureReason, JobEventType, PostgresBackend, WaitSignal, getNextCronOccurrence, initJobQueue, testHandlerSerialization, validateCronExpression, validateHandlerSerializable2 as validateHandlerSerializable };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map