@nicnocquee/dataqueue 1.25.0 → 1.26.0-beta.20260223195940

package/dist/index.cjs

@@ -1,18 +1,21 @@
 'use strict';
 
-var async_hooks = require('async_hooks');
-var crypto = require('crypto');
 var worker_threads = require('worker_threads');
+var async_hooks = require('async_hooks');
 var pg = require('pg');
 var pgConnectionString = require('pg-connection-string');
 var fs = require('fs');
+var crypto = require('crypto');
 var module$1 = require('module');
+var croner = require('croner');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 
+// src/processor.ts
+
 // src/types.ts
 var JobEventType = /* @__PURE__ */ ((JobEventType2) => {
   JobEventType2["Added"] = "added";
@@ -26,11 +29,11 @@ var JobEventType = /* @__PURE__ */ ((JobEventType2) => {
   JobEventType2["Waiting"] = "waiting";
   return JobEventType2;
 })(JobEventType || {});
-var FailureReason = /* @__PURE__ */ ((FailureReason5) => {
-  FailureReason5["Timeout"] = "timeout";
-  FailureReason5["HandlerError"] = "handler_error";
-  FailureReason5["NoHandler"] = "no_handler";
-  return FailureReason5;
+var FailureReason = /* @__PURE__ */ ((FailureReason4) => {
+  FailureReason4["Timeout"] = "timeout";
+  FailureReason4["HandlerError"] = "handler_error";
+  FailureReason4["NoHandler"] = "no_handler";
+  return FailureReason4;
 })(FailureReason || {});
 var WaitSignal = class extends Error {
   constructor(type, waitUntil, tokenId, stepData) {
@@ -57,265 +60,1274 @@ var 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}"` : ""}`
+// src/processor.ts
+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.`
       );
-      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 (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.`
       );
-      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]
+      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.`
       );
-      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}`);
+  } catch (error) {
+    if (error instanceof Error) {
       throw error;
-    } finally {
-      client.release();
     }
+    throw new Error(
+      `Failed to validate handler serialization for job type "${jobType}": ${String(error)}`
+    );
   }
-  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);
+}
+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_threads.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(backend, 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 backend.getWaitpoint(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, 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 backend.updateStepData(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 backend.createWaitpoint(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 backend.getWaitpoint(tokenId);
+      if (wp && wp.status === "completed") {
+        const result = {
+          ok: true,
+          output: wp.output
+        };
+        stepData[waitKey] = {
+          type: "token",
+          tokenId,
+          completed: true,
+          result
+        };
+        await backend.updateStepData(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 backend.updateStepData(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 hasStepHistory = Object.keys(stepData).some(
+    (k) => k.startsWith("__wait_")
+  );
+  if (hasStepHistory) {
+    await resolveCompletedWaits(backend, stepData);
+    await backend.updateStepData(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 = buildWaitContext(backend, job.id, stepData, 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) {
+      log(
+        `Job ${job.id} entering wait: type=${error.type}, waitUntil=${error.waitUntil?.toISOString() ?? "none"}, tokenId=${error.tokenId ?? "none"}`
+      );
+      await backend.waitJob(job.id, {
+        waitUntil: error.waitUntil,
+        waitTokenId: error.tokenId,
+        stepData: error.stepData
+      });
+      return;
+    }
+    console.error(`Error processing job ${job.id}:`, error);
+    let failureReason = "handler_error" /* HandlerError */;
+    if (error && typeof error === "object" && "failureReason" in error && error.failureReason === "timeout" /* Timeout */) {
+      failureReason = "timeout" /* Timeout */;
+    }
+    await backend.failJob(
+      job.id,
+      error instanceof Error ? error : new Error(String(error)),
+      failureReason
+    );
+  }
+}
+async function processBatchWithHandlers(backend, workerId, batchSize, jobType, jobHandlers, concurrency, onError) {
+  const jobs = await backend.getNextBatch(
+    workerId,
+    batchSize,
+    jobType
+  );
+  if (!concurrency || concurrency >= jobs.length) {
+    await Promise.all(
+      jobs.map((job) => processJobWithHandlers(backend, job, jobHandlers))
+    );
+    return jobs.length;
+  }
+  let idx = 0;
+  let running = 0;
+  let finished = 0;
+  return new Promise((resolve, reject) => {
+    const next = () => {
+      if (finished === jobs.length) return resolve(jobs.length);
+      while (running < concurrency && idx < jobs.length) {
+        const job = jobs[idx++];
+        running++;
+        processJobWithHandlers(backend, job, jobHandlers).then(() => {
+          running--;
+          finished++;
+          next();
+        }).catch((err) => {
+          running--;
+          finished++;
+          if (onError) {
+            onError(err instanceof Error ? err : new Error(String(err)));
+          }
+          next();
+        });
+      }
+    };
+    next();
+  });
+}
+var createProcessor = (backend, handlers, options = {}, onBeforeBatch) => {
+  const {
+    workerId = `worker-${Math.random().toString(36).substring(2, 9)}`,
+    batchSize = 10,
+    pollInterval = 5e3,
+    onError = (error) => console.error("Job processor error:", error),
+    jobType,
+    concurrency = 3
+  } = options;
+  let running = false;
+  let intervalId = null;
+  let currentBatchPromise = null;
+  setLogContext(options.verbose ?? false);
+  const processJobs = async () => {
+    if (!running) return 0;
+    if (onBeforeBatch) {
+      try {
+        await onBeforeBatch();
+      } catch (hookError) {
+        log(`onBeforeBatch hook error: ${hookError}`);
+        if (onError) {
+          onError(
+            hookError instanceof Error ? hookError : new Error(String(hookError))
+          );
+        }
+      }
+    }
+    log(
+      `Processing jobs with workerId: ${workerId}${jobType ? ` and jobType: ${Array.isArray(jobType) ? jobType.join(",") : jobType}` : ""}`
+    );
+    try {
+      const processed = await processBatchWithHandlers(
+        backend,
+        workerId,
+        batchSize,
+        jobType,
+        handlers,
+        concurrency,
+        onError
+      );
+      return processed;
+    } catch (error) {
+      onError(error instanceof Error ? error : new Error(String(error)));
+    }
+    return 0;
+  };
+  return {
+    /**
+     * Start the job processor in the background.
+     * - This will run periodically (every pollInterval milliseconds or 5 seconds if not provided) and process jobs as they become available.
+     * - You have to call the stop method to stop the processor.
+     */
+    startInBackground: () => {
+      if (running) return;
+      log(`Starting job processor with workerId: ${workerId}`);
+      running = true;
+      const scheduleNext = (immediate) => {
+        if (!running) return;
+        if (immediate) {
+          intervalId = setTimeout(loop, 0);
+        } else {
+          intervalId = setTimeout(loop, pollInterval);
+        }
+      };
+      const loop = async () => {
+        if (!running) return;
+        currentBatchPromise = processJobs();
+        const processed = await currentBatchPromise;
+        currentBatchPromise = null;
+        scheduleNext(processed === batchSize);
+      };
+      loop();
+    },
+    /**
+     * Stop the job processor that runs in the background.
+     * Does not wait for in-flight jobs.
+     */
+    stop: () => {
+      log(`Stopping job processor with workerId: ${workerId}`);
+      running = false;
+      if (intervalId) {
+        clearTimeout(intervalId);
+        intervalId = null;
+      }
+    },
+    /**
+     * Stop the job processor and wait for all in-flight jobs to complete.
+     * Useful for graceful shutdown (e.g., SIGTERM handling).
+     */
+    stopAndDrain: async (drainTimeoutMs = 3e4) => {
+      log(`Stopping and draining job processor with workerId: ${workerId}`);
+      running = false;
+      if (intervalId) {
+        clearTimeout(intervalId);
+        intervalId = null;
+      }
+      if (currentBatchPromise) {
+        await Promise.race([
+          currentBatchPromise.catch(() => {
+          }),
+          new Promise((resolve) => setTimeout(resolve, drainTimeoutMs))
+        ]);
+        currentBatchPromise = null;
+      }
+      log(`Job processor ${workerId} drained`);
+    },
+    /**
+     * Start the job processor synchronously.
+     * - This will process all jobs immediately and then stop.
+     * - The pollInterval is ignored.
+     */
+    start: async () => {
+      log(`Starting job processor with workerId: ${workerId}`);
+      running = true;
+      const processed = await processJobs();
+      running = false;
+      return processed;
+    },
+    isRunning: () => running
+  };
+};
+
+// src/supervisor.ts
+var createSupervisor = (backend, options = {}) => {
+  const {
+    intervalMs = 6e4,
+    stuckJobsTimeoutMinutes = 10,
+    cleanupJobsDaysToKeep = 30,
+    cleanupEventsDaysToKeep = 30,
+    cleanupBatchSize = 1e3,
+    reclaimStuckJobs = true,
+    expireTimedOutTokens = true,
+    onError = (error) => console.error("Supervisor maintenance error:", error),
+    verbose = false
+  } = options;
+  let running = false;
+  let timeoutId = null;
+  let currentRunPromise = null;
+  setLogContext(verbose);
+  const runOnce = async () => {
+    setLogContext(verbose);
+    const result = {
+      reclaimedJobs: 0,
+      cleanedUpJobs: 0,
+      cleanedUpEvents: 0,
+      expiredTokens: 0
+    };
+    if (reclaimStuckJobs) {
+      try {
+        result.reclaimedJobs = await backend.reclaimStuckJobs(
+          stuckJobsTimeoutMinutes
+        );
+        if (result.reclaimedJobs > 0) {
+          log(`Supervisor: reclaimed ${result.reclaimedJobs} stuck jobs`);
+        }
+      } catch (e) {
+        onError(e instanceof Error ? e : new Error(String(e)));
+      }
+    }
+    if (cleanupJobsDaysToKeep > 0) {
+      try {
+        result.cleanedUpJobs = await backend.cleanupOldJobs(
+          cleanupJobsDaysToKeep,
+          cleanupBatchSize
+        );
+        if (result.cleanedUpJobs > 0) {
+          log(`Supervisor: cleaned up ${result.cleanedUpJobs} old jobs`);
+        }
+      } catch (e) {
+        onError(e instanceof Error ? e : new Error(String(e)));
+      }
+    }
+    if (cleanupEventsDaysToKeep > 0) {
+      try {
+        result.cleanedUpEvents = await backend.cleanupOldJobEvents(
+          cleanupEventsDaysToKeep,
+          cleanupBatchSize
+        );
+        if (result.cleanedUpEvents > 0) {
+          log(
+            `Supervisor: cleaned up ${result.cleanedUpEvents} old job events`
+          );
+        }
+      } catch (e) {
+        onError(e instanceof Error ? e : new Error(String(e)));
+      }
+    }
+    if (expireTimedOutTokens) {
+      try {
+        result.expiredTokens = await backend.expireTimedOutWaitpoints();
+        if (result.expiredTokens > 0) {
+          log(`Supervisor: expired ${result.expiredTokens} timed-out tokens`);
+        }
+      } catch (e) {
+        onError(e instanceof Error ? e : new Error(String(e)));
+      }
+    }
+    return result;
+  };
+  return {
+    start: async () => {
+      return runOnce();
+    },
+    startInBackground: () => {
+      if (running) return;
+      log("Supervisor: starting background maintenance loop");
+      running = true;
+      const loop = async () => {
+        if (!running) return;
+        currentRunPromise = runOnce();
+        await currentRunPromise;
+        currentRunPromise = null;
+        if (running) {
+          timeoutId = setTimeout(loop, intervalMs);
+        }
+      };
+      loop();
+    },
+    stop: () => {
+      running = false;
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      log("Supervisor: stopped");
+    },
+    stopAndDrain: async (timeoutMs = 3e4) => {
+      running = false;
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (currentRunPromise) {
+        log("Supervisor: draining current maintenance run\u2026");
+        await Promise.race([
+          currentRunPromise,
+          new Promise((resolve) => setTimeout(resolve, timeoutMs))
+        ]);
+        currentRunPromise = null;
+      }
+      log("Supervisor: drained and stopped");
+    },
+    isRunning: () => running
+  };
+};
+function loadPemOrFile(value) {
+  if (!value) return void 0;
+  if (value.startsWith("file://")) {
+    const filePath = value.slice(7);
+    return fs__default.default.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 = pgConnectionString.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 pg.Pool({
+    ...config,
+    ...ssl ? { ssl } : {}
+  });
+  if (searchPath) {
+    pool.on("connect", (client) => {
+      client.query(`SET search_path TO ${searchPath}`);
+    });
+  }
+  return pool;
+};
+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 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 ──────────────────────────────────────────────────────────
+  /**
+   * Add a job and return its numeric ID.
+   *
+   * @param job - Job configuration.
+   * @param options - Optional. Pass `{ db }` to run the INSERT on an external
+   *   client (e.g., inside a transaction) so the job is part of the caller's
+   *   transaction. The event INSERT also uses the same client.
+   */
+  async addJob({
+    jobType,
+    payload,
+    maxAttempts = 3,
+    priority = 0,
+    runAt = null,
+    timeoutMs = void 0,
+    forceKillOnTimeout = false,
+    tags = void 0,
+    idempotencyKey = void 0,
+    retryDelay = void 0,
+    retryBackoff = void 0,
+    retryDelayMax = void 0
+  }, options) {
+    const externalClient = options?.db;
+    const client = externalClient ?? 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, retry_delay, retry_backoff, retry_delay_max) 
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12) 
+           ${onConflict}
+           RETURNING id`,
+          [
+            jobType,
+            payload,
+            maxAttempts,
+            priority,
+            runAt,
+            timeoutMs ?? null,
+            forceKillOnTimeout ?? false,
+            tags ?? null,
+            idempotencyKey ?? null,
+            retryDelay ?? null,
+            retryBackoff ?? null,
+            retryDelayMax ?? 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, retry_delay, retry_backoff, retry_delay_max) 
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) 
+           ${onConflict}
+           RETURNING id`,
+          [
+            jobType,
+            payload,
+            maxAttempts,
+            priority,
+            timeoutMs ?? null,
+            forceKillOnTimeout ?? false,
+            tags ?? null,
+            idempotencyKey ?? null,
+            retryDelay ?? null,
+            retryBackoff ?? null,
+            retryDelayMax ?? 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}"` : ""}`
+      );
+      if (externalClient) {
+        try {
+          await client.query(
+            `INSERT INTO job_events (job_id, event_type, metadata) VALUES ($1, $2, $3)`,
+            [
+              jobId,
+              "added" /* Added */,
+              JSON.stringify({ jobType, payload, tags, idempotencyKey })
+            ]
+          );
+        } catch (error) {
+          log(`Error recording job event for job ${jobId}: ${error}`);
+        }
+      } else {
+        await this.recordJobEvent(jobId, "added" /* Added */, {
+          jobType,
+          payload,
+          tags,
+          idempotencyKey
+        });
+      }
+      return jobId;
+    } catch (error) {
+      log(`Error adding job: ${error}`);
+      throw error;
+    } finally {
+      if (!externalClient) client.release();
+    }
+  }
+  /**
+   * Insert multiple jobs in a single database round-trip.
+   *
+   * Uses a multi-row INSERT with ON CONFLICT handling for idempotency keys.
+   * Returns IDs in the same order as the input array.
+   */
+  async addJobs(jobs, options) {
+    if (jobs.length === 0) return [];
+    const externalClient = options?.db;
+    const client = externalClient ?? await this.pool.connect();
+    try {
+      const COLS_PER_JOB = 12;
+      const valueClauses = [];
+      const params = [];
+      const hasAnyIdempotencyKey = jobs.some((j) => j.idempotencyKey);
+      for (let i = 0; i < jobs.length; i++) {
+        const {
+          jobType,
+          payload,
+          maxAttempts = 3,
+          priority = 0,
+          runAt = null,
+          timeoutMs = void 0,
+          forceKillOnTimeout = false,
+          tags = void 0,
+          idempotencyKey = void 0,
+          retryDelay = void 0,
+          retryBackoff = void 0,
+          retryDelayMax = void 0
+        } = jobs[i];
+        const base = i * COLS_PER_JOB;
+        valueClauses.push(
+          `($${base + 1}, $${base + 2}, $${base + 3}, $${base + 4}, COALESCE($${base + 5}::timestamptz, CURRENT_TIMESTAMP), $${base + 6}, $${base + 7}, $${base + 8}, $${base + 9}, $${base + 10}, $${base + 11}, $${base + 12})`
+        );
+        params.push(
+          jobType,
+          payload,
+          maxAttempts,
+          priority,
+          runAt,
+          timeoutMs ?? null,
+          forceKillOnTimeout ?? false,
+          tags ?? null,
+          idempotencyKey ?? null,
+          retryDelay ?? null,
+          retryBackoff ?? null,
+          retryDelayMax ?? null
+        );
+      }
+      const onConflict = hasAnyIdempotencyKey ? `ON CONFLICT (idempotency_key) WHERE idempotency_key IS NOT NULL DO NOTHING` : "";
+      const 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, retry_delay, retry_backoff, retry_delay_max)
+         VALUES ${valueClauses.join(", ")}
+         ${onConflict}
+         RETURNING id, idempotency_key`,
+        params
+      );
+      const returnedKeyToId = /* @__PURE__ */ new Map();
+      const returnedNullKeyIds = [];
+      for (const row of result.rows) {
+        if (row.idempotency_key != null) {
+          returnedKeyToId.set(row.idempotency_key, row.id);
+        } else {
+          returnedNullKeyIds.push(row.id);
+        }
+      }
+      const missingKeys = [];
+      for (const job of jobs) {
+        if (job.idempotencyKey && !returnedKeyToId.has(job.idempotencyKey)) {
+          missingKeys.push(job.idempotencyKey);
+        }
+      }
+      if (missingKeys.length > 0) {
+        const existing = await client.query(
+          `SELECT id, idempotency_key FROM job_queue WHERE idempotency_key = ANY($1)`,
+          [missingKeys]
+        );
+        for (const row of existing.rows) {
+          returnedKeyToId.set(row.idempotency_key, row.id);
+        }
+      }
+      let nullKeyIdx = 0;
+      const ids = [];
+      for (const job of jobs) {
+        if (job.idempotencyKey) {
+          const id = returnedKeyToId.get(job.idempotencyKey);
+          if (id === void 0) {
+            throw new Error(
+              `Failed to resolve job ID for idempotency key "${job.idempotencyKey}"`
+            );
+          }
+          ids.push(id);
+        } else {
+          ids.push(returnedNullKeyIds[nullKeyIdx++]);
+        }
+      }
+      log(`Batch-inserted ${jobs.length} jobs, IDs: [${ids.join(", ")}]`);
+      const newJobEvents = [];
+      for (let i = 0; i < jobs.length; i++) {
+        const job = jobs[i];
+        const wasInserted = !job.idempotencyKey || !missingKeys.includes(job.idempotencyKey);
+        if (wasInserted) {
+          newJobEvents.push({
+            jobId: ids[i],
+            eventType: "added" /* Added */,
+            metadata: {
+              jobType: job.jobType,
+              payload: job.payload,
+              tags: job.tags,
+              idempotencyKey: job.idempotencyKey
+            }
+          });
+        }
+      }
+      if (newJobEvents.length > 0) {
+        if (externalClient) {
+          const evtValues = [];
+          const evtParams = [];
+          let evtIdx = 1;
+          for (const evt of newJobEvents) {
+            evtValues.push(`($${evtIdx++}, $${evtIdx++}, $${evtIdx++})`);
+            evtParams.push(
+              evt.jobId,
+              evt.eventType,
+              evt.metadata ? JSON.stringify(evt.metadata) : null
+            );
+          }
+          try {
+            await client.query(
+              `INSERT INTO job_events (job_id, event_type, metadata) VALUES ${evtValues.join(", ")}`,
+              evtParams
+            );
+          } catch (error) {
+            log(`Error recording batch job events: ${error}`);
+          }
+        } else {
+          await this.recordJobEventsBatch(newJobEvents);
+        }
+      }
+      return ids;
+    } catch (error) {
+      log(`Error batch-inserting jobs: ${error}`);
+      throw error;
+    } finally {
+      if (!externalClient) 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, retry_delay AS "retryDelay", retry_backoff AS "retryBackoff", retry_delay_max AS "retryDelayMax" 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, retry_delay AS "retryDelay", retry_backoff AS "retryBackoff", retry_delay_max AS "retryDelayMax" 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, retry_delay AS "retryDelay", retry_backoff AS "retryBackoff", retry_delay_max AS "retryDelayMax" 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, retry_delay AS "retryDelay", retry_backoff AS "retryBackoff", retry_delay_max AS "retryDelayMax" 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) {
@@ -353,7 +1365,7 @@ var PostgresBackend = class {
   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
+      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, retry_delay AS "retryDelay", retry_backoff AS "retryBackoff", retry_delay_max AS "retryDelayMax"
          FROM job_queue`;
       let params = [];
       switch (mode) {
@@ -447,7 +1459,7 @@ var PostgresBackend = class {
           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
+        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, retry_delay AS "retryDelay", retry_backoff AS "retryBackoff", retry_delay_max AS "retryDelayMax"
       `,
         params
       );
@@ -509,9 +1521,17 @@ var PostgresBackend = class {
         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
+            next_attempt_at = CASE
+              WHEN attempts >= max_attempts THEN NULL
+              WHEN retry_delay IS NULL AND retry_backoff IS NULL AND retry_delay_max IS NULL
+                THEN NOW() + (POWER(2, attempts) * INTERVAL '1 minute')
+              WHEN COALESCE(retry_backoff, true) = true
+                THEN NOW() + (LEAST(
+                  COALESCE(retry_delay_max, 2147483647),
+                  COALESCE(retry_delay, 60) * POWER(2, attempts)
+                ) * (0.5 + 0.5 * random()) * INTERVAL '1 second')
+              ELSE
+                NOW() + (COALESCE(retry_delay, 60) * INTERVAL '1 second')
             END,
             error_history = COALESCE(error_history, '[]'::jsonb) || $2::jsonb,
             failure_reason = $3,
@@ -749,6 +1769,18 @@ var PostgresBackend = class {
         updateFields.push(`tags = $${paramIdx++}`);
         params.push(updates.tags ?? null);
       }
+      if (updates.retryDelay !== void 0) {
+        updateFields.push(`retry_delay = $${paramIdx++}`);
+        params.push(updates.retryDelay ?? null);
+      }
+      if (updates.retryBackoff !== void 0) {
+        updateFields.push(`retry_backoff = $${paramIdx++}`);
+        params.push(updates.retryBackoff ?? null);
+      }
+      if (updates.retryDelayMax !== void 0) {
+        updateFields.push(`retry_delay_max = $${paramIdx++}`);
+        params.push(updates.retryDelayMax ?? null);
+      }
       if (updateFields.length === 0) {
         log(`No fields to update for job ${jobId}`);
         return;
@@ -770,6 +1802,12 @@ var PostgresBackend = class {
       if (updates.timeoutMs !== void 0)
         metadata.timeoutMs = updates.timeoutMs;
       if (updates.tags !== void 0) metadata.tags = updates.tags;
+      if (updates.retryDelay !== void 0)
+        metadata.retryDelay = updates.retryDelay;
+      if (updates.retryBackoff !== void 0)
+        metadata.retryBackoff = updates.retryBackoff;
+      if (updates.retryDelayMax !== void 0)
+        metadata.retryDelayMax = updates.retryDelayMax;
       await this.recordJobEvent(jobId, "edited" /* Edited */, metadata);
       log(`Edited job ${jobId}: ${JSON.stringify(metadata)}`);
     } catch (error) {
@@ -813,6 +1851,18 @@ var PostgresBackend = class {
         updateFields.push(`tags = $${paramIdx++}`);
         params.push(updates.tags ?? null);
       }
+      if (updates.retryDelay !== void 0) {
+        updateFields.push(`retry_delay = $${paramIdx++}`);
+        params.push(updates.retryDelay ?? null);
+      }
+      if (updates.retryBackoff !== void 0) {
+        updateFields.push(`retry_backoff = $${paramIdx++}`);
+        params.push(updates.retryBackoff ?? null);
+      }
+      if (updates.retryDelayMax !== void 0) {
+        updateFields.push(`retry_delay_max = $${paramIdx++}`);
+        params.push(updates.retryDelayMax ?? null);
+      }
       if (updateFields.length === 0) {
         log(`No fields to update for batch edit`);
         return 0;
@@ -909,45 +1959,85 @@ var PostgresBackend = class {
       client.release();
     }
   }
-  async cleanupOldJobs(daysToKeep = 30) {
-    const client = await this.pool.connect();
+  /**
+   * Delete completed jobs older than the given number of days.
+   * Deletes in batches of 1000 to avoid long-running transactions
+   * and excessive WAL bloat at scale.
+   *
+   * @param daysToKeep - Number of days to retain completed jobs (default 30).
+   * @param batchSize - Number of rows to delete per batch (default 1000).
+   * @returns Total number of deleted jobs.
+   */
+  async cleanupOldJobs(daysToKeep = 30, batchSize = 1e3) {
+    let totalDeleted = 0;
     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;
+      let deletedInBatch;
+      do {
+        const client = await this.pool.connect();
+        try {
+          const result = await client.query(
+            `
+            DELETE FROM job_queue
+            WHERE id IN (
+              SELECT id FROM job_queue
+              WHERE status = 'completed'
+              AND updated_at < NOW() - INTERVAL '1 day' * $1::int
+              LIMIT $2
+            )
+          `,
+            [daysToKeep, batchSize]
+          );
+          deletedInBatch = result.rowCount || 0;
+          totalDeleted += deletedInBatch;
+        } finally {
+          client.release();
+        }
+      } while (deletedInBatch === batchSize);
+      log(`Deleted ${totalDeleted} old jobs`);
+      return totalDeleted;
     } catch (error) {
       log(`Error cleaning up old jobs: ${error}`);
       throw error;
-    } finally {
-      client.release();
     }
   }
-  async cleanupOldJobEvents(daysToKeep = 30) {
-    const client = await this.pool.connect();
+  /**
+   * Delete job events older than the given number of days.
+   * Deletes in batches of 1000 to avoid long-running transactions
+   * and excessive WAL bloat at scale.
+   *
+   * @param daysToKeep - Number of days to retain events (default 30).
+   * @param batchSize - Number of rows to delete per batch (default 1000).
+   * @returns Total number of deleted events.
+   */
+  async cleanupOldJobEvents(daysToKeep = 30, batchSize = 1e3) {
+    let totalDeleted = 0;
     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;
+      let deletedInBatch;
+      do {
+        const client = await this.pool.connect();
+        try {
+          const result = await client.query(
+            `
+            DELETE FROM job_events
+            WHERE id IN (
+              SELECT id FROM job_events
+              WHERE created_at < NOW() - INTERVAL '1 day' * $1::int
+              LIMIT $2
+            )
+          `,
+            [daysToKeep, batchSize]
+          );
+          deletedInBatch = result.rowCount || 0;
+          totalDeleted += deletedInBatch;
+        } finally {
+          client.release();
+        }
+      } while (deletedInBatch === batchSize);
+      log(`Deleted ${totalDeleted} old job events`);
+      return totalDeleted;
     } catch (error) {
       log(`Error cleaning up old job events: ${error}`);
       throw error;
-    } finally {
-      client.release();
     }
   }
   async reclaimStuckJobs(maxProcessingTimeMinutes = 10) {
@@ -1005,926 +2095,540 @@ var PostgresBackend = class {
       client.release();
     }
   }
-  async setPendingReasonForUnpickedJobs(reason, jobType) {
+  // ── Cron schedules ──────────────────────────────────────────────────
+  /** Create a cron schedule and return its ID. */
+  async addCronSchedule(input) {
     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
+      const result = await client.query(
+        `INSERT INTO cron_schedules
+          (schedule_name, cron_expression, job_type, payload, max_attempts,
+           priority, timeout_ms, force_kill_on_timeout, tags, timezone,
+           allow_overlap, next_run_at, retry_delay, retry_backoff, retry_delay_max)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
+         RETURNING id`,
+        [
+          input.scheduleName,
+          input.cronExpression,
+          input.jobType,
+          input.payload,
+          input.maxAttempts,
+          input.priority,
+          input.timeoutMs,
+          input.forceKillOnTimeout,
+          input.tags ?? null,
+          input.timezone,
+          input.allowOverlap,
+          input.nextRunAt,
+          input.retryDelay,
+          input.retryBackoff,
+          input.retryDelayMax
+        ]
       );
+      const id = result.rows[0].id;
+      log(`Added cron schedule ${id}: "${input.scheduleName}"`);
+      return id;
+    } catch (error) {
+      if (error?.code === "23505") {
+        throw new Error(
+          `Cron schedule with name "${input.scheduleName}" already exists`
+        );
+      }
+      log(`Error adding cron schedule: ${error}`);
+      throw error;
     } finally {
       client.release();
     }
   }
-};
-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)`
+  /** Get a cron schedule by ID. */
+  async getCronSchedule(id) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `SELECT id, schedule_name AS "scheduleName", cron_expression AS "cronExpression",
+                job_type AS "jobType", payload, max_attempts AS "maxAttempts",
+                priority, timeout_ms AS "timeoutMs",
+                force_kill_on_timeout AS "forceKillOnTimeout", tags,
+                timezone, allow_overlap AS "allowOverlap", status,
+                last_enqueued_at AS "lastEnqueuedAt", last_job_id AS "lastJobId",
+                next_run_at AS "nextRunAt",
+                created_at AS "createdAt", updated_at AS "updatedAt",
+                retry_delay AS "retryDelay", retry_backoff AS "retryBackoff",
+                retry_delay_max AS "retryDelayMax"
+         FROM cron_schedules WHERE id = $1`,
+        [id]
       );
-      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_${crypto.randomUUID()}`;
-    let timeoutAt = null;
-    if (options?.timeout) {
-      const ms = parseTimeoutString(options.timeout);
-      timeoutAt = new Date(Date.now() + ms);
+      if (result.rows.length === 0) return null;
+      return result.rows[0];
+    } catch (error) {
+      log(`Error getting cron schedule ${id}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
     }
-    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]
+  /** Get a cron schedule by its unique name. */
+  async getCronScheduleByName(name) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `SELECT id, schedule_name AS "scheduleName", cron_expression AS "cronExpression",
+                job_type AS "jobType", payload, max_attempts AS "maxAttempts",
+                priority, timeout_ms AS "timeoutMs",
+                force_kill_on_timeout AS "forceKillOnTimeout", tags,
+                timezone, allow_overlap AS "allowOverlap", status,
+                last_enqueued_at AS "lastEnqueuedAt", last_job_id AS "lastJobId",
+                next_run_at AS "nextRunAt",
+                created_at AS "createdAt", updated_at AS "updatedAt",
+                retry_delay AS "retryDelay", retry_backoff AS "retryBackoff",
+                retry_delay_max AS "retryDelayMax"
+         FROM cron_schedules WHERE schedule_name = $1`,
+        [name]
       );
+      if (result.rows.length === 0) return null;
+      return result.rows[0];
+    } catch (error) {
+      log(`Error getting cron schedule by name "${name}": ${error}`);
+      throw error;
+    } finally {
+      client.release();
     }
-    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]
-        );
+  /** List cron schedules, optionally filtered by status. */
+  async listCronSchedules(status) {
+    const client = await this.pool.connect();
+    try {
+      let query = `SELECT id, schedule_name AS "scheduleName", cron_expression AS "cronExpression",
+                job_type AS "jobType", payload, max_attempts AS "maxAttempts",
+                priority, timeout_ms AS "timeoutMs",
+                force_kill_on_timeout AS "forceKillOnTimeout", tags,
+                timezone, allow_overlap AS "allowOverlap", status,
+                last_enqueued_at AS "lastEnqueuedAt", last_job_id AS "lastJobId",
+                next_run_at AS "nextRunAt",
+                created_at AS "createdAt", updated_at AS "updatedAt",
+                retry_delay AS "retryDelay", retry_backoff AS "retryBackoff",
+                retry_delay_max AS "retryDelayMax"
+         FROM cron_schedules`;
+      const params = [];
+      if (status) {
+        query += ` WHERE status = $1`;
+        params.push(status);
       }
+      query += ` ORDER BY created_at ASC`;
+      const result = await client.query(query, params);
+      return result.rows;
+    } catch (error) {
+      log(`Error listing cron schedules: ${error}`);
+      throw error;
+    } finally {
+      client.release();
     }
-    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.`
-      );
+  }
+  /** Delete a cron schedule by ID. */
+  async removeCronSchedule(id) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(`DELETE FROM cron_schedules WHERE id = $1`, [id]);
+      log(`Removed cron schedule ${id}`);
+    } catch (error) {
+      log(`Error removing cron schedule ${id}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
     }
