@nicnocquee/dataqueue 1.22.0 → 1.25.0

package/dist/index.js

@@ -1,7 +1,10 @@
 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';
 
 // src/types.ts
 var JobEventType = /* @__PURE__ */ ((JobEventType2) => {
@@ -11,14 +14,28 @@ var JobEventType = /* @__PURE__ */ ((JobEventType2) => {
   JobEventType2["Failed"] = "failed";
   JobEventType2["Cancelled"] = "cancelled";
   JobEventType2["Retried"] = "retried";
+  JobEventType2["Edited"] = "edited";
+  JobEventType2["Prolonged"] = "prolonged";
+  JobEventType2["Waiting"] = "waiting";
   return JobEventType2;
 })(JobEventType || {});
-var FailureReason = /* @__PURE__ */ ((FailureReason3) => {
-  FailureReason3["Timeout"] = "timeout";
-  FailureReason3["HandlerError"] = "handler_error";
-  FailureReason3["NoHandler"] = "no_handler";
-  return FailureReason3;
+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 });
@@ -33,675 +50,1655 @@ var log = (message) => {
   }
 };
 
-// src/queue.ts
-var recordJobEvent = async (pool, jobId, eventType, metadata) => {
-  const client = await 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();
+// src/backends/postgres.ts
+var PostgresBackend = class {
+  constructor(pool) {
+    this.pool = pool;
   }
-};
-var addJob = async (pool, {
-  jobType,
-  payload,
-  maxAttempts = 3,
-  priority = 0,
-  runAt = null,
-  timeoutMs = void 0,
-  tags = void 0
-}) => {
-  const client = await pool.connect();
-  try {
-    let result;
-    if (runAt) {
-      result = await client.query(
-        `INSERT INTO job_queue 
-          (job_type, payload, max_attempts, priority, run_at, timeout_ms, tags) 
-         VALUES ($1, $2, $3, $4, $5, $6, $7) 
-         RETURNING id`,
-        [
-          jobType,
-          payload,
-          maxAttempts,
-          priority,
-          runAt,
-          timeoutMs ?? null,
-          tags ?? null
-        ]
+  /** 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 ${result.rows[0].id}: payload ${JSON.stringify(payload)}, runAt ${runAt.toISOString()}, priority ${priority}, maxAttempts ${maxAttempts} jobType ${jobType}, tags ${JSON.stringify(tags)}`
+        `Added job ${jobId}: payload ${JSON.stringify(payload)}, ${runAt ? `runAt ${runAt.toISOString()}, ` : ""}priority ${priority}, maxAttempts ${maxAttempts}, jobType ${jobType}, tags ${JSON.stringify(tags)}${idempotencyKey ? `, idempotencyKey "${idempotencyKey}"` : ""}`
       );
-    } else {
-      result = await client.query(
-        `INSERT INTO job_queue 
-          (job_type, payload, max_attempts, priority, timeout_ms, tags) 
-         VALUES ($1, $2, $3, $4, $5, $6) 
-         RETURNING id`,
+      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')
+      `,
         [
-          jobType,
-          payload,
-          maxAttempts,
-          priority,
-          timeoutMs ?? null,
-          tags ?? null
+          jobId,
+          JSON.stringify([
+            {
+              message: error.message || String(error),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          ]),
+          failureReason ?? null
         ]
       );
-      log(
-        `Added job ${result.rows[0].id}: payload ${JSON.stringify(payload)}, priority ${priority}, maxAttempts ${maxAttempts} jobType ${jobType}, tags ${JSON.stringify(tags)}`
+      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();
+    }
+  }
+  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();
     }
-    await recordJobEvent(pool, result.rows[0].id, "added" /* Added */, {
-      jobType,
-      payload,
-      tags
-    });
-    return result.rows[0].id;
-  } catch (error) {
-    log(`Error adding job: ${error}`);
-    throw error;
-  } finally {
-    client.release();
   }
 };
-var getJob = async (pool, id) => {
+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(
-      `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" FROM job_queue WHERE id = $1`,
-      [id]
+      `
+      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.rows.length === 0) {
-      log(`Job ${id} not found`);
-      return null;
+    if (result.rowCount === 0) {
+      log(
+        `Job ${jobId} could not be set to waiting (may have been reclaimed or is no longer processing)`
+      );
+      return;
     }
-    log(`Found job ${id}`);
-    const job = result.rows[0];
-    return {
-      ...job,
-      payload: job.payload,
-      timeoutMs: job.timeoutMs,
-      failureReason: job.failureReason
-    };
+    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 getting job ${id}: ${error}`);
+    log(`Error setting job ${jobId} to waiting: ${error}`);
     throw error;
   } finally {
     client.release();
   }
 };
-var getJobsByStatus = async (pool, status, limit = 100, offset = 0) => {
+var updateStepData = async (pool, jobId, stepData) => {
   const client = await 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", 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" FROM job_queue WHERE status = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3`,
-      [status, limit, offset]
+    await client.query(
+      `UPDATE job_queue SET step_data = $2, updated_at = NOW() WHERE id = $1`,
+      [jobId, JSON.stringify(stepData)]
     );
-    log(`Found ${result.rows.length} jobs by status ${status}`);
-    return result.rows.map((job) => ({
-      ...job,
-      payload: job.payload,
-      timeoutMs: job.timeoutMs,
-      failureReason: job.failureReason
-    }));
   } catch (error) {
-    log(`Error getting jobs by status ${status}: ${error}`);
-    throw error;
+    log(`Error updating step_data for job ${jobId}: ${error}`);
   } finally {
     client.release();
   }
 };
-var getNextBatch = async (pool, workerId, batchSize = 10, jobType) => {
+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 {
-    await client.query("BEGIN");
-    let jobTypeFilter = "";
-    let 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 id = `wp_${randomUUID()}`;
+    let timeoutAt = null;
+    if (options?.timeout) {
+      const ms = parseTimeoutString(options.timeout);
+      timeoutAt = new Date(Date.now() + ms);
     }
-    const result = await client.query(
-      `
-      UPDATE job_queue
-      SET status = 'processing', 
-          locked_at = NOW(), 
-          locked_by = $1,
-          attempts = attempts + 1,
-          updated_at = NOW(),
-          pending_reason = NULL,
-          started_at = COALESCE(started_at, NOW()),
-          last_retried_at = CASE WHEN attempts > 0 THEN NOW() ELSE last_retried_at END
-      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()
-        ${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", 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"
-    `,
-      params
+    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(`Found ${result.rows.length} jobs to process`);
-    await client.query("COMMIT");
-    for (const row of result.rows) {
-      await recordJobEvent(pool, row.id, "processing" /* Processing */);
-    }
-    return result.rows.map((job) => ({
-      ...job,
-      payload: job.payload,
-      timeoutMs: job.timeoutMs
-    }));
+    log(`Created waitpoint ${id} for job ${jobId}`);
+    return { id };
   } catch (error) {
-    log(`Error getting next batch: ${error}`);
-    await client.query("ROLLBACK");
+    log(`Error creating waitpoint: ${error}`);
     throw error;
   } finally {
     client.release();
   }
 };
-var completeJob = async (pool, jobId) => {
+var completeWaitpoint = async (pool, tokenId, data) => {
   const client = await pool.connect();
   try {
-    await client.query(
-      `
-      UPDATE job_queue
-      SET status = 'completed', updated_at = NOW(), completed_at = NOW()
-      WHERE id = $1
-    `,
-      [jobId]
+    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]
     );
-    await recordJobEvent(pool, jobId, "completed" /* Completed */);
+    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) {
-    log(`Error completing job ${jobId}: ${error}`);
+    await client.query("ROLLBACK");
+    log(`Error completing waitpoint ${tokenId}: ${error}`);
     throw error;
   } finally {
-    log(`Completed job ${jobId}`);
     client.release();
   }
 };
-var failJob = async (pool, jobId, error, failureReason) => {
+var getWaitpoint = async (pool, tokenId) => {
   const client = await pool.connect();
   try {
-    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
-    `,
-      [
-        jobId,
-        JSON.stringify([
-          {
-            message: error.message || String(error),
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          }
-        ]),
-        failureReason ?? null
-      ]
+    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]
     );
-    await recordJobEvent(pool, jobId, "failed" /* Failed */, {
-      message: error.message || String(error),
-      failureReason
-    });
-  } catch (error2) {
-    log(`Error failing job ${jobId}: ${error2}`);
-    throw error2;
+    if (result.rows.length === 0) return null;
+    return result.rows[0];
+  } catch (error) {
+    log(`Error getting waitpoint ${tokenId}: ${error}`);
+    throw error;
   } finally {
-    log(`Failed job ${jobId}`);
     client.release();
   }
 };
-var retryJob = async (pool, jobId) => {
+var expireTimedOutWaitpoints = async (pool) => {
   const client = await pool.connect();
   try {
-    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
-    `,
-      [jobId]
+    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`
     );
-    await recordJobEvent(pool, jobId, "retried" /* Retried */);
+    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) {
-    log(`Error retrying job ${jobId}: ${error}`);
+    await client.query("ROLLBACK");
+    log(`Error expiring timed-out waitpoints: ${error}`);
     throw error;
   } finally {
-    log(`Retried job ${jobId}`);
     client.release();
   }
 };
-var cleanupOldJobs = async (pool, daysToKeep = 30) => {
-  const client = await pool.connect();
-  try {
-    const result = await client.query(`
-      DELETE FROM job_queue
-      WHERE status = 'completed'
-      AND updated_at < NOW() - INTERVAL '${daysToKeep} days'
-      RETURNING id
-    `);
-    log(`Deleted ${result.rowCount} old jobs`);
-    return result.rowCount || 0;
-  } catch (error) {
-    log(`Error cleaning up old jobs: ${error}`);
-    throw error;
-  } finally {
-    client.release();
+function tryExtractPool(backend) {
+  if (backend instanceof PostgresBackend) {
+    return backend.getPool();
   }
-};
-var cancelJob = async (pool, jobId) => {
-  const client = await pool.connect();
+  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 {
-    await client.query(
-      `
-      UPDATE job_queue
-      SET status = 'cancelled', updated_at = NOW(), last_cancelled_at = NOW()
-      WHERE id = $1 AND status = 'pending'
-    `,
-      [jobId]
-    );
-    await recordJobEvent(pool, jobId, "cancelled" /* Cancelled */);
+    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) {
-    log(`Error cancelling job ${jobId}: ${error}`);
-    throw error;
-  } finally {
-    log(`Cancelled job ${jobId}`);
-    client.release();
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error(
+      `Failed to validate handler serialization for job type "${jobType}": ${String(error)}`
+    );
   }
-};
-var cancelAllUpcomingJobs = async (pool, filters) => {
-  const client = await 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);
+}
+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;
           }
-          if (ops.eq) {
-            query += ` AND run_at = $${paramIdx++}`;
-            params.push(ops.eq);
+          
+          // 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
       }
-      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);
-        }
+    });
+    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);
       }
