@nicnocquee/dataqueue 1.25.0 → 1.26.0

package/dist/index.js

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