+  }
+  /** Pause a cron schedule. */
+  async pauseCronSchedule(id) {
+    const client = await this.pool.connect();
     try {
-      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.`
+      await client.query(
+        `UPDATE cron_schedules SET status = 'paused', updated_at = NOW() WHERE id = $1`,
+        [id]
       );
+      log(`Paused cron schedule ${id}`);
+    } catch (error) {
+      log(`Error pausing cron schedule ${id}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
     }
-  } catch (error) {
-    if (error instanceof Error) {
+  }
+  /** Resume a paused cron schedule. */
+  async resumeCronSchedule(id) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(
+        `UPDATE cron_schedules SET status = 'active', updated_at = NOW() WHERE id = $1`,
+        [id]
+      );
+      log(`Resumed cron schedule ${id}`);
+    } catch (error) {
+      log(`Error resuming cron schedule ${id}: ${error}`);
       throw error;
+    } finally {
+      client.release();
     }
-    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_threads.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);
-        });
+  /** Edit a cron schedule. */
+  async editCronSchedule(id, updates, nextRunAt) {
+    const client = await this.pool.connect();
+    try {
+      const updateFields = [];
+      const params = [];
+      let paramIdx = 1;
+      if (updates.cronExpression !== void 0) {
+        updateFields.push(`cron_expression = $${paramIdx++}`);
+        params.push(updates.cronExpression);
       }
-    }, 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" }
-        };
+      if (updates.payload !== void 0) {
+        updateFields.push(`payload = $${paramIdx++}`);
+        params.push(updates.payload);
       }