-    }
-    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();
-  }
-};
-var getAllJobs = async (pool, limit = 100, offset = 0) => {
-  const client = await 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", 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" FROM job_queue ORDER BY created_at DESC LIMIT $1 OFFSET $2`,
-      [limit, offset]
+    });
+    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."
     );
-    log(`Found ${result.rows.length} jobs (all)`);
-    return result.rows.map((job) => ({
-      ...job,
-      payload: job.payload,
-      timeoutMs: job.timeoutMs
-    }));
-  } catch (error) {
-    log(`Error getting all jobs: ${error}`);
-    throw error;
-  } finally {
-    client.release();
   }
-};
-var setPendingReasonForUnpickedJobs = async (pool, reason, jobType) => {
-  const client = await pool.connect();
-  try {
-    let jobTypeFilter = "";
-    let 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);
+  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" }
+        };
       }
     }
-    await client.query(
-      `UPDATE job_queue SET pending_reason = $1 WHERE status = 'pending'${jobTypeFilter}`,
-      params
-    );
-  } finally {
-    client.release();
   }
-};
-var reclaimStuckJobs = async (pool, maxProcessingTimeMinutes = 10) => {
-  const client = await 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() - INTERVAL '${maxProcessingTimeMinutes} minutes'
-      RETURNING id
-      `
-    );
-    log(`Reclaimed ${result.rowCount} stuck jobs`);
-    return result.rowCount || 0;
-  } catch (error) {
-    log(`Error reclaiming stuck jobs: ${error}`);
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-var getJobEvents = async (pool, jobId) => {
-  const client = await 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();
-  }
-};
-var getJobsByTags = async (pool, tags, mode = "all", limit = 100, offset = 0) => {
-  const client = await 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
-       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,
-      failureReason: job.failureReason
-    }));
-  } catch (error) {
-    log(
-      `Error getting jobs by tags ${JSON.stringify(tags)} (mode: ${mode}): ${error}`
-    );
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-var getJobs = async (pool, filters, limit = 100, offset = 0) => {
-  const client = await 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 FROM job_queue`;
-    const params = [];
-    let where = [];
-    let paramIdx = 1;
-    if (filters) {
-      if (filters.jobType) {
-        where.push(`job_type = $${paramIdx++}`);
-        params.push(filters.jobType);
+}
+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;
       }
-      if (filters.priority !== void 0) {
-        where.push(`priority = $${paramIdx++}`);
-        params.push(filters.priority);
+      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;
       }
-      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);
-          }
-        }
+      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;
       }
-      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);
-        }
+      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));
     }
-    if (where.length > 0) {
-      query += ` WHERE ${where.join(" AND ")}`;
-    }
-    paramIdx = params.length + 1;
-    query += ` ORDER BY created_at DESC LIMIT $${paramIdx++} OFFSET $${paramIdx}`;
-    params.push(limit, offset);
-    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,
-      failureReason: job.failureReason
-    }));
-  } catch (error) {
-    log(`Error getting jobs: ${error}`);
-    throw error;
-  } finally {
-    client.release();
-  }
-};
-
-// src/processor.ts
-async function processJobWithHandlers(pool, job, jobHandlers) {
+  };
+  return ctx;
+}
+async function processJobWithHandlers(backend, job, jobHandlers) {
   const handler = jobHandlers[job.jobType];
   if (!handler) {
-    await setPendingReasonForUnpickedJobs(
-      pool,
+    await backend.setPendingReasonForUnpickedJobs(
       `No handler registered for job type: ${job.jobType}`,
       job.jobType
     );
-    await failJob(
-      pool,
+    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 {
-    const jobPromise = handler(job.payload, controller.signal);
-    if (timeoutMs && timeoutMs > 0) {
-      await Promise.race([
-        jobPromise,
-        new Promise((_, reject) => {
-          timeoutId = setTimeout(() => {
-            controller.abort();
-            const timeoutError = new Error(
-              `Job timed out after ${timeoutMs} ms`
-            );
-            timeoutError.failureReason = "timeout" /* Timeout */;
-            reject(timeoutError);
-          }, timeoutMs);
-        })
-      ]);
+    if (forceKillOnTimeout && timeoutMs && timeoutMs > 0) {
+      await runHandlerInWorker(handler, job.payload, timeoutMs, job.jobType);
     } else {
-      await jobPromise;
+      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 completeJob(pool, job.id);
+    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 failJob(
-      pool,
+    await backend.failJob(
       job.id,
       error instanceof Error ? error : new Error(String(error)),
       failureReason
     );
   }
 }
-async function processBatchWithHandlers(pool, workerId, batchSize, jobType, jobHandlers, concurrency) {
-  const jobs = await getNextBatch(
-    pool,
+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(pool, job, jobHandlers))
+      jobs.map((job) => processJobWithHandlers(backend, job, jobHandlers))
     );
     return jobs.length;
   }
@@ -714,13 +1711,16 @@ async function processBatchWithHandlers(pool, workerId, batchSize, jobType, jobH
       while (running < concurrency && idx < jobs.length) {
         const job = jobs[idx++];
         running++;
-        processJobWithHandlers(pool, job, jobHandlers).then(() => {
+        processJobWithHandlers(backend, job, jobHandlers).then(() => {
           running--;
           finished++;
           next();
         }).catch((err) => {
           running--;
           finished++;
+          if (onError) {
+            onError(err instanceof Error ? err : new Error(String(err)));
+          }
           next();
         });
       }
@@ -728,7 +1728,7 @@ async function processBatchWithHandlers(pool, workerId, batchSize, jobType, jobH
     next();
   });
 }
-var createProcessor = (pool, handlers, options = {}) => {
+var createProcessor = (backend, handlers, options = {}) => {
   const {
     workerId = `worker-${Math.random().toString(36).substring(2, 9)}`,
     batchSize = 10,
@@ -739,6 +1739,7 @@ var createProcessor = (pool, handlers, options = {}) => {
   } = options;
   let running = false;
   let intervalId = null;
+  let currentBatchPromise = null;
   setLogContext(options.verbose ?? false);
   const processJobs = async () => {
     if (!running) return 0;
@@ -747,12 +1748,13 @@ var createProcessor = (pool, handlers, options = {}) => {
     );
     try {
       const processed = await processBatchWithHandlers(
-        pool,
+        backend,
         workerId,
         batchSize,
         jobType,
         handlers,
-        concurrency
+        concurrency,
+        onError
       );
       return processed;
     } catch (error) {
@@ -770,27 +1772,56 @@ var createProcessor = (pool, handlers, options = {}) => {
       if (running) return;
       log(`Starting job processor with workerId: ${workerId}`);
       running = true;
-      const processBatches = async () => {
+      const scheduleNext = (immediate) => {
         if (!running) return;
-        const processed = await processJobs();
-        if (processed === batchSize && running) {
-          setImmediate(processBatches);
+        if (immediate) {
+          intervalId = setTimeout(loop, 0);
+        } else {
+          intervalId = setTimeout(loop, pollInterval);
         }
       };
-      processBatches();
-      intervalId = setInterval(processJobs, 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
+     * 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) {
-        clearInterval(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.
@@ -889,60 +1920,1263 @@ Recommended: Remove sslmode from the connection string when using a custom CA.
   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;
+    });
+  }
+  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;
+  }
+};
+
+// 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 { databaseConfig } = config;
-  const pool = createPool(databaseConfig);
+  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;
+  };
   return {
     // Job queue operations
     addJob: withLogContext(
-      (job) => addJob(pool, job),
+      (job) => backend.addJob(job),
       config.verbose ?? false
     ),
     getJob: withLogContext(
-      (id) => getJob(pool, id),
+      (id) => backend.getJob(id),
       config.verbose ?? false
     ),
     getJobsByStatus: withLogContext(
-      (status, limit, offset) => getJobsByStatus(pool, status, limit, offset),
+      (status, limit, offset) => backend.getJobsByStatus(status, limit, offset),
       config.verbose ?? false
     ),
     getAllJobs: withLogContext(
-      (limit, offset) => getAllJobs(pool, limit, offset),
+      (limit, offset) => backend.getAllJobs(limit, offset),
       config.verbose ?? false
     ),
     getJobs: withLogContext(
-      (filters, limit, offset) => getJobs(pool, filters, limit, offset),
+      (filters, limit, offset) => backend.getJobs(filters, limit, offset),
       config.verbose ?? false
     ),
-    retryJob: (jobId) => retryJob(pool, jobId),
-    cleanupOldJobs: (daysToKeep) => cleanupOldJobs(pool, daysToKeep),
+    retryJob: (jobId) => backend.retryJob(jobId),
+    cleanupOldJobs: (daysToKeep) => backend.cleanupOldJobs(daysToKeep),
+    cleanupOldJobEvents: (daysToKeep) => backend.cleanupOldJobEvents(daysToKeep),
     cancelJob: withLogContext(
-      (jobId) => cancelJob(pool, jobId),
+      (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) => cancelAllUpcomingJobs(pool, filters),
+      (filters) => backend.cancelAllUpcomingJobs(filters),
       config.verbose ?? false
     ),
     reclaimStuckJobs: withLogContext(
-      (maxProcessingTimeMinutes) => reclaimStuckJobs(pool, maxProcessingTimeMinutes),
+      (maxProcessingTimeMinutes) => backend.reclaimStuckJobs(maxProcessingTimeMinutes),
       config.verbose ?? false
     ),
     getJobsByTags: withLogContext(
-      (tags, mode = "all", limit, offset) => getJobsByTags(pool, tags, mode, limit, offset),
+      (tags, mode = "all", limit, offset) => backend.getJobsByTags(tags, mode, limit, offset),
       config.verbose ?? false
     ),
     // Job processing
-    createProcessor: (handlers, options) => createProcessor(pool, handlers, options),
-    // Advanced access (for custom operations)
-    getPool: () => pool,
+    createProcessor: (handlers, options) => createProcessor(backend, handlers, options),
     // Job events
     getJobEvents: withLogContext(
-      (jobId) => getJobEvents(pool, jobId),
+      (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
+    ),
+    // 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) => {
@@ -950,6 +3184,6 @@ var withLogContext = (fn, verbose) => (...args) => {
   return fn(...args);
 };
 
-export { FailureReason, JobEventType, initJobQueue };
+export { FailureReason, JobEventType, PostgresBackend, WaitSignal, initJobQueue, testHandlerSerialization, validateHandlerSerializable2 as validateHandlerSerializable };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map