-    }
-  }
-}
-function buildWaitContext(backend, pool, jobId, stepData, baseCtx) {
-  let waitCounter = 0;
-  const ctx = {
-    prolong: baseCtx.prolong,
-    onTimeout: baseCtx.onTimeout,
-    run: async (stepName, fn) => {
-      const cached = stepData[stepName];
-      if (cached && typeof cached === "object" && cached.__completed) {
-        log(`Step "${stepName}" replayed from cache for job ${jobId}`);
-        return cached.result;
+      if (updates.maxAttempts !== void 0) {
+        updateFields.push(`max_attempts = $${paramIdx++}`);
+        params.push(updates.maxAttempts);
       }
-      const result = await fn();
-      stepData[stepName] = { __completed: true, result };
-      await updateStepData(pool, jobId, stepData);
-      return result;
-    },
-    waitFor: async (duration) => {
-      const waitKey = `__wait_${waitCounter++}`;
-      const cached = stepData[waitKey];
-      if (cached && typeof cached === "object" && cached.completed) {
-        log(`Wait "${waitKey}" already completed for job ${jobId}, skipping`);
-        return;
+      if (updates.priority !== void 0) {
+        updateFields.push(`priority = $${paramIdx++}`);
+        params.push(updates.priority);
       }
-      const waitUntilDate = calculateWaitUntil(duration);
-      stepData[waitKey] = { type: "duration", completed: false };
-      throw new WaitSignal("duration", waitUntilDate, void 0, stepData);
-    },
-    waitUntil: async (date) => {
-      const waitKey = `__wait_${waitCounter++}`;
-      const cached = stepData[waitKey];
-      if (cached && typeof cached === "object" && cached.completed) {
-        log(`Wait "${waitKey}" already completed for job ${jobId}, skipping`);
-        return;
+      if (updates.timeoutMs !== void 0) {
+        updateFields.push(`timeout_ms = $${paramIdx++}`);
+        params.push(updates.timeoutMs);
       }
-      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;
+      if (updates.forceKillOnTimeout !== void 0) {
+        updateFields.push(`force_kill_on_timeout = $${paramIdx++}`);
+        params.push(updates.forceKillOnTimeout);
       }
-      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 (updates.tags !== void 0) {
+        updateFields.push(`tags = $${paramIdx++}`);
+        params.push(updates.tags);
       }
-      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;
+      if (updates.timezone !== void 0) {
+        updateFields.push(`timezone = $${paramIdx++}`);
+        params.push(updates.timezone);
       }
-      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`
-        );
+      if (updates.allowOverlap !== void 0) {
+        updateFields.push(`allow_overlap = $${paramIdx++}`);
+        params.push(updates.allowOverlap);
       }
-      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 (updates.retryDelay !== void 0) {
+        updateFields.push(`retry_delay = $${paramIdx++}`);
+        params.push(updates.retryDelay);
       }
-    }
-    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 */
-        );
+      if (updates.retryBackoff !== void 0) {
+        updateFields.push(`retry_backoff = $${paramIdx++}`);
+        params.push(updates.retryBackoff);
+      }
+      if (updates.retryDelayMax !== void 0) {
+        updateFields.push(`retry_delay_max = $${paramIdx++}`);
+        params.push(updates.retryDelayMax);
+      }
+      if (nextRunAt !== void 0) {
+        updateFields.push(`next_run_at = $${paramIdx++}`);
+        params.push(nextRunAt);
+      }
+      if (updateFields.length === 0) {
+        log(`No fields to update for cron schedule ${id}`);
         return;
       }
-      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 */;
+      updateFields.push(`updated_at = NOW()`);
+      params.push(id);
+      const query = `UPDATE cron_schedules SET ${updateFields.join(", ")} WHERE id = $${paramIdx}`;
+      await client.query(query, params);
+      log(`Edited cron schedule ${id}`);
+    } catch (error) {
+      log(`Error editing cron schedule ${id}: ${error}`);
+      throw error;
+    } finally {
+      client.release();
     }
-    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();
-        });
+  /**
+   * Atomically fetch all active cron schedules whose nextRunAt <= NOW().
+   * Uses FOR UPDATE SKIP LOCKED to prevent duplicate enqueuing across workers.
+   */
+  async getDueCronSchedules() {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(
+        `SELECT id, schedule_name AS "scheduleName", cron_expression AS "cronExpression",
+                job_type AS "jobType", payload, max_attempts AS "maxAttempts",
+                priority, timeout_ms AS "timeoutMs",
+                force_kill_on_timeout AS "forceKillOnTimeout", tags,
+                timezone, allow_overlap AS "allowOverlap", status,
+                last_enqueued_at AS "lastEnqueuedAt", last_job_id AS "lastJobId",
+                next_run_at AS "nextRunAt",
+                created_at AS "createdAt", updated_at AS "updatedAt",
+                retry_delay AS "retryDelay", retry_backoff AS "retryBackoff",
+                retry_delay_max AS "retryDelayMax"
+         FROM cron_schedules
+         WHERE status = 'active'
+           AND next_run_at IS NOT NULL
+           AND next_run_at <= NOW()
+         ORDER BY next_run_at ASC
+         FOR UPDATE SKIP LOCKED`
+      );
+      log(`Found ${result.rows.length} due cron schedules`);
+      return result.rows;
+    } catch (error) {
+      if (error?.code === "42P01") {
+        log("cron_schedules table does not exist, skipping cron enqueue");
+        return [];
       }
-    };
-    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}` : ""}`
-    );
+      log(`Error getting due cron schedules: ${error}`);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /**
+   * Update a cron schedule after a job has been enqueued.
+   * Sets lastEnqueuedAt, lastJobId, and advances nextRunAt.
+   */
+  async updateCronScheduleAfterEnqueue(id, lastEnqueuedAt, lastJobId, nextRunAt) {
+    const client = await this.pool.connect();
     try {
-      const processed = await processBatchWithHandlers(
-        backend,
-        workerId,
-        batchSize,
-        jobType,
-        handlers,
-        concurrency,
-        onError
+      await client.query(
+        `UPDATE cron_schedules
+         SET last_enqueued_at = $2,
+             last_job_id = $3,
+             next_run_at = $4,
+             updated_at = NOW()
+         WHERE id = $1`,
+        [id, lastEnqueuedAt, lastJobId, nextRunAt]
+      );
+      log(
+        `Updated cron schedule ${id}: lastJobId=${lastJobId}, nextRunAt=${nextRunAt?.toISOString() ?? "null"}`
       );
-      return processed;
     } catch (error) {
-      onError(error instanceof Error ? error : new Error(String(error)));
+      log(`Error updating cron schedule ${id} after enqueue: ${error}`);
+      throw error;
+    } finally {
+      client.release();
     }
-    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;
+  }
+  // ── Wait / step-data support ────────────────────────────────────────
+  /**
+   * Transition a job from 'processing' to 'waiting' status.
+   * Persists step data so the handler can resume from where it left off.
+   *
+   * @param jobId - The job to pause.
+   * @param options - Wait configuration including optional waitUntil date, token ID, and step data.
+   */
+  async waitJob(jobId, options) {
+    const client = await this.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;
       }
-      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__default.default.readFileSync(filePath, "utf8");
+      await this.recordJobEvent(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();
+    }
   }
-  return value;
-}
-var createPool = (config) => {
-  let searchPath;
-  let ssl = void 0;
-  let customCA;
-  let sslmode;
-  if (config.connectionString) {
+  /**
+   * Persist step data for a job. Called after each ctx.run() step completes.
+   * Best-effort: does not throw to avoid killing the running handler.
+   *
+   * @param jobId - The job to update.
+   * @param stepData - The step data to persist.
+   */
+  async updateStepData(jobId, stepData) {
+    const client = await this.pool.connect();
     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 };
+      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();
+    }
+  }
+  /**
+   * Create a waitpoint token in the database.
+   *
+   * @param jobId - The job ID to associate with the token (null if created outside a handler).
+   * @param options - Optional timeout string (e.g. '10m', '1h') and tags.
+   * @returns The created waitpoint with its unique ID.
+   */
+  async createWaitpoint(jobId, options) {
+    const client = await this.pool.connect();
+    try {
+      const id = `wp_${crypto.randomUUID()}`;
+      let timeoutAt = null;
+      if (options?.timeout) {
+        const ms = parseTimeoutString(options.timeout);
+        timeoutAt = new Date(Date.now() + ms);
       }
-    } catch (e) {
-      const parsed = pgConnectionString.parse(config.connectionString);
-      if (parsed.options) {
-        const match = parsed.options.match(/search_path=([^\s]+)/);
-        if (match) {
-          searchPath = match[1];
-        }
+      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();
+    }
+  }
+  /**
+   * Complete a waitpoint token and move the associated job back to 'pending'.
+   *
+   * @param tokenId - The waitpoint token ID to complete.
+   * @param data - Optional data to pass to the waiting handler.
+   */
+  async completeWaitpoint(tokenId, data) {
+    const client = await this.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;
       }
-      sslmode = typeof parsed.sslmode === "string" ? parsed.sslmode : void 0;
-      if (sslmode === "no-verify") {
-        ssl = { rejectUnauthorized: false };
+      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();
     }
   }
-  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;
+  /**
+   * Retrieve a waitpoint token by its ID.
+   *
+   * @param tokenId - The waitpoint token ID to look up.
+   * @returns The waitpoint record, or null if not found.
+   */
+  async getWaitpoint(tokenId) {
+    const client = await this.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();
     }
-    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 pg.Pool({
-    ...config,
-    ...ssl ? { ssl } : {}
-  });
-  if (searchPath) {
-    pool.on("connect", (client) => {
-      client.query(`SET search_path TO ${searchPath}`);
-    });
+  /**
+   * Expire timed-out waitpoint tokens and move their associated jobs back to 'pending'.
+   *
+   * @returns The number of tokens that were expired.
+   */
+  async expireTimedOutWaitpoints() {
+    const client = await this.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();
+    }
+  }
+  // ── Internal helpers ──────────────────────────────────────────────────
+  async setPendingReasonForUnpickedJobs(reason, jobType) {
+    const client = await this.pool.connect();
+    try {
+      let jobTypeFilter = "";
+      const params = [reason];
+      if (jobType) {
+        if (Array.isArray(jobType)) {
+          jobTypeFilter = ` AND job_type = ANY($2)`;
+          params.push(jobType);
+        } else {
+          jobTypeFilter = ` AND job_type = $2`;
+          params.push(jobType);
+        }
+      }
+      await client.query(
+        `UPDATE job_queue SET pending_reason = $1 WHERE status = 'pending'${jobTypeFilter}`,
+        params
+      );
+    } finally {
+      client.release();
+    }
   }
-  return pool;
 };
 
 // src/backends/redis-scripts.ts
@@ -1941,6 +2645,9 @@ 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])
+local retryDelay = ARGV[11]       -- "null" or seconds string
+local retryBackoff = ARGV[12]     -- "null" or "true"/"false"
+local retryDelayMax = ARGV[13]    -- "null" or seconds string
 
 -- Idempotency check
 if idempotencyKey ~= "null" then
@@ -1981,7 +2688,13 @@ redis.call('HMSET', jobKey,
   'lastFailedAt', 'null',
   'lastCancelledAt', 'null',
   'tags', tagsJson,
-  'idempotencyKey', idempotencyKey
+  'idempotencyKey', idempotencyKey,
+  'waitUntil', 'null',
+  'waitTokenId', 'null',
+  'stepData', 'null',
+  'retryDelay', retryDelay,
+  'retryBackoff', retryBackoff,
+  'retryDelayMax', retryDelayMax
 )
 
 -- Status index
@@ -2022,6 +2735,118 @@ end
 
 return id
 `;
+var ADD_JOBS_SCRIPT = `
+local prefix = KEYS[1]
+local jobsJson = ARGV[1]
+local nowMs = tonumber(ARGV[2])
+
+local jobs = cjson.decode(jobsJson)
+local results = {}
+
+for i, job in ipairs(jobs) do
+  local jobType = job.jobType
+  local payloadJson = job.payload
+  local maxAttempts = tonumber(job.maxAttempts)
+  local priority = tonumber(job.priority)
+  local runAtMs = tostring(job.runAtMs)
+  local timeoutMs = tostring(job.timeoutMs)
+  local forceKillOnTimeout = tostring(job.forceKillOnTimeout)
+  local tagsJson = tostring(job.tags)
+  local idempotencyKey = tostring(job.idempotencyKey)
+  local retryDelay = tostring(job.retryDelay)
+  local retryBackoff = tostring(job.retryBackoff)
+  local retryDelayMax = tostring(job.retryDelayMax)
+
+  -- Idempotency check
+  local skip = false
+  if idempotencyKey ~= "null" then
+    local existing = redis.call('GET', prefix .. 'idempotency:' .. idempotencyKey)
+    if existing then
+      results[i] = tonumber(existing)
+      skip = true
+    end
+  end
+
+  if not skip then
+    -- 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,
+      'waitUntil', 'null',
+      'waitTokenId', 'null',
+      'stepData', 'null',
+      'retryDelay', retryDelay,
+      'retryBackoff', retryBackoff,
+      'retryDelayMax', retryDelayMax
+    )
+
+    -- 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
+      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
+    redis.call('ZADD', prefix .. 'all', nowMs, id)
+
+    -- Queue or delayed
+    if runAt <= nowMs then
+      local score = priority * ${SCORE_RANGE} + (${SCORE_RANGE} - nowMs)
+      redis.call('ZADD', prefix .. 'queue', score, id)
+    else
+      redis.call('ZADD', prefix .. 'delayed', runAt, id)
+    end
+
+    results[i] = id
+  end
+end
+
+return results
+`;
 var GET_NEXT_BATCH_SCRIPT = `
 local prefix = KEYS[1]
 local workerId = ARGV[1]
@@ -2064,7 +2889,25 @@ for _, jobId in ipairs(retries) do
   redis.call('ZREM', prefix .. 'retry', jobId)
 end
 
--- 3. Parse job type filter
+-- 3. Move ready waiting jobs (time-based, no token) into queue
+local waitingJobs = redis.call('ZRANGEBYSCORE', prefix .. 'waiting', '-inf', nowMs, 'LIMIT', 0, 200)
+for _, jobId in ipairs(waitingJobs) do
+  local jk = prefix .. 'job:' .. jobId
+  local status = redis.call('HGET', jk, 'status')
+  local waitTokenId = redis.call('HGET', jk, 'waitTokenId')
+  if status == 'waiting' and (waitTokenId == false or waitTokenId == 'null') 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:waiting', jobId)
+    redis.call('SADD', prefix .. 'status:pending', jobId)
+    redis.call('HMSET', jk, 'status', 'pending', 'waitUntil', 'null')
+  end
+  redis.call('ZREM', prefix .. 'waiting', jobId)
+end
+
+-- 4. Parse job type filter
 local filterTypes = nil
 if jobTypeFilter ~= "null" then
   -- Could be a JSON array or a plain string
@@ -2077,7 +2920,7 @@ if jobTypeFilter ~= "null" then
   end
 end
 
--- 4. Pop candidates from queue (highest score first)
+-- 5. 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)
@@ -2161,7 +3004,10 @@ local jk = prefix .. 'job:' .. jobId
 redis.call('HMSET', jk,
   'status', 'completed',
   'updatedAt', nowMs,
-  'completedAt', nowMs
+  'completedAt', nowMs,
+  'stepData', 'null',
+  'waitUntil', 'null',
+  'waitTokenId', 'null'
 )
 redis.call('SREM', prefix .. 'status:processing', jobId)
 redis.call('SADD', prefix .. 'status:completed', jobId)
@@ -2179,11 +3025,38 @@ 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
+-- Read per-job retry config (may be "null")
+local rdRaw = redis.call('HGET', jk, 'retryDelay')
+local rbRaw = redis.call('HGET', jk, 'retryBackoff')
+local rmRaw = redis.call('HGET', jk, 'retryDelayMax')
+
 local nextAttemptAt = 'null'
 if attempts < maxAttempts then
-  local delayMs = math.pow(2, attempts) * 60000
-  nextAttemptAt = nowMs + delayMs
+  local allNull = (rdRaw == 'null' or rdRaw == false)
+               and (rbRaw == 'null' or rbRaw == false)
+               and (rmRaw == 'null' or rmRaw == false)
+  if allNull then
+    -- Legacy formula: 2^attempts minutes
+    local delayMs = math.pow(2, attempts) * 60000
+    nextAttemptAt = nowMs + delayMs
+  else
+    local retryDelaySec = 60
+    if rdRaw and rdRaw ~= 'null' then retryDelaySec = tonumber(rdRaw) end
+    local useBackoff = true
+    if rbRaw and rbRaw ~= 'null' then useBackoff = (rbRaw == 'true') end
+    local maxDelaySec = nil
+    if rmRaw and rmRaw ~= 'null' then maxDelaySec = tonumber(rmRaw) end
+
+    local delaySec
+    if useBackoff then
+      delaySec = retryDelaySec * math.pow(2, attempts)
+      if maxDelaySec then delaySec = math.min(delaySec, maxDelaySec) end
+      delaySec = delaySec * (0.5 + 0.5 * math.random())
+    else
+      delaySec = retryDelaySec
+    end
+    nextAttemptAt = nowMs + math.floor(delaySec * 1000)
+  end
 end
 
 -- Append to error_history
@@ -2220,6 +3093,7 @@ local nowMs = tonumber(ARGV[2])
 local jk = prefix .. 'job:' .. jobId
 
 local oldStatus = redis.call('HGET', jk, 'status')
+if oldStatus ~= 'failed' and oldStatus ~= 'processing' then return 0 end
 
 redis.call('HMSET', jk,
   'status', 'pending',
@@ -2231,9 +3105,7 @@ redis.call('HMSET', jk,
 )
 
 -- Remove from old status, add to pending
-if oldStatus then
-  redis.call('SREM', prefix .. 'status:' .. oldStatus, jobId)
-end
+redis.call('SREM', prefix .. 'status:' .. oldStatus, jobId)
 redis.call('SADD', prefix .. 'status:pending', jobId)
 
 -- Remove from retry sorted set if present
@@ -2254,18 +3126,21 @@ local nowMs = ARGV[2]
 local jk = prefix .. 'job:' .. jobId
 
 local status = redis.call('HGET', jk, 'status')
-if status ~= 'pending' then return 0 end
+if status ~= 'pending' and status ~= 'waiting' then return 0 end
 
 redis.call('HMSET', jk,
   'status', 'cancelled',
   'updatedAt', nowMs,
-  'lastCancelledAt', nowMs
+  'lastCancelledAt', nowMs,
+  'waitUntil', 'null',
+  'waitTokenId', 'null'
 )
-redis.call('SREM', prefix .. 'status:pending', jobId)
+redis.call('SREM', prefix .. 'status:' .. status, jobId)
 redis.call('SADD', prefix .. 'status:cancelled', jobId)
--- Remove from queue / delayed
+-- Remove from queue / delayed / waiting
 redis.call('ZREM', prefix .. 'queue', jobId)
 redis.call('ZREM', prefix .. 'delayed', jobId)
+redis.call('ZREM', prefix .. 'waiting', jobId)
 
 return 1
 `;
@@ -2333,18 +3208,16 @@ end
 
 return count
 `;
-var CLEANUP_OLD_JOBS_SCRIPT = `
+var CLEANUP_OLD_JOBS_BATCH_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
+for i = 2, #ARGV do
+  local jobId = ARGV[i]
   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')
@@ -2367,7 +3240,6 @@ for _, jobId in ipairs(completed) do
     if idempotencyKey and idempotencyKey ~= 'null' then
       redis.call('DEL', prefix .. 'idempotency:' .. idempotencyKey)
     end
-    -- Delete events
     redis.call('DEL', prefix .. 'events:' .. jobId)
 
     count = count + 1
@@ -2376,8 +3248,158 @@ end
 
 return count
 `;
+var WAIT_JOB_SCRIPT = `
+local prefix = KEYS[1]
+local jobId = ARGV[1]
+local waitUntilMs = ARGV[2]
+local waitTokenId = ARGV[3]
+local stepDataJson = ARGV[4]
+local nowMs = ARGV[5]
+local jk = prefix .. 'job:' .. jobId
+
+local status = redis.call('HGET', jk, 'status')
+if status ~= 'processing' then return 0 end
+
+redis.call('HMSET', jk,
+  'status', 'waiting',
+  'waitUntil', waitUntilMs,
+  'waitTokenId', waitTokenId,
+  'stepData', stepDataJson,
+  'lockedAt', 'null',
+  'lockedBy', 'null',
+  'updatedAt', nowMs
+)
+redis.call('SREM', prefix .. 'status:processing', jobId)
+redis.call('SADD', prefix .. 'status:waiting', jobId)
+
+-- Add to waiting sorted set if time-based wait
+if waitUntilMs ~= 'null' then
+  redis.call('ZADD', prefix .. 'waiting', tonumber(waitUntilMs), jobId)
+end
+
+return 1
+`;
+var COMPLETE_WAITPOINT_SCRIPT = `
+local prefix = KEYS[1]
+local tokenId = ARGV[1]
+local outputJson = ARGV[2]
+local nowMs = ARGV[3]
+local wpk = prefix .. 'waitpoint:' .. tokenId
+
+local wpStatus = redis.call('HGET', wpk, 'status')
+if not wpStatus or wpStatus ~= 'waiting' then return 0 end
+
+redis.call('HMSET', wpk,
+  'status', 'completed',
+  'output', outputJson,
+  'completedAt', nowMs
+)
+
+-- Move associated job back to pending
+local jobId = redis.call('HGET', wpk, 'jobId')
+if jobId and jobId ~= 'null' then
+  local jk = prefix .. 'job:' .. jobId
+  local jobStatus = redis.call('HGET', jk, 'status')
+  if jobStatus == 'waiting' then
+    redis.call('HMSET', jk,
+      'status', 'pending',
+      'waitTokenId', 'null',
+      'waitUntil', 'null',
+      'updatedAt', nowMs
+    )
+    redis.call('SREM', prefix .. 'status:waiting', jobId)
+    redis.call('SADD', prefix .. 'status:pending', jobId)
+    redis.call('ZREM', prefix .. 'waiting', 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)
+  end
+end
+
+return 1
+`;
+var EXPIRE_TIMED_OUT_WAITPOINTS_SCRIPT = `
+local prefix = KEYS[1]
+local nowMs = tonumber(ARGV[1])
+
+local expiredIds = redis.call('ZRANGEBYSCORE', prefix .. 'waitpoint_timeout', '-inf', nowMs)
+local count = 0
+
+for _, tokenId in ipairs(expiredIds) do
+  local wpk = prefix .. 'waitpoint:' .. tokenId
+  local wpStatus = redis.call('HGET', wpk, 'status')
+  if wpStatus == 'waiting' then
+    redis.call('HMSET', wpk,
+      'status', 'timed_out'
+    )
+
+    -- Move associated job back to pending
+    local jobId = redis.call('HGET', wpk, 'jobId')
+    if jobId and jobId ~= 'null' then
+      local jk = prefix .. 'job:' .. jobId
+      local jobStatus = redis.call('HGET', jk, 'status')
+      if jobStatus == 'waiting' then
+        redis.call('HMSET', jk,
+          'status', 'pending',
+          'waitTokenId', 'null',
+          'waitUntil', 'null',
+          'updatedAt', nowMs
+        )
+        redis.call('SREM', prefix .. 'status:waiting', jobId)
+        redis.call('SADD', prefix .. 'status:pending', jobId)
+        redis.call('ZREM', prefix .. 'waiting', jobId)
+
+        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)
+      end
+    end
+
+    count = count + 1
+  end
+  redis.call('ZREM', prefix .. 'waitpoint_timeout', tokenId)
+end
 
-// src/backends/redis.ts
+return count
+`;
+var MAX_TIMEOUT_MS2 = 365 * 24 * 60 * 60 * 1e3;
+function parseTimeoutString2(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_MS2) {
+    throw new Error(
+      `Timeout value "${timeout}" is too large. Maximum allowed is 365 days.`
+    );
+  }
+  return ms;
+}
 function hashToObject(arr) {
   const obj = {};
   for (let i = 0; i < arr.length; i += 2) {
@@ -2443,11 +3465,41 @@ function deserializeJob(h) {
     lastCancelledAt: dateOrNull(h.lastCancelledAt),
     tags,
     idempotencyKey: nullish(h.idempotencyKey),
-    progress: numOrNull(h.progress)
+    progress: numOrNull(h.progress),
+    waitUntil: dateOrNull(h.waitUntil),
+    waitTokenId: nullish(h.waitTokenId),
+    stepData: parseStepData(h.stepData),
+    retryDelay: numOrNull(h.retryDelay),
+    retryBackoff: h.retryBackoff === "true" ? true : h.retryBackoff === "false" ? false : null,
+    retryDelayMax: numOrNull(h.retryDelayMax)
   };
 }
+function parseStepData(raw) {
+  if (!raw || raw === "null") return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
 var RedisBackend = class {
-  constructor(redisConfig) {
+  /**
+   * Create a RedisBackend.
+   *
+   * @param configOrClient - Either `redisConfig` from the config file (the
+   *   library creates a new ioredis client) or an existing ioredis client
+   *   instance (bring your own).
+   * @param keyPrefix - Key prefix, only used when `configOrClient` is an
+   *   external client. Ignored when `redisConfig` is passed (uses
+   *   `redisConfig.keyPrefix` instead). Default: `'dq:'`.
+   */
+  constructor(configOrClient, keyPrefix) {
+    if (configOrClient && typeof configOrClient.eval === "function") {
+      this.client = configOrClient;
+      this.prefix = keyPrefix ?? "dq:";
+      return;
+    }
+    const redisConfig = configOrClient;
     let IORedis;
     try {
       const _require = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
@@ -2520,8 +3572,16 @@ var RedisBackend = class {
     timeoutMs = void 0,
     forceKillOnTimeout = false,
     tags = void 0,
-    idempotencyKey = void 0
-  }) {
+    idempotencyKey = void 0,
+    retryDelay = void 0,
+    retryBackoff = void 0,
+    retryDelayMax = void 0
+  }, options) {
+    if (options?.db) {
+      throw new Error(
+        "The db option is not supported with the Redis backend. Transactional job creation is only available with PostgreSQL."
+      );
+    }
     const now = this.nowMs();
     const runAtMs = runAt ? runAt.getTime() : 0;
     const result = await this.client.eval(
@@ -2537,7 +3597,10 @@ var RedisBackend = class {
       forceKillOnTimeout ? "true" : "false",
       tags ? JSON.stringify(tags) : "null",
       idempotencyKey ?? "null",
-      now
+      now,
+      retryDelay !== void 0 ? retryDelay.toString() : "null",
+      retryBackoff !== void 0 ? retryBackoff.toString() : "null",
+      retryDelayMax !== void 0 ? retryDelayMax.toString() : "null"
     );
     const jobId = Number(result);
     log(
@@ -2551,6 +3614,58 @@ var RedisBackend = class {
     });
     return jobId;
   }
+  /**
+   * Insert multiple jobs atomically via a single Lua script.
+   * Returns IDs in the same order as the input array.
+   */
+  async addJobs(jobs, options) {
+    if (jobs.length === 0) return [];
+    if (options?.db) {
+      throw new Error(
+        "The db option is not supported with the Redis backend. Transactional job creation is only available with PostgreSQL."
+      );
+    }
+    const now = this.nowMs();
+    const jobsPayload = jobs.map((job) => ({
+      jobType: job.jobType,
+      payload: JSON.stringify(job.payload),
+      maxAttempts: job.maxAttempts ?? 3,
+      priority: job.priority ?? 0,
+      runAtMs: job.runAt ? job.runAt.getTime() : 0,
+      timeoutMs: job.timeoutMs !== void 0 ? job.timeoutMs.toString() : "null",
+      forceKillOnTimeout: job.forceKillOnTimeout ? "true" : "false",
+      tags: job.tags ? JSON.stringify(job.tags) : "null",
+      idempotencyKey: job.idempotencyKey ?? "null",
+      retryDelay: job.retryDelay !== void 0 ? job.retryDelay.toString() : "null",
+      retryBackoff: job.retryBackoff !== void 0 ? job.retryBackoff.toString() : "null",
+      retryDelayMax: job.retryDelayMax !== void 0 ? job.retryDelayMax.toString() : "null"
+    }));
+    const result = await this.client.eval(
+      ADD_JOBS_SCRIPT,
+      1,
+      this.prefix,
+      JSON.stringify(jobsPayload),
+      now
+    );
+    const ids = result.map(Number);
+    log(`Batch-inserted ${jobs.length} jobs, IDs: [${ids.join(", ")}]`);
+    const existingIdempotencyIds = /* @__PURE__ */ new Set();
+    for (let i = 0; i < jobs.length; i++) {
+      if (jobs[i].idempotencyKey) {
+        if (existingIdempotencyIds.has(ids[i])) {
+          continue;
+        }
+        existingIdempotencyIds.add(ids[i]);
+      }
+      await this.recordJobEvent(ids[i], "added" /* Added */, {
+        jobType: jobs[i].jobType,
+        payload: jobs[i].payload,
+        tags: jobs[i].tags,
+        idempotencyKey: jobs[i].idempotencyKey
+      });
+    }
+    return ids;
+  }
   async getJob(id) {
     const data = await this.client.hgetall(`${this.prefix}job:${id}`);
     if (!data || Object.keys(data).length === 0) {
@@ -2601,8 +3716,14 @@ var RedisBackend = class {
       if (filters.runAt) {
         jobs = this.filterByRunAt(jobs, filters.runAt);
       }
+      if (filters.cursor !== void 0) {
+        jobs = jobs.filter((j) => j.id < filters.cursor);
+      }
+    }
+    jobs.sort((a, b) => b.id - a.id);
+    if (filters?.cursor !== void 0) {
+      return jobs.slice(0, limit);
     }
-    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) {
@@ -2811,58 +3932,346 @@ var RedisBackend = class {
       }
       metadata.tags = updates.tags;
     }
+    if (updates.retryDelay !== void 0) {
+      fields.push(
+        "retryDelay",
+        updates.retryDelay !== null ? updates.retryDelay.toString() : "null"
+      );
+      metadata.retryDelay = updates.retryDelay;
+    }
+    if (updates.retryBackoff !== void 0) {
+      fields.push(
+        "retryBackoff",
+        updates.retryBackoff !== null ? updates.retryBackoff.toString() : "null"
+      );
+      metadata.retryBackoff = updates.retryBackoff;
+    }
+    if (updates.retryDelayMax !== void 0) {
+      fields.push(
+        "retryDelayMax",
+        updates.retryDelayMax !== null ? updates.retryDelayMax.toString() : "null"
+      );
+      metadata.retryDelayMax = updates.retryDelayMax;
+    }
     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)}`);
+    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;
+  }
+  /**
+   * Delete completed jobs older than the given number of days.
+   * Uses SSCAN to iterate the completed set in batches, avoiding
+   * loading all IDs into memory and preventing long Redis blocks.
+   *
+   * @param daysToKeep - Number of days to retain completed jobs (default 30).
+   * @param batchSize - Number of IDs to scan per SSCAN iteration (default 200).
+   * @returns Total number of deleted jobs.
+   */
+  async cleanupOldJobs(daysToKeep = 30, batchSize = 200) {
+    const cutoffMs = this.nowMs() - daysToKeep * 24 * 60 * 60 * 1e3;
+    const setKey = `${this.prefix}status:completed`;
+    let totalDeleted = 0;
+    let cursor = "0";
+    do {
+      const [nextCursor, ids] = await this.client.sscan(
+        setKey,
+        cursor,
+        "COUNT",
+        batchSize
+      );
+      cursor = nextCursor;
+      if (ids.length > 0) {
+        const result = await this.client.eval(
+          CLEANUP_OLD_JOBS_BATCH_SCRIPT,
+          1,
+          this.prefix,
+          cutoffMs,
+          ...ids
+        );
+        totalDeleted += Number(result);
+      }
+    } while (cursor !== "0");
+    log(`Deleted ${totalDeleted} old jobs`);
+    return totalDeleted;
+  }
+  /**
+   * Delete job events older than the given number of days.
+   * Iterates all event lists and removes events whose createdAt is before the cutoff.
+   * Also removes orphaned event lists (where the job no longer exists).
+   *
+   * @param daysToKeep - Number of days to retain events (default 30).
+   * @param batchSize - Number of event keys to scan per SCAN iteration (default 200).
+   * @returns Total number of deleted events.
+   */
+  async cleanupOldJobEvents(daysToKeep = 30, batchSize = 200) {
+    const cutoffMs = this.nowMs() - daysToKeep * 24 * 60 * 60 * 1e3;
+    const pattern = `${this.prefix}events:*`;
+    let totalDeleted = 0;
+    let cursor = "0";
+    do {
+      const [nextCursor, keys] = await this.client.scan(
+        cursor,
+        "MATCH",
+        pattern,
+        "COUNT",
+        batchSize
+      );
+      cursor = nextCursor;
+      for (const key of keys) {
+        const jobIdStr = key.slice(`${this.prefix}events:`.length);
+        const jobExists = await this.client.exists(
+          `${this.prefix}job:${jobIdStr}`
+        );
+        if (!jobExists) {
+          const len = await this.client.llen(key);
+          await this.client.del(key);
+          totalDeleted += len;
+          continue;
+        }
+        const events = await this.client.lrange(key, 0, -1);
+        const kept = [];
+        for (const raw of events) {
+          try {
+            const e = JSON.parse(raw);
+            if (e.createdAt >= cutoffMs) {
+              kept.push(raw);
+            } else {
+              totalDeleted++;
+            }
+          } catch {
+            totalDeleted++;
+          }
+        }
+        if (kept.length === 0) {
+          await this.client.del(key);
+        } else if (kept.length < events.length) {
+          const pipeline = this.client.pipeline();
+          pipeline.del(key);
+          for (const raw of kept) {
+            pipeline.rpush(key, raw);
+          }
+          await pipeline.exec();
+        }
+      }
+    } while (cursor !== "0");
+    log(`Deleted ${totalDeleted} old job events`);
+    return totalDeleted;
+  }
+  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);
+  }
+  // ── Wait / step-data support ────────────────────────────────────────
+  /**
+   * Transition a job from 'processing' to 'waiting' status.
+   * Persists step data so the handler can resume from where it left off.
+   *
+   * @param jobId - The job to pause.
+   * @param options - Wait configuration including optional waitUntil date, token ID, and step data.
+   */
+  async waitJob(jobId, options) {
+    const now = this.nowMs();
+    const waitUntilMs = options.waitUntil ? options.waitUntil.getTime().toString() : "null";
+    const waitTokenId = options.waitTokenId ?? "null";
+    const stepDataJson = JSON.stringify(options.stepData);
+    const result = await this.client.eval(
+      WAIT_JOB_SCRIPT,
+      1,
+      this.prefix,
+      jobId,
+      waitUntilMs,
+      waitTokenId,
+      stepDataJson,
+      now
+    );
+    if (Number(result) === 0) {
+      log(
+        `Job ${jobId} could not be set to waiting (may have been reclaimed or is no longer processing)`
+      );
+      return;
+    }
+    await this.recordJobEvent(jobId, "waiting" /* Waiting */, {
+      waitUntil: options.waitUntil?.toISOString() ?? null,
+      waitTokenId: options.waitTokenId ?? null
+    });
+    log(`Job ${jobId} set to waiting`);
   }
-  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);
+  /**
+   * Persist step data for a job. Called after each ctx.run() step completes.
+   * Best-effort: does not throw to avoid killing the running handler.
+   *
+   * @param jobId - The job to update.
+   * @param stepData - The step data to persist.
+   */
+  async updateStepData(jobId, stepData) {
+    try {
+      const now = this.nowMs();
+      await this.client.hset(
+        `${this.prefix}job:${jobId}`,
+        "stepData",
+        JSON.stringify(stepData),
+        "updatedAt",
+        now.toString()
+      );
+    } catch (error) {
+      log(`Error updating stepData for job ${jobId}: ${error}`);
     }
-    let count = 0;
-    for (const id of ids) {
-      await this.editJob(Number(id), updates);
-      count++;
+  }
+  /**
+   * Create a waitpoint token.
+   *
+   * @param jobId - The job ID to associate with the token (null if created outside a handler).
+   * @param options - Optional timeout string (e.g. '10m', '1h') and tags.
+   * @returns The created waitpoint with its unique ID.
+   */
+  async createWaitpoint(jobId, options) {
+    const id = `wp_${crypto.randomUUID()}`;
+    const now = this.nowMs();
+    let timeoutAt = null;
+    if (options?.timeout) {
+      const ms = parseTimeoutString2(options.timeout);
+      timeoutAt = now + ms;
     }
-    log(`Edited ${count} pending jobs`);
-    return count;
+    const key = `${this.prefix}waitpoint:${id}`;
+    const fields = [
+      "id",
+      id,
+      "jobId",
+      jobId !== null ? jobId.toString() : "null",
+      "status",
+      "waiting",
+      "output",
+      "null",
+      "timeoutAt",
+      timeoutAt !== null ? timeoutAt.toString() : "null",
+      "createdAt",
+      now.toString(),
+      "completedAt",
+      "null",
+      "tags",
+      options?.tags ? JSON.stringify(options.tags) : "null"
+    ];
+    await this.client.hmset(key, ...fields);
+    if (timeoutAt !== null) {
+      await this.client.zadd(`${this.prefix}waitpoint_timeout`, timeoutAt, id);
+    }
+    log(`Created waitpoint ${id} for job ${jobId}`);
+    return { id };
   }
-  async cleanupOldJobs(daysToKeep = 30) {
-    const cutoffMs = this.nowMs() - daysToKeep * 24 * 60 * 60 * 1e3;
+  /**
+   * Complete a waitpoint token and move the associated job back to 'pending'.
+   *
+   * @param tokenId - The waitpoint token ID to complete.
+   * @param data - Optional data to pass to the waiting handler.
+   */
+  async completeWaitpoint(tokenId, data) {
+    const now = this.nowMs();
+    const outputJson = data != null ? JSON.stringify(data) : "null";
     const result = await this.client.eval(
-      CLEANUP_OLD_JOBS_SCRIPT,
+      COMPLETE_WAITPOINT_SCRIPT,
       1,
       this.prefix,
-      cutoffMs
+      tokenId,
+      outputJson,
+      now
     );
-    log(`Deleted ${result} old jobs`);
-    return Number(result);
+    if (Number(result) === 0) {
+      log(`Waitpoint ${tokenId} not found or already completed`);
+      return;
+    }
+    log(`Completed waitpoint ${tokenId}`);
   }
-  async cleanupOldJobEvents(daysToKeep = 30) {
-    log(
-      `cleanupOldJobEvents is a no-op for Redis backend (events are cleaned up with their jobs)`
+  /**
+   * Retrieve a waitpoint token by its ID.
+   *
+   * @param tokenId - The waitpoint token ID to look up.
+   * @returns The waitpoint record, or null if not found.
+   */
+  async getWaitpoint(tokenId) {
+    const data = await this.client.hgetall(
+      `${this.prefix}waitpoint:${tokenId}`
     );
-    return 0;
+    if (!data || Object.keys(data).length === 0) return null;
+    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 output = null;
+    if (data.output && data.output !== "null") {
+      try {
+        output = JSON.parse(data.output);
+      } catch {
+        output = data.output;
+      }
+    }
+    let tags = null;
+    if (data.tags && data.tags !== "null") {
+      try {
+        tags = JSON.parse(data.tags);
+      } catch {
+      }
+    }
+    return {
+      id: data.id,
+      jobId: numOrNull(data.jobId),
+      status: data.status,
+      output,
+      timeoutAt: dateOrNull(data.timeoutAt),
+      createdAt: new Date(Number(data.createdAt)),
+      completedAt: dateOrNull(data.completedAt),
+      tags
+    };
   }
-  async reclaimStuckJobs(maxProcessingTimeMinutes = 10) {
-    const maxAgeMs = maxProcessingTimeMinutes * 60 * 1e3;
+  /**
+   * Expire timed-out waitpoint tokens and move their associated jobs back to 'pending'.
+   *
+   * @returns The number of tokens that were expired.
+   */
+  async expireTimedOutWaitpoints() {
     const now = this.nowMs();
     const result = await this.client.eval(
-      RECLAIM_STUCK_JOBS_SCRIPT,
+      EXPIRE_TIMED_OUT_WAITPOINTS_SCRIPT,
       1,
       this.prefix,
-      maxAgeMs,
       now
     );
-    log(`Reclaimed ${result} stuck jobs`);
-    return Number(result);
+    const count = Number(result);
+    if (count > 0) {
+      log(`Expired ${count} timed-out waitpoints`);
+    }
+    return count;
   }
   // ── Internal helpers ──────────────────────────────────────────────────
   async setPendingReasonForUnpickedJobs(reason, jobType) {
@@ -2968,6 +4377,359 @@ var RedisBackend = class {
       return true;
     });
   }
+  // ── Cron schedules ──────────────────────────────────────────────────
+  /** Create a cron schedule and return its ID. */
+  async addCronSchedule(input) {
+    const existingId = await this.client.get(
+      `${this.prefix}cron_name:${input.scheduleName}`
+    );
+    if (existingId !== null) {
+      throw new Error(
+        `Cron schedule with name "${input.scheduleName}" already exists`
+      );
+    }
+    const id = await this.client.incr(`${this.prefix}cron_id_seq`);
+    const now = this.nowMs();
+    const key = `${this.prefix}cron:${id}`;
+    const fields = [
+      "id",
+      id.toString(),
+      "scheduleName",
+      input.scheduleName,
+      "cronExpression",
+      input.cronExpression,
+      "jobType",
+      input.jobType,
+      "payload",
+      JSON.stringify(input.payload),
+      "maxAttempts",
+      input.maxAttempts.toString(),
+      "priority",
+      input.priority.toString(),
+      "timeoutMs",
+      input.timeoutMs !== null ? input.timeoutMs.toString() : "null",
+      "forceKillOnTimeout",
+      input.forceKillOnTimeout ? "true" : "false",
+      "tags",
+      input.tags ? JSON.stringify(input.tags) : "null",
+      "timezone",
+      input.timezone,
+      "allowOverlap",
+      input.allowOverlap ? "true" : "false",
+      "status",
+      "active",
+      "lastEnqueuedAt",
+      "null",
+      "lastJobId",
+      "null",
+      "nextRunAt",
+      input.nextRunAt ? input.nextRunAt.getTime().toString() : "null",
+      "createdAt",
+      now.toString(),
+      "updatedAt",
+      now.toString(),
+      "retryDelay",
+      input.retryDelay !== null && input.retryDelay !== void 0 ? input.retryDelay.toString() : "null",
+      "retryBackoff",
+      input.retryBackoff !== null && input.retryBackoff !== void 0 ? input.retryBackoff.toString() : "null",
+      "retryDelayMax",
+      input.retryDelayMax !== null && input.retryDelayMax !== void 0 ? input.retryDelayMax.toString() : "null"
+    ];
+    await this.client.hmset(key, ...fields);
+    await this.client.set(
+      `${this.prefix}cron_name:${input.scheduleName}`,
+      id.toString()
+    );
+    await this.client.sadd(`${this.prefix}crons`, id.toString());
+    await this.client.sadd(`${this.prefix}cron_status:active`, id.toString());
+    if (input.nextRunAt) {
+      await this.client.zadd(
+        `${this.prefix}cron_due`,
+        input.nextRunAt.getTime(),
+        id.toString()
+      );
+    }
+    log(`Added cron schedule ${id}: "${input.scheduleName}"`);
+    return id;
+  }
+  /** Get a cron schedule by ID. */
+  async getCronSchedule(id) {
+    const data = await this.client.hgetall(`${this.prefix}cron:${id}`);
+    if (!data || Object.keys(data).length === 0) return null;
+    return this.deserializeCronSchedule(data);
+  }
+  /** Get a cron schedule by its unique name. */
+  async getCronScheduleByName(name) {
+    const id = await this.client.get(`${this.prefix}cron_name:${name}`);
+    if (id === null) return null;
+    return this.getCronSchedule(Number(id));
+  }
+  /** List cron schedules, optionally filtered by status. */
+  async listCronSchedules(status) {
+    let ids;
+    if (status) {
+      ids = await this.client.smembers(`${this.prefix}cron_status:${status}`);
+    } else {
+      ids = await this.client.smembers(`${this.prefix}crons`);
+    }
+    if (ids.length === 0) return [];
+    const pipeline = this.client.pipeline();
+    for (const id of ids) {
+      pipeline.hgetall(`${this.prefix}cron:${id}`);
+    }
+    const results = await pipeline.exec();
+    const schedules = [];
+    if (results) {
+      for (const [err, data] of results) {
+        if (!err && data && typeof data === "object" && Object.keys(data).length > 0) {
+          schedules.push(
+            this.deserializeCronSchedule(data)
+          );
+        }
+      }
+    }
+    schedules.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+    return schedules;
+  }
+  /** Delete a cron schedule by ID. */
+  async removeCronSchedule(id) {
+    const data = await this.client.hgetall(`${this.prefix}cron:${id}`);
+    if (!data || Object.keys(data).length === 0) return;
+    const name = data.scheduleName;
+    const status = data.status;
+    await this.client.del(`${this.prefix}cron:${id}`);
+    await this.client.del(`${this.prefix}cron_name:${name}`);
+    await this.client.srem(`${this.prefix}crons`, id.toString());
+    await this.client.srem(
+      `${this.prefix}cron_status:${status}`,
+      id.toString()
+    );
+    await this.client.zrem(`${this.prefix}cron_due`, id.toString());
+    log(`Removed cron schedule ${id}`);
+  }
+  /** Pause a cron schedule. */
+  async pauseCronSchedule(id) {
+    const now = this.nowMs();
+    await this.client.hset(
+      `${this.prefix}cron:${id}`,
+      "status",
+      "paused",
+      "updatedAt",
+      now.toString()
+    );
+    await this.client.srem(`${this.prefix}cron_status:active`, id.toString());
+    await this.client.sadd(`${this.prefix}cron_status:paused`, id.toString());
+    await this.client.zrem(`${this.prefix}cron_due`, id.toString());
+    log(`Paused cron schedule ${id}`);
+  }
+  /** Resume a paused cron schedule. */
+  async resumeCronSchedule(id) {
+    const now = this.nowMs();
+    await this.client.hset(
+      `${this.prefix}cron:${id}`,
+      "status",
+      "active",
+      "updatedAt",
+      now.toString()
+    );
+    await this.client.srem(`${this.prefix}cron_status:paused`, id.toString());
+    await this.client.sadd(`${this.prefix}cron_status:active`, id.toString());
+    const nextRunAt = await this.client.hget(
+      `${this.prefix}cron:${id}`,
+      "nextRunAt"
+    );
+    if (nextRunAt && nextRunAt !== "null") {
+      await this.client.zadd(
+        `${this.prefix}cron_due`,
+        Number(nextRunAt),
+        id.toString()
+      );
+    }
+    log(`Resumed cron schedule ${id}`);
+  }
+  /** Edit a cron schedule. */
+  async editCronSchedule(id, updates, nextRunAt) {
+    const now = this.nowMs();
+    const fields = [];
+    if (updates.cronExpression !== void 0) {
+      fields.push("cronExpression", updates.cronExpression);
+    }
+    if (updates.payload !== void 0) {
+      fields.push("payload", JSON.stringify(updates.payload));
+    }
+    if (updates.maxAttempts !== void 0) {
+      fields.push("maxAttempts", updates.maxAttempts.toString());
+    }
+    if (updates.priority !== void 0) {
+      fields.push("priority", updates.priority.toString());
+    }
+    if (updates.timeoutMs !== void 0) {
+      fields.push(
+        "timeoutMs",
+        updates.timeoutMs !== null ? updates.timeoutMs.toString() : "null"
+      );
+    }
+    if (updates.forceKillOnTimeout !== void 0) {
+      fields.push(
+        "forceKillOnTimeout",
+        updates.forceKillOnTimeout ? "true" : "false"
+      );
+    }
+    if (updates.tags !== void 0) {
+      fields.push(
+        "tags",
+        updates.tags !== null ? JSON.stringify(updates.tags) : "null"
+      );
+    }
+    if (updates.timezone !== void 0) {
+      fields.push("timezone", updates.timezone);
+    }
+    if (updates.allowOverlap !== void 0) {
+      fields.push("allowOverlap", updates.allowOverlap ? "true" : "false");
+    }
+    if (updates.retryDelay !== void 0) {
+      fields.push(
+        "retryDelay",
+        updates.retryDelay !== null ? updates.retryDelay.toString() : "null"
+      );
+    }
+    if (updates.retryBackoff !== void 0) {
+      fields.push(
+        "retryBackoff",
+        updates.retryBackoff !== null ? updates.retryBackoff.toString() : "null"
+      );
+    }
+    if (updates.retryDelayMax !== void 0) {
+      fields.push(
+        "retryDelayMax",
+        updates.retryDelayMax !== null ? updates.retryDelayMax.toString() : "null"
+      );
+    }
+    if (nextRunAt !== void 0) {
+      const val = nextRunAt !== null ? nextRunAt.getTime().toString() : "null";
+      fields.push("nextRunAt", val);
+      if (nextRunAt !== null) {
+        await this.client.zadd(
+          `${this.prefix}cron_due`,
+          nextRunAt.getTime(),
+          id.toString()
+        );
+      } else {
+        await this.client.zrem(`${this.prefix}cron_due`, id.toString());
+      }
+    }
+    if (fields.length === 0) {
+      log(`No fields to update for cron schedule ${id}`);
+      return;
+    }
+    fields.push("updatedAt", now.toString());
+    await this.client.hmset(`${this.prefix}cron:${id}`, ...fields);
+    log(`Edited cron schedule ${id}`);
+  }
+  /**
+   * Fetch all active cron schedules whose nextRunAt <= now.
+   * Uses a sorted set (cron_due) for efficient range query.
+   */
+  async getDueCronSchedules() {
+    const now = this.nowMs();
+    const ids = await this.client.zrangebyscore(
+      `${this.prefix}cron_due`,
+      0,
+      now
+    );
+    if (ids.length === 0) {
+      log("Found 0 due cron schedules");
+      return [];
+    }
+    const schedules = [];
+    for (const id of ids) {
+      const data = await this.client.hgetall(`${this.prefix}cron:${id}`);
+      if (data && Object.keys(data).length > 0 && data.status === "active") {
+        schedules.push(this.deserializeCronSchedule(data));
+      }
+    }
+    log(`Found ${schedules.length} due cron schedules`);
+    return schedules;
+  }
+  /**
+   * Update a cron schedule after a job has been enqueued.
+   * Sets lastEnqueuedAt, lastJobId, and advances nextRunAt.
+   */
+  async updateCronScheduleAfterEnqueue(id, lastEnqueuedAt, lastJobId, nextRunAt) {
+    const fields = [
+      "lastEnqueuedAt",
+      lastEnqueuedAt.getTime().toString(),
+      "lastJobId",
+      lastJobId.toString(),
+      "nextRunAt",
+      nextRunAt ? nextRunAt.getTime().toString() : "null",
+      "updatedAt",
+      this.nowMs().toString()
+    ];
+    await this.client.hmset(`${this.prefix}cron:${id}`, ...fields);
+    if (nextRunAt) {
+      await this.client.zadd(
+        `${this.prefix}cron_due`,
+        nextRunAt.getTime(),
+        id.toString()
+      );
+    } else {
+      await this.client.zrem(`${this.prefix}cron_due`, id.toString());
+    }
+    log(
+      `Updated cron schedule ${id}: lastJobId=${lastJobId}, nextRunAt=${nextRunAt?.toISOString() ?? "null"}`
+    );
+  }
+  /** Deserialize a Redis hash into a CronScheduleRecord. */
+  deserializeCronSchedule(h) {
+    const nullish = (v) => v === void 0 || v === "null" || v === "" ? null : v;
+    const numOrNull = (v) => {
+      const n = nullish(v);
+      return n === null ? null : Number(n);
+    };
+    const dateOrNull = (v) => {
+      const n = numOrNull(v);
+      return n === null ? null : new Date(n);
+    };
+    let payload;
+    try {
+      payload = JSON.parse(h.payload);
+    } catch {
+      payload = h.payload;
+    }
+    let tags;
+    try {
+      const raw = h.tags;
+      if (raw && raw !== "null") {
+        tags = JSON.parse(raw);
+      }
+    } catch {
+    }
+    return {
+      id: Number(h.id),
+      scheduleName: h.scheduleName,
+      cronExpression: h.cronExpression,
+      jobType: h.jobType,
+      payload,
+      maxAttempts: Number(h.maxAttempts),
+      priority: Number(h.priority),
+      timeoutMs: numOrNull(h.timeoutMs),
+      forceKillOnTimeout: h.forceKillOnTimeout === "true",
+      tags,
+      timezone: h.timezone,
+      allowOverlap: h.allowOverlap === "true",
+      status: h.status,
+      lastEnqueuedAt: dateOrNull(h.lastEnqueuedAt),
+      lastJobId: numOrNull(h.lastJobId),
+      nextRunAt: dateOrNull(h.nextRunAt),
+      createdAt: new Date(Number(h.createdAt)),
+      updatedAt: new Date(Number(h.updatedAt)),
+      retryDelay: numOrNull(h.retryDelay),
+      retryBackoff: h.retryBackoff === "true" ? true : h.retryBackoff === "false" ? false : null,
+      retryDelayMax: numOrNull(h.retryDelayMax)
+    };
+  }
+  // ── Private helpers (filters) ─────────────────────────────────────────
   async applyFilters(ids, filters) {
     let result = ids;
     if (filters.jobType) {
@@ -2997,6 +4759,19 @@ var RedisBackend = class {
     return result;
   }
 };
+function getNextCronOccurrence(cronExpression, timezone = "UTC", after, CronImpl = croner.Cron) {
+  const cron = new CronImpl(cronExpression, { timezone });
+  const next = cron.nextRun(after ?? /* @__PURE__ */ new Date());
+  return next ?? null;
+}
+function validateCronExpression(cronExpression, CronImpl = croner.Cron) {
+  try {
+    new CronImpl(cronExpression);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/handler-validation.ts
 function validateHandlerSerializable2(handler, jobType) {
@@ -3072,29 +4847,89 @@ 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);
+    if (pgConfig.pool) {
+      backend = new PostgresBackend(pgConfig.pool);
+    } else if (pgConfig.databaseConfig) {
+      const pool = createPool(pgConfig.databaseConfig);
+      backend = new PostgresBackend(pool);
+    } else {
+      throw new Error(
+        'PostgreSQL backend requires either "databaseConfig" or "pool" to be provided.'
+      );
+    }
   } else if (backendType === "redis") {
-    const redisConfig = config.redisConfig;
-    backend = new RedisBackend(redisConfig);
+    const redisConfig = config;
+    if (redisConfig.client) {
+      backend = new RedisBackend(
+        redisConfig.client,
+        redisConfig.keyPrefix
+      );
+    } else if (redisConfig.redisConfig) {
+      backend = new RedisBackend(redisConfig.redisConfig);
+    } else {
+      throw new Error(
+        'Redis backend requires either "redisConfig" or "client" to be provided.'
+      );
+    }
   } 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.'
+  const enqueueDueCronJobsImpl = async () => {
+    const dueSchedules = await backend.getDueCronSchedules();
+    let count = 0;
+    for (const schedule of dueSchedules) {
+      if (!schedule.allowOverlap && schedule.lastJobId !== null) {
+        const lastJob = await backend.getJob(schedule.lastJobId);
+        if (lastJob && (lastJob.status === "pending" || lastJob.status === "processing" || lastJob.status === "waiting")) {
+          const nextRunAt2 = getNextCronOccurrence(
+            schedule.cronExpression,
+            schedule.timezone
+          );
+          await backend.updateCronScheduleAfterEnqueue(
+            schedule.id,
+            /* @__PURE__ */ new Date(),
+            schedule.lastJobId,
+            nextRunAt2
+          );
+          continue;
+        }
+      }
+      const jobId = await backend.addJob({
+        jobType: schedule.jobType,
+        payload: schedule.payload,
+        maxAttempts: schedule.maxAttempts,
+        priority: schedule.priority,
+        timeoutMs: schedule.timeoutMs ?? void 0,
+        forceKillOnTimeout: schedule.forceKillOnTimeout,
+        tags: schedule.tags,
+        retryDelay: schedule.retryDelay ?? void 0,
+        retryBackoff: schedule.retryBackoff ?? void 0,
+        retryDelayMax: schedule.retryDelayMax ?? void 0
+      });
+      const nextRunAt = getNextCronOccurrence(
+        schedule.cronExpression,
+        schedule.timezone
+      );
+      await backend.updateCronScheduleAfterEnqueue(
+        schedule.id,
+        /* @__PURE__ */ new Date(),
+        jobId,
+        nextRunAt
       );
+      count++;
     }
-    return pool;
+    return count;
   };
   return {
     // Job queue operations
     addJob: withLogContext(
-      (job) => backend.addJob(job),
+      (job, options) => backend.addJob(job, options),
+      config.verbose ?? false
+    ),
+    addJobs: withLogContext(
+      (jobs, options) => backend.addJobs(jobs, options),
       config.verbose ?? false
     ),
     getJob: withLogContext(
@@ -3114,8 +4949,8 @@ var initJobQueue = (config) => {
       config.verbose ?? false
     ),
     retryJob: (jobId) => backend.retryJob(jobId),
-    cleanupOldJobs: (daysToKeep) => backend.cleanupOldJobs(daysToKeep),
-    cleanupOldJobEvents: (daysToKeep) => backend.cleanupOldJobEvents(daysToKeep),
+    cleanupOldJobs: (daysToKeep, batchSize) => backend.cleanupOldJobs(daysToKeep, batchSize),
+    cleanupOldJobEvents: (daysToKeep, batchSize) => backend.cleanupOldJobEvents(daysToKeep, batchSize),
     cancelJob: withLogContext(
       (jobId) => backend.cancelJob(jobId),
       config.verbose ?? false
@@ -3143,33 +4978,116 @@ var initJobQueue = (config) => {
       (tags, mode = "all", limit, offset) => backend.getJobsByTags(tags, mode, limit, offset),
       config.verbose ?? false
     ),
-    // Job processing
-    createProcessor: (handlers, options) => createProcessor(backend, handlers, options),
+    // Job processing — automatically enqueues due cron jobs before each batch
+    createProcessor: (handlers, options) => createProcessor(backend, handlers, options, async () => {
+      await enqueueDueCronJobsImpl();
+    }),
+    // Background supervisor — automated maintenance
+    createSupervisor: (options) => createSupervisor(backend, options),
     // Job events
     getJobEvents: withLogContext(
       (jobId) => backend.getJobEvents(jobId),
       config.verbose ?? false
     ),
-    // Wait / Token support (PostgreSQL-only for now)
+    // Wait / Token support (works with all backends)
     createToken: withLogContext(
-      (options) => createWaitpoint(requirePool(), null, options),
+      (options) => backend.createWaitpoint(null, options),
       config.verbose ?? false
     ),
     completeToken: withLogContext(
-      (tokenId, data) => completeWaitpoint(requirePool(), tokenId, data),
+      (tokenId, data) => backend.completeWaitpoint(tokenId, data),
       config.verbose ?? false
     ),
     getToken: withLogContext(
-      (tokenId) => getWaitpoint(requirePool(), tokenId),
+      (tokenId) => backend.getWaitpoint(tokenId),
       config.verbose ?? false
     ),
     expireTimedOutTokens: withLogContext(
-      () => expireTimedOutWaitpoints(requirePool()),
+      () => backend.expireTimedOutWaitpoints(),
+      config.verbose ?? false
+    ),
+    // Cron schedule operations
+    addCronJob: withLogContext(
+      (options) => {
+        if (!validateCronExpression(options.cronExpression)) {
+          return Promise.reject(
+            new Error(`Invalid cron expression: "${options.cronExpression}"`)
+          );
+        }
+        const nextRunAt = getNextCronOccurrence(
+          options.cronExpression,
+          options.timezone ?? "UTC"
+        );
+        const input = {
+          scheduleName: options.scheduleName,
+          cronExpression: options.cronExpression,
+          jobType: options.jobType,
+          payload: options.payload,
+          maxAttempts: options.maxAttempts ?? 3,
+          priority: options.priority ?? 0,
+          timeoutMs: options.timeoutMs ?? null,
+          forceKillOnTimeout: options.forceKillOnTimeout ?? false,
+          tags: options.tags,
+          timezone: options.timezone ?? "UTC",
+          allowOverlap: options.allowOverlap ?? false,
+          nextRunAt,
+          retryDelay: options.retryDelay ?? null,
+          retryBackoff: options.retryBackoff ?? null,
+          retryDelayMax: options.retryDelayMax ?? null
+        };
+        return backend.addCronSchedule(input);
+      },
+      config.verbose ?? false
+    ),
+    getCronJob: withLogContext(
+      (id) => backend.getCronSchedule(id),
+      config.verbose ?? false
+    ),
+    getCronJobByName: withLogContext(
+      (name) => backend.getCronScheduleByName(name),
+      config.verbose ?? false
+    ),
+    listCronJobs: withLogContext(
+      (status) => backend.listCronSchedules(status),
+      config.verbose ?? false
+    ),
+    removeCronJob: withLogContext(
+      (id) => backend.removeCronSchedule(id),
+      config.verbose ?? false
+    ),
+    pauseCronJob: withLogContext(
+      (id) => backend.pauseCronSchedule(id),
+      config.verbose ?? false
+    ),
+    resumeCronJob: withLogContext(
+      (id) => backend.resumeCronSchedule(id),
+      config.verbose ?? false
+    ),
+    editCronJob: withLogContext(
+      async (id, updates) => {
+        if (updates.cronExpression !== void 0 && !validateCronExpression(updates.cronExpression)) {
+          throw new Error(
+            `Invalid cron expression: "${updates.cronExpression}"`
+          );
+        }
+        let nextRunAt;
+        if (updates.cronExpression !== void 0 || updates.timezone !== void 0) {
+          const existing = await backend.getCronSchedule(id);
+          const expr = updates.cronExpression ?? existing?.cronExpression ?? "";
+          const tz = updates.timezone ?? existing?.timezone ?? "UTC";
+          nextRunAt = getNextCronOccurrence(expr, tz);
+        }
+        await backend.editCronSchedule(id, updates, nextRunAt);
+      },
+      config.verbose ?? false
+    ),
+    enqueueDueCronJobs: withLogContext(
+      () => enqueueDueCronJobsImpl(),
       config.verbose ?? false
     ),
     // Advanced access
     getPool: () => {
-      if (backendType !== "postgres") {
+      if (!(backend instanceof PostgresBackend)) {
         throw new Error(
           "getPool() is only available with the PostgreSQL backend."
         );
@@ -3195,8 +5113,10 @@ exports.FailureReason = FailureReason;
 exports.JobEventType = JobEventType;
 exports.PostgresBackend = PostgresBackend;
 exports.WaitSignal = WaitSignal;
+exports.getNextCronOccurrence = getNextCronOccurrence;
 exports.initJobQueue = initJobQueue;
 exports.testHandlerSerialization = testHandlerSerialization;
+exports.validateCronExpression = validateCronExpression;
 exports.validateHandlerSerializable = validateHandlerSerializable2;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map