@nicnocquee/dataqueue 1.34.0 → 1.35.0-beta.20260224110011

package/dist/index.js

@@ -1,3 +1,4 @@
+import { EventEmitter } from 'events';
 import { Worker } from 'worker_threads';
 import { AsyncLocalStorage } from 'async_hooks';
 import { Pool } from 'pg';
@@ -7,7 +8,7 @@ import { randomUUID } from 'crypto';
 import { createRequire } from 'module';
 import { Cron } from 'croner';
 
-// src/processor.ts
+// src/index.ts
 
 // src/types.ts
 var JobEventType = /* @__PURE__ */ ((JobEventType2) => {
@@ -143,9 +144,9 @@ async function runHandlerInWorker(handler, payload, timeoutMs, jobType) {
           }
           
           handlerFn(payload, signal)
-            .then(() => {
+            .then((result) => {
               clearTimeout(timeoutId);
-              parentPort.postMessage({ type: 'success' });
+              parentPort.postMessage({ type: 'success', output: result });
             })
             .catch((error) => {
               clearTimeout(timeoutId);
@@ -180,24 +181,27 @@ async function runHandlerInWorker(handler, payload, timeoutMs, jobType) {
       }
     });
     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(
+      "message",
+      (message) => {
+        if (resolved) return;
+        resolved = true;
+        if (message.type === "success") {
+          resolve(message.output);
+        } 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;
@@ -354,22 +358,30 @@ function buildWaitContext(backend, jobId, stepData, baseCtx) {
       if (percent < 0 || percent > 100)
         throw new Error("Progress must be between 0 and 100");
       await backend.updateProgress(jobId, Math.round(percent));
+    },
+    setOutput: async (data) => {
+      await backend.updateOutput(jobId, data);
     }
   };
   return ctx;
 }
-async function processJobWithHandlers(backend, job, jobHandlers) {
+async function processJobWithHandlers(backend, job, jobHandlers, emit) {
   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 */
+    const noHandlerError = new Error(
+      `No handler registered for job type: ${job.jobType}`
     );
+    await backend.failJob(job.id, noHandlerError, "no_handler" /* NoHandler */);
+    emit?.("job:failed", {
+      jobId: job.id,
+      jobType: job.jobType,
+      error: noHandlerError,
+      willRetry: false
+    });
     return;
   }
   const stepData = { ...job.stepData || {} };
@@ -384,9 +396,16 @@ async function processJobWithHandlers(backend, job, jobHandlers) {
   const forceKillOnTimeout = job.forceKillOnTimeout ?? false;
   let timeoutId;
   const controller = new AbortController();
+  let setOutputCalled = false;
+  let handlerReturnValue;
   try {
     if (forceKillOnTimeout && timeoutMs && timeoutMs > 0) {
-      await runHandlerInWorker(handler, job.payload, timeoutMs, job.jobType);
+      handlerReturnValue = await runHandlerInWorker(
+        handler,
+        job.payload,
+        timeoutMs,
+        job.jobType
+      );
     } else {
       let onTimeoutCallback;
       let timeoutReject;
@@ -438,6 +457,22 @@ async function processJobWithHandlers(backend, job, jobHandlers) {
         }
       };
       const ctx = buildWaitContext(backend, job.id, stepData, baseCtx);
+      if (emit) {
+        const originalSetProgress = ctx.setProgress;
+        ctx.setProgress = async (percent) => {
+          await originalSetProgress(percent);
+          emit("job:progress", {
+            jobId: job.id,
+            progress: Math.round(percent)
+          });
+        };
+      }
+      const originalSetOutput = ctx.setOutput;
+      ctx.setOutput = async (data) => {
+        setOutputCalled = true;
+        await originalSetOutput(data);
+        emit?.("job:output", { jobId: job.id, output: data });
+      };
       if (forceKillOnTimeout && !hasTimeout) {
         log(
           `forceKillOnTimeout is set but no timeoutMs for job ${job.id}, running without force kill`
@@ -445,7 +480,7 @@ async function processJobWithHandlers(backend, job, jobHandlers) {
       }
       const jobPromise = handler(job.payload, controller.signal, ctx);
       if (hasTimeout) {
-        await Promise.race([
+        handlerReturnValue = await Promise.race([
           jobPromise,
           new Promise((_, reject) => {
             timeoutReject = reject;
@@ -453,11 +488,13 @@ async function processJobWithHandlers(backend, job, jobHandlers) {
           })
         ]);
       } else {
-        await jobPromise;
+        handlerReturnValue = await jobPromise;
       }
     }
     if (timeoutId) clearTimeout(timeoutId);
-    await backend.completeJob(job.id);
+    const completionOutput = setOutputCalled || handlerReturnValue === void 0 ? void 0 : handlerReturnValue;
+    await backend.completeJob(job.id, completionOutput);
+    emit?.("job:completed", { jobId: job.id, jobType: job.jobType });
   } catch (error) {
     if (timeoutId) clearTimeout(timeoutId);
     if (error instanceof WaitSignal) {
@@ -469,6 +506,7 @@ async function processJobWithHandlers(backend, job, jobHandlers) {
         waitTokenId: error.tokenId,
         stepData: error.stepData
       });
+      emit?.("job:waiting", { jobId: job.id, jobType: job.jobType });
       return;
     }
     console.error(`Error processing job ${job.id}:`, error);
@@ -476,22 +514,33 @@ async function processJobWithHandlers(backend, job, jobHandlers) {
     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
-    );
+    const failError = error instanceof Error ? error : new Error(String(error));
+    await backend.failJob(job.id, failError, failureReason);
+    emit?.("job:failed", {
+      jobId: job.id,
+      jobType: job.jobType,
+      error: failError,
+      willRetry: job.attempts + 1 < job.maxAttempts
+    });
   }
 }
-async function processBatchWithHandlers(backend, workerId, batchSize, jobType, jobHandlers, concurrency, onError) {
+async function processBatchWithHandlers(backend, workerId, batchSize, jobType, jobHandlers, concurrency, groupConcurrency, onError, emit) {
   const jobs = await backend.getNextBatch(
     workerId,
     batchSize,
-    jobType
+    jobType,
+    groupConcurrency
   );
+  if (emit) {
+    for (const job of jobs) {
+      emit("job:processing", { jobId: job.id, jobType: job.jobType });
+    }
+  }
   if (!concurrency || concurrency >= jobs.length) {
     await Promise.all(
-      jobs.map((job) => processJobWithHandlers(backend, job, jobHandlers))
+      jobs.map(
+        (job) => processJobWithHandlers(backend, job, jobHandlers, emit)
+      )
     );
     return jobs.length;
   }
@@ -504,7 +553,7 @@ async function processBatchWithHandlers(backend, workerId, batchSize, jobType, j
       while (running < concurrency && idx < jobs.length) {
         const job = jobs[idx++];
         running++;
-        processJobWithHandlers(backend, job, jobHandlers).then(() => {
+        processJobWithHandlers(backend, job, jobHandlers, emit).then(() => {
           running--;
           finished++;
           next();
@@ -521,15 +570,21 @@ async function processBatchWithHandlers(backend, workerId, batchSize, jobType, j
     next();
   });
 }
-var createProcessor = (backend, handlers, options = {}, onBeforeBatch) => {
+var createProcessor = (backend, handlers, options = {}, onBeforeBatch, emit) => {
   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
+    concurrency = 3,
+    groupConcurrency
   } = options;
+  if (groupConcurrency !== void 0 && (!Number.isInteger(groupConcurrency) || groupConcurrency <= 0)) {
+    throw new Error(
+      'Processor option "groupConcurrency" must be a positive integer when provided.'
+    );
+  }
   let running = false;
   let intervalId = null;
   let currentBatchPromise = null;
@@ -541,11 +596,11 @@ var createProcessor = (backend, handlers, options = {}, onBeforeBatch) => {
         await onBeforeBatch();
       } catch (hookError) {
         log(`onBeforeBatch hook error: ${hookError}`);
+        const err = hookError instanceof Error ? hookError : new Error(String(hookError));
         if (onError) {
-          onError(
-            hookError instanceof Error ? hookError : new Error(String(hookError))
-          );
+          onError(err);
         }
+        emit?.("error", err);
       }
     }
     log(
@@ -559,11 +614,15 @@ var createProcessor = (backend, handlers, options = {}, onBeforeBatch) => {
         jobType,
         handlers,
         concurrency,
-        onError
+        groupConcurrency,
+        onError,
+        emit
       );
       return processed;
     } catch (error) {
-      onError(error instanceof Error ? error : new Error(String(error)));
+      const err = error instanceof Error ? error : new Error(String(error));
+      onError(err);
+      emit?.("error", err);
     }
     return 0;
   };
@@ -642,6 +701,138 @@ var createProcessor = (backend, handlers, options = {}, onBeforeBatch) => {
     isRunning: () => running
   };
 };
+
+// src/supervisor.ts
+var createSupervisor = (backend, options = {}, emit) => {
+  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) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        onError(err);
+        emit?.("error", err);
+      }
+    }
+    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) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        onError(err);
+        emit?.("error", err);
+      }
+    }
+    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) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        onError(err);
+        emit?.("error", err);
+      }
+    }
+    if (expireTimedOutTokens) {
+      try {
+        result.expiredTokens = await backend.expireTimedOutWaitpoints();
+        if (result.expiredTokens > 0) {
+          log(`Supervisor: expired ${result.expiredTokens} timed-out tokens`);
+        }
+      } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        onError(err);
+        emit?.("error", err);
+      }
+    }
+    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://")) {
@@ -793,6 +984,14 @@ var PostgresBackend = class {
     }
   }
   // ── 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,
@@ -802,17 +1001,22 @@ var PostgresBackend = class {
     timeoutMs = void 0,
     forceKillOnTimeout = false,
     tags = void 0,
-    idempotencyKey = void 0
-  }) {
-    const client = await this.pool.connect();
+    idempotencyKey = void 0,
+    retryDelay = void 0,
+    retryBackoff = void 0,
+    retryDelayMax = void 0,
+    group = 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) 
-           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) 
+            (job_type, payload, max_attempts, priority, run_at, timeout_ms, force_kill_on_timeout, tags, idempotency_key, retry_delay, retry_backoff, retry_delay_max, group_id, group_tier) 
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14) 
            ${onConflict}
            RETURNING id`,
           [
@@ -824,14 +1028,19 @@ var PostgresBackend = class {
             timeoutMs ?? null,
             forceKillOnTimeout ?? false,
             tags ?? null,
-            idempotencyKey ?? null
+            idempotencyKey ?? null,
+            retryDelay ?? null,
+            retryBackoff ?? null,
+            retryDelayMax ?? null,
+            group?.id ?? null,
+            group?.tier ?? 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) 
+            (job_type, payload, max_attempts, priority, timeout_ms, force_kill_on_timeout, tags, idempotency_key, retry_delay, retry_backoff, retry_delay_max, group_id, group_tier) 
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13) 
            ${onConflict}
            RETURNING id`,
           [
@@ -842,7 +1051,12 @@ var PostgresBackend = class {
             timeoutMs ?? null,
             forceKillOnTimeout ?? false,
             tags ?? null,
-            idempotencyKey ?? null
+            idempotencyKey ?? null,
+            retryDelay ?? null,
+            retryBackoff ?? null,
+            retryDelayMax ?? null,
+            group?.id ?? null,
+            group?.tier ?? null
           ]
         );
       }
@@ -865,25 +1079,191 @@ var PostgresBackend = class {
       log(
         `Added job ${jobId}: payload ${JSON.stringify(payload)}, ${runAt ? `runAt ${runAt.toISOString()}, ` : ""}priority ${priority}, maxAttempts ${maxAttempts}, jobType ${jobType}, tags ${JSON.stringify(tags)}${idempotencyKey ? `, idempotencyKey "${idempotencyKey}"` : ""}`
       );
-      await this.recordJobEvent(jobId, "added" /* Added */, {
-        jobType,
-        payload,
-        tags,
-        idempotencyKey
-      });
+      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 {
-      client.release();
+      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 = 14;
+      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,
+          group = 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}, $${base + 13}, $${base + 14})`
+        );
+        params.push(
+          jobType,
+          payload,
+          maxAttempts,
+          priority,
+          runAt,
+          timeoutMs ?? null,
+          forceKillOnTimeout ?? false,
+          tags ?? null,
+          idempotencyKey ?? null,
+          retryDelay ?? null,
+          retryBackoff ?? null,
+          retryDelayMax ?? null,
+          group?.id ?? null,
+          group?.tier ?? 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, group_id, group_tier)
+         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 FROM job_queue WHERE id = $1`,
+        `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", group_id AS "groupId", group_tier AS "groupTier", output FROM job_queue WHERE id = $1`,
         [id]
       );
       if (result.rows.length === 0) {
@@ -910,7 +1290,7 @@ var PostgresBackend = class {
     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`,
+        `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", group_id AS "groupId", group_tier AS "groupTier", output 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}`);
@@ -932,7 +1312,7 @@ var PostgresBackend = class {
     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`,
+        `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", group_id AS "groupId", group_tier AS "groupTier", output FROM job_queue ORDER BY created_at DESC LIMIT $1 OFFSET $2`,
         [limit, offset]
       );
       log(`Found ${result.rows.length} jobs (all)`);
@@ -952,7 +1332,7 @@ var PostgresBackend = class {
   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`;
+      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", group_id AS "groupId", group_tier AS "groupTier", output FROM job_queue`;
       const params = [];
       const where = [];
       let paramIdx = 1;
@@ -1053,7 +1433,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", group_id AS "groupId", group_tier AS "groupTier", output
          FROM job_queue`;
       let params = [];
       switch (mode) {
@@ -1100,7 +1480,7 @@ var PostgresBackend = class {
     }
   }
   // ── Processing lifecycle ──────────────────────────────────────────────
-  async getNextBatch(workerId, batchSize = 10, jobType) {
+  async getNextBatch(workerId, batchSize = 10, jobType, groupConcurrency) {
     const client = await this.pool.connect();
     try {
       await client.query("BEGIN");
@@ -1108,49 +1488,120 @@ var PostgresBackend = class {
       const params = [workerId, batchSize];
       if (jobType) {
         if (Array.isArray(jobType)) {
-          jobTypeFilter = ` AND job_type = ANY($3)`;
+          jobTypeFilter = ` AND candidate.job_type = ANY($3)`;
           params.push(jobType);
         } else {
-          jobTypeFilter = ` AND job_type = $3`;
+          jobTypeFilter = ` AND candidate.job_type = $3`;
           params.push(jobType);
         }
       }
-      const result = await client.query(
-        `
-        UPDATE job_queue
-        SET status = 'processing', 
-            locked_at = NOW(), 
-            locked_by = $1,
-            attempts = CASE WHEN status = 'waiting' THEN attempts ELSE attempts + 1 END,
-            updated_at = NOW(),
-            pending_reason = NULL,
-            started_at = COALESCE(started_at, NOW()),
-            last_retried_at = CASE WHEN status != 'waiting' AND attempts > 0 THEN NOW() ELSE last_retried_at END,
-            wait_until = NULL
-        WHERE id IN (
-          SELECT id FROM job_queue
-          WHERE (
-            (
-              (status = 'pending' OR (status = 'failed' AND next_attempt_at <= NOW()))
-              AND (attempts < max_attempts)
-              AND run_at <= NOW()
+      let result;
+      if (groupConcurrency === void 0) {
+        result = await client.query(
+          `
+          UPDATE job_queue
+          SET status = 'processing', 
+              locked_at = NOW(), 
+              locked_by = $1,
+              attempts = CASE WHEN status = 'waiting' THEN attempts ELSE attempts + 1 END,
+              updated_at = NOW(),
+              pending_reason = NULL,
+              started_at = COALESCE(started_at, NOW()),
+              last_retried_at = CASE WHEN status != 'waiting' AND attempts > 0 THEN NOW() ELSE last_retried_at END,
+              wait_until = NULL
+          WHERE id IN (
+            SELECT id FROM job_queue candidate
+            WHERE (
+              (
+                (candidate.status = 'pending' OR (candidate.status = 'failed' AND candidate.next_attempt_at <= NOW()))
+                AND (candidate.attempts < candidate.max_attempts)
+                AND candidate.run_at <= NOW()
+              )
+              OR (
+                candidate.status = 'waiting'
+                AND candidate.wait_until IS NOT NULL
+                AND candidate.wait_until <= NOW()
+                AND candidate.wait_token_id IS NULL
+              )
             )
-            OR (
-              status = 'waiting'
-              AND wait_until IS NOT NULL
-              AND wait_until <= NOW()
-              AND wait_token_id IS NULL
+            ${jobTypeFilter}
+            ORDER BY candidate.priority DESC, candidate.created_at ASC
+            LIMIT $2
+            FOR UPDATE SKIP LOCKED
+          )
+          RETURNING id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason", idempotency_key AS "idempotencyKey", wait_until AS "waitUntil", wait_token_id AS "waitTokenId", step_data AS "stepData", progress, retry_delay AS "retryDelay", retry_backoff AS "retryBackoff", retry_delay_max AS "retryDelayMax", group_id AS "groupId", group_tier AS "groupTier", output
+        `,
+          params
+        );
+      } else {
+        const constrainedParams = [...params, groupConcurrency];
+        const groupConcurrencyParamIndex = constrainedParams.length;
+        result = await client.query(
+          `
+          WITH eligible AS (
+            SELECT candidate.id, candidate.group_id, candidate.priority, candidate.created_at
+            FROM job_queue candidate
+            WHERE (
+              (
+                (candidate.status = 'pending' OR (candidate.status = 'failed' AND candidate.next_attempt_at <= NOW()))
+                AND (candidate.attempts < candidate.max_attempts)
+                AND candidate.run_at <= NOW()
+              )
+              OR (
+                candidate.status = 'waiting'
+                AND candidate.wait_until IS NOT NULL
+                AND candidate.wait_until <= NOW()
+                AND candidate.wait_token_id IS NULL
+              )
             )
+            ${jobTypeFilter}
+            FOR UPDATE SKIP LOCKED
+          ),
+          ranked AS (
+            SELECT
+              eligible.id,
+              eligible.group_id,
+              eligible.priority,
+              eligible.created_at,
+              ROW_NUMBER() OVER (
+                PARTITION BY eligible.group_id
+                ORDER BY eligible.priority DESC, eligible.created_at ASC
+              ) AS group_rank,
+              COALESCE((
+                SELECT COUNT(*)
+                FROM job_queue processing_jobs
+                WHERE processing_jobs.status = 'processing'
+                  AND processing_jobs.group_id = eligible.group_id
+              ), 0) AS active_group_count
+            FROM eligible
+          ),
+          selected AS (
+            SELECT ranked.id
+            FROM ranked
+            WHERE ranked.group_id IS NULL
+              OR (
+                ranked.active_group_count < $${groupConcurrencyParamIndex}
+                AND ranked.group_rank <= ($${groupConcurrencyParamIndex} - ranked.active_group_count)
+              )
+            ORDER BY ranked.priority DESC, ranked.created_at ASC
+            LIMIT $2
           )
-          ${jobTypeFilter}
-          ORDER BY priority DESC, created_at ASC
-          LIMIT $2
-          FOR UPDATE SKIP LOCKED
-        )
-        RETURNING id, job_type AS "jobType", payload, status, max_attempts AS "maxAttempts", attempts, priority, run_at AS "runAt", timeout_ms AS "timeoutMs", force_kill_on_timeout AS "forceKillOnTimeout", created_at AS "createdAt", updated_at AS "updatedAt", started_at AS "startedAt", completed_at AS "completedAt", last_failed_at AS "lastFailedAt", locked_at AS "lockedAt", locked_by AS "lockedBy", error_history AS "errorHistory", failure_reason AS "failureReason", next_attempt_at AS "nextAttemptAt", last_retried_at AS "lastRetriedAt", last_cancelled_at AS "lastCancelledAt", pending_reason AS "pendingReason", idempotency_key AS "idempotencyKey", wait_until AS "waitUntil", wait_token_id AS "waitTokenId", step_data AS "stepData", progress
-      `,
-        params
-      );
+          UPDATE job_queue
+          SET status = 'processing', 
+              locked_at = NOW(), 
+              locked_by = $1,
+              attempts = CASE WHEN status = 'waiting' THEN attempts ELSE attempts + 1 END,
+              updated_at = NOW(),
+              pending_reason = NULL,
+              started_at = COALESCE(started_at, NOW()),
+              last_retried_at = CASE WHEN status != 'waiting' AND attempts > 0 THEN NOW() ELSE last_retried_at END,
+              wait_until = NULL
+          WHERE id IN (SELECT id FROM selected)
+          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", group_id AS "groupId", group_tier AS "groupTier", output
+        `,
+          constrainedParams
+        );
+      }
       log(`Found ${result.rows.length} jobs to process`);
       await client.query("COMMIT");
       if (result.rows.length > 0) {
@@ -1175,17 +1626,19 @@ var PostgresBackend = class {
       client.release();
     }
   }
-  async completeJob(jobId) {
+  async completeJob(jobId, output) {
     const client = await this.pool.connect();
     try {
+      const outputJson = output !== void 0 ? JSON.stringify(output) : null;
       const result = await client.query(
         `
         UPDATE job_queue
         SET status = 'completed', updated_at = NOW(), completed_at = NOW(),
-            step_data = NULL, wait_until = NULL, wait_token_id = NULL
+            step_data = NULL, wait_until = NULL, wait_token_id = NULL,
+            output = COALESCE($2::jsonb, output)
         WHERE id = $1 AND status = 'processing'
       `,
-        [jobId]
+        [jobId, outputJson]
       );
       if (result.rowCount === 0) {
         log(
@@ -1209,9 +1662,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,
@@ -1280,6 +1741,21 @@ var PostgresBackend = class {
       client.release();
     }
   }
+  // ── Output ────────────────────────────────────────────────────────────
+  async updateOutput(jobId, output) {
+    const client = await this.pool.connect();
+    try {
+      await client.query(
+        `UPDATE job_queue SET output = $2::jsonb, updated_at = NOW() WHERE id = $1`,
+        [jobId, JSON.stringify(output)]
+      );
+      log(`Updated output for job ${jobId}`);
+    } catch (error) {
+      log(`Error updating output for job ${jobId}: ${error}`);
+    } finally {
+      client.release();
+    }
+  }
   // ── Job management ────────────────────────────────────────────────────
   async retryJob(jobId) {
     const client = await this.pool.connect();
@@ -1449,6 +1925,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;
@@ -1470,6 +1958,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) {
@@ -1513,6 +2007,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;
@@ -1754,8 +2260,8 @@ var PostgresBackend = class {
         `INSERT INTO cron_schedules
           (schedule_name, cron_expression, job_type, payload, max_attempts,
            priority, timeout_ms, force_kill_on_timeout, tags, timezone,
-           allow_overlap, next_run_at)
-         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+           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,
@@ -1769,7 +2275,10 @@ var PostgresBackend = class {
           input.tags ?? null,
           input.timezone,
           input.allowOverlap,
-          input.nextRunAt
+          input.nextRunAt,
+          input.retryDelay,
+          input.retryBackoff,
+          input.retryDelayMax
         ]
       );
       const id = result.rows[0].id;
@@ -1799,7 +2308,9 @@ var PostgresBackend = class {
                 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"
+                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]
       );
@@ -1824,7 +2335,9 @@ var PostgresBackend = class {
                 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"
+                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]
       );
@@ -1848,7 +2361,9 @@ var PostgresBackend = class {
                 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"
+                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) {
@@ -1953,6 +2468,18 @@ var PostgresBackend = class {
         updateFields.push(`allow_overlap = $${paramIdx++}`);
         params.push(updates.allowOverlap);
       }
+      if (updates.retryDelay !== void 0) {
+        updateFields.push(`retry_delay = $${paramIdx++}`);
+        params.push(updates.retryDelay);
+      }
+      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);
@@ -1988,7 +2515,9 @@ var PostgresBackend = class {
                 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"
+                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
@@ -2272,6 +2801,11 @@ 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
+local groupId = ARGV[14]          -- "null" or group ID
+local groupTier = ARGV[15]        -- "null" or group tier
 
 -- Idempotency check
 if idempotencyKey ~= "null" then
@@ -2315,7 +2849,12 @@ redis.call('HMSET', jobKey,
   'idempotencyKey', idempotencyKey,
   'waitUntil', 'null',
   'waitTokenId', 'null',
-  'stepData', 'null'
+  'stepData', 'null',
+  'retryDelay', retryDelay,
+  'retryBackoff', retryBackoff,
+  'retryDelayMax', retryDelayMax,
+  'groupId', groupId,
+  'groupTier', groupTier
 )
 
 -- Status index
@@ -2356,12 +2895,134 @@ 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)
+  local groupId = tostring(job.groupId)
+  local groupTier = tostring(job.groupTier)
+
+  -- 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,
+      'groupId', groupId,
+      'groupTier', groupTier
+    )
+
+    -- 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]
 local batchSize = tonumber(ARGV[2])
 local nowMs = tonumber(ARGV[3])
 local jobTypeFilter = ARGV[4] -- "null" or JSON array or single string
+local groupConcurrencyRaw = ARGV[5] -- "null" or positive integer
+local groupConcurrency = nil
+if groupConcurrencyRaw ~= "null" then
+  groupConcurrency = tonumber(groupConcurrencyRaw)
+end
+local groupActiveKey = prefix .. 'group:active'
 
 -- 1. Move ready delayed jobs into queue
 local delayed = redis.call('ZRANGEBYSCORE', prefix .. 'delayed', '-inf', nowMs, 'LIMIT', 0, 200)
@@ -2462,36 +3123,53 @@ for i = 1, #candidates, 2 do
         -- Not ready yet: move to delayed
         redis.call('ZADD', prefix .. 'delayed', runAt, jobId)
       else
-        -- Claim this job
-        local attempts = tonumber(redis.call('HGET', jk, 'attempts'))
-        local startedAt = redis.call('HGET', jk, 'startedAt')
-        local lastRetriedAt = redis.call('HGET', jk, 'lastRetriedAt')
-        if startedAt == 'null' then startedAt = nowMs end
-        if attempts > 0 then lastRetriedAt = nowMs end
+        local groupId = redis.call('HGET', jk, 'groupId')
+        local hasGroup = groupId and groupId ~= 'null'
+        local canClaim = true
+        if hasGroup and groupConcurrency then
+          local activeCount = tonumber(redis.call('HGET', groupActiveKey, groupId) or '0')
+          if activeCount >= groupConcurrency then
+            table.insert(putBack, score)
+            table.insert(putBack, jobId)
+            canClaim = false
+          end
+        end
 
-        redis.call('HMSET', jk,
-          'status', 'processing',
-          'lockedAt', nowMs,
-          'lockedBy', workerId,
-          'attempts', attempts + 1,
-          'updatedAt', nowMs,
-          'pendingReason', 'null',
-          'startedAt', startedAt,
-          'lastRetriedAt', lastRetriedAt
-        )
+        if canClaim then
+          -- Claim this job
+          local attempts = tonumber(redis.call('HGET', jk, 'attempts'))
+          local startedAt = redis.call('HGET', jk, 'startedAt')
+          local lastRetriedAt = redis.call('HGET', jk, 'lastRetriedAt')
+          if startedAt == 'null' then startedAt = nowMs end
+          if attempts > 0 then lastRetriedAt = nowMs end
+
+          redis.call('HMSET', jk,
+            'status', 'processing',
+            'lockedAt', nowMs,
+            'lockedBy', workerId,
+            'attempts', attempts + 1,
+            'updatedAt', nowMs,
+            'pendingReason', 'null',
+            'startedAt', startedAt,
+            'lastRetriedAt', lastRetriedAt
+          )
 
-        -- Update status sets
-        redis.call('SREM', prefix .. 'status:pending', jobId)
-        redis.call('SADD', prefix .. 'status:processing', jobId)
+          -- Update status sets
+          redis.call('SREM', prefix .. 'status:pending', jobId)
+          redis.call('SADD', prefix .. 'status:processing', jobId)
+          if hasGroup and groupConcurrency then
+            redis.call('HINCRBY', groupActiveKey, groupId, 1)
+          end
 
-        -- Return job data as flat array
-        local data = redis.call('HGETALL', jk)
-        for _, v in ipairs(data) do
-          table.insert(results, v)
+          -- Return job data as flat array
+          local data = redis.call('HGETALL', jk)
+          for _, v in ipairs(data) do
+            table.insert(results, v)
+          end
+          -- Separator
+          table.insert(results, '__JOB_SEP__')
+          jobsClaimed = jobsClaimed + 1
         end
-        -- Separator
-        table.insert(results, '__JOB_SEP__')
-        jobsClaimed = jobsClaimed + 1
       end
     end
   end
@@ -2508,18 +3186,34 @@ var COMPLETE_JOB_SCRIPT = `
 local prefix = KEYS[1]
 local jobId = ARGV[1]
 local nowMs = ARGV[2]
+local outputJson = ARGV[3]
 local jk = prefix .. 'job:' .. jobId
+local groupId = redis.call('HGET', jk, 'groupId')
 
-redis.call('HMSET', jk,
+local fields = {
   'status', 'completed',
   'updatedAt', nowMs,
   'completedAt', nowMs,
   'stepData', 'null',
   'waitUntil', 'null',
   'waitTokenId', 'null'
-)
+}
+
+if outputJson ~= '__NONE__' then
+  fields[#fields + 1] = 'output'
+  fields[#fields + 1] = outputJson
+end
+
+redis.call('HMSET', jk, unpack(fields))
 redis.call('SREM', prefix .. 'status:processing', jobId)
 redis.call('SADD', prefix .. 'status:completed', jobId)
+if groupId and groupId ~= 'null' then
+  local activeKey = prefix .. 'group:active'
+  local remaining = redis.call('HINCRBY', activeKey, groupId, -1)
+  if tonumber(remaining) <= 0 then
+    redis.call('HDEL', activeKey, groupId)
+  end
+end
 
 return 1
 `;
@@ -2530,15 +3224,43 @@ local errorJson = ARGV[2]
 local failureReason = ARGV[3]
 local nowMs = tonumber(ARGV[4])
 local jk = prefix .. 'job:' .. jobId
+local groupId = redis.call('HGET', jk, 'groupId')
 
 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
@@ -2560,6 +3282,13 @@ redis.call('HMSET', jk,
 )
 redis.call('SREM', prefix .. 'status:processing', jobId)
 redis.call('SADD', prefix .. 'status:failed', jobId)
+if groupId and groupId ~= 'null' then
+  local activeKey = prefix .. 'group:active'
+  local remaining = redis.call('HINCRBY', activeKey, groupId, -1)
+  if tonumber(remaining) <= 0 then
+    redis.call('HDEL', activeKey, groupId)
+  end
+end
 
 -- Schedule retry if applicable
 if nextAttemptAt ~= 'null' then
@@ -2576,6 +3305,7 @@ local jk = prefix .. 'job:' .. jobId
 
 local oldStatus = redis.call('HGET', jk, 'status')
 if oldStatus ~= 'failed' and oldStatus ~= 'processing' then return 0 end
+local groupId = redis.call('HGET', jk, 'groupId')
 
 redis.call('HMSET', jk,
   'status', 'pending',
@@ -2589,6 +3319,13 @@ redis.call('HMSET', jk,
 -- Remove from old status, add to pending
 redis.call('SREM', prefix .. 'status:' .. oldStatus, jobId)
 redis.call('SADD', prefix .. 'status:pending', jobId)
+if oldStatus == 'processing' and groupId and groupId ~= 'null' then
+  local activeKey = prefix .. 'group:active'
+  local remaining = redis.call('HINCRBY', activeKey, groupId, -1)
+  if tonumber(remaining) <= 0 then
+    redis.call('HDEL', activeKey, groupId)
+  end
+end
 
 -- Remove from retry sorted set if present
 redis.call('ZREM', prefix .. 'retry', jobId)
@@ -2675,6 +3412,14 @@ for _, jobId in ipairs(processing) do
         )
         redis.call('SREM', prefix .. 'status:processing', jobId)
         redis.call('SADD', prefix .. 'status:pending', jobId)
+        local groupId = redis.call('HGET', jk, 'groupId')
+        if groupId and groupId ~= 'null' then
+          local activeKey = prefix .. 'group:active'
+          local remaining = redis.call('HINCRBY', activeKey, groupId, -1)
+          if tonumber(remaining) <= 0 then
+            redis.call('HDEL', activeKey, groupId)
+          end
+        end
 
         -- Re-add to queue
         local priority = tonumber(redis.call('HGET', jk, 'priority') or '0')
@@ -2741,6 +3486,7 @@ local jk = prefix .. 'job:' .. jobId
 
 local status = redis.call('HGET', jk, 'status')
 if status ~= 'processing' then return 0 end
+local groupId = redis.call('HGET', jk, 'groupId')
 
 redis.call('HMSET', jk,
   'status', 'waiting',
@@ -2753,6 +3499,13 @@ redis.call('HMSET', jk,
 )
 redis.call('SREM', prefix .. 'status:processing', jobId)
 redis.call('SADD', prefix .. 'status:waiting', jobId)
+if groupId and groupId ~= 'null' then
+  local activeKey = prefix .. 'group:active'
+  local remaining = redis.call('HINCRBY', activeKey, groupId, -1)
+  if tonumber(remaining) <= 0 then
+    redis.call('HDEL', activeKey, groupId)
+  end
+end
 
 -- Add to waiting sorted set if time-based wait
 if waitUntilMs ~= 'null' then
@@ -2950,9 +3703,23 @@ function deserializeJob(h) {
     progress: numOrNull(h.progress),
     waitUntil: dateOrNull(h.waitUntil),
     waitTokenId: nullish(h.waitTokenId),
-    stepData: parseStepData(h.stepData)
+    stepData: parseStepData(h.stepData),
+    retryDelay: numOrNull(h.retryDelay),
+    retryBackoff: h.retryBackoff === "true" ? true : h.retryBackoff === "false" ? false : null,
+    retryDelayMax: numOrNull(h.retryDelayMax),
+    groupId: nullish(h.groupId),
+    groupTier: nullish(h.groupTier),
+    output: parseJsonField(h.output)
   };
 }
+function parseJsonField(raw) {
+  if (!raw || raw === "null") return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
 function parseStepData(raw) {
   if (!raw || raw === "null") return void 0;
   try {
@@ -2962,7 +3729,23 @@ function parseStepData(raw) {
   }
 }
 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 = createRequire(import.meta.url);
@@ -3035,8 +3818,17 @@ 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,
+    group = 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(
@@ -3052,7 +3844,12 @@ 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",
+      group?.id ?? "null",
+      group?.tier ?? "null"
     );
     const jobId = Number(result);
     log(
@@ -3066,6 +3863,60 @@ 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",
+      groupId: job.group?.id ?? "null",
+      groupTier: job.group?.tier ?? "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) {
@@ -3136,7 +3987,7 @@ var RedisBackend = class {
     return jobs.slice(offset, offset + limit);
   }
   // ── Processing lifecycle ──────────────────────────────────────────────
-  async getNextBatch(workerId, batchSize = 10, jobType) {
+  async getNextBatch(workerId, batchSize = 10, jobType, groupConcurrency) {
     const now = this.nowMs();
     const jobTypeFilter = jobType === void 0 ? "null" : Array.isArray(jobType) ? JSON.stringify(jobType) : jobType;
     const result = await this.client.eval(
@@ -3146,7 +3997,8 @@ var RedisBackend = class {
       workerId,
       batchSize,
       now,
-      jobTypeFilter
+      jobTypeFilter,
+      groupConcurrency !== void 0 ? groupConcurrency : "null"
     );
     if (!result || result.length === 0) {
       log("Found 0 jobs to process");
@@ -3171,9 +4023,17 @@ var RedisBackend = class {
     }
     return jobs;
   }
-  async completeJob(jobId) {
+  async completeJob(jobId, output) {
     const now = this.nowMs();
-    await this.client.eval(COMPLETE_JOB_SCRIPT, 1, this.prefix, jobId, now);
+    const outputArg = output !== void 0 ? JSON.stringify(output) : "__NONE__";
+    await this.client.eval(
+      COMPLETE_JOB_SCRIPT,
+      1,
+      this.prefix,
+      jobId,
+      now,
+      outputArg
+    );
     await this.recordJobEvent(jobId, "completed" /* Completed */);
     log(`Completed job ${jobId}`);
   }
@@ -3226,6 +4086,22 @@ var RedisBackend = class {
       log(`Error updating progress for job ${jobId}: ${error}`);
     }
   }
+  // ── Output ────────────────────────────────────────────────────────────
+  async updateOutput(jobId, output) {
+    try {
+      const now = this.nowMs();
+      await this.client.hset(
+        `${this.prefix}job:${jobId}`,
+        "output",
+        JSON.stringify(output),
+        "updatedAt",
+        now.toString()
+      );
+      log(`Updated output for job ${jobId}`);
+    } catch (error) {
+      log(`Error updating output for job ${jobId}: ${error}`);
+    }
+  }
   // ── Job management ────────────────────────────────────────────────────
   async retryJob(jobId) {
     const now = this.nowMs();
@@ -3332,6 +4208,27 @@ 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;
@@ -3806,7 +4703,13 @@ var RedisBackend = class {
       "createdAt",
       now.toString(),
       "updatedAt",
-      now.toString()
+      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(
@@ -3960,6 +4863,24 @@ var RedisBackend = class {
     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);
@@ -4078,7 +4999,10 @@ var RedisBackend = class {
       lastJobId: numOrNull(h.lastJobId),
       nextRunAt: dateOrNull(h.nextRunAt),
       createdAt: new Date(Number(h.createdAt)),
-      updatedAt: new Date(Number(h.updatedAt))
+      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) ─────────────────────────────────────────
@@ -4201,14 +5125,37 @@ var initJobQueue = (config) => {
   let backend;
   if (backendType === "postgres") {
     const pgConfig = config;
-    const 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 emitter = new EventEmitter();
+  const emit = (event, data) => {
+    emitter.emit(event, data);
+  };
   const enqueueDueCronJobsImpl = async () => {
     const dueSchedules = await backend.getDueCronSchedules();
     let count = 0;
@@ -4236,7 +5183,10 @@ var initJobQueue = (config) => {
         priority: schedule.priority,
         timeoutMs: schedule.timeoutMs ?? void 0,
         forceKillOnTimeout: schedule.forceKillOnTimeout,
-        tags: schedule.tags
+        tags: schedule.tags,
+        retryDelay: schedule.retryDelay ?? void 0,
+        retryBackoff: schedule.retryBackoff ?? void 0,
+        retryDelayMax: schedule.retryDelayMax ?? void 0
       });
       const nextRunAt = getNextCronOccurrence(
         schedule.cronExpression,
@@ -4255,7 +5205,21 @@ var initJobQueue = (config) => {
   return {
     // Job queue operations
     addJob: withLogContext(
-      (job) => backend.addJob(job),
+      async (job, options) => {
+        const jobId = await backend.addJob(job, options);
+        emit("job:added", { jobId, jobType: job.jobType });
+        return jobId;
+      },
+      config.verbose ?? false
+    ),
+    addJobs: withLogContext(
+      async (jobs, options) => {
+        const jobIds = await backend.addJobs(jobs, options);
+        for (let i = 0; i < jobIds.length; i++) {
+          emit("job:added", { jobId: jobIds[i], jobType: jobs[i].jobType });
+        }
+        return jobIds;
+      },
       config.verbose ?? false
     ),
     getJob: withLogContext(
@@ -4274,13 +5238,16 @@ var initJobQueue = (config) => {
       (filters, limit, offset) => backend.getJobs(filters, limit, offset),
       config.verbose ?? false
     ),
-    retryJob: (jobId) => backend.retryJob(jobId),
+    retryJob: async (jobId) => {
+      await backend.retryJob(jobId);
+      emit("job:retried", { jobId });
+    },
     cleanupOldJobs: (daysToKeep, batchSize) => backend.cleanupOldJobs(daysToKeep, batchSize),
     cleanupOldJobEvents: (daysToKeep, batchSize) => backend.cleanupOldJobEvents(daysToKeep, batchSize),
-    cancelJob: withLogContext(
-      (jobId) => backend.cancelJob(jobId),
-      config.verbose ?? false
-    ),
+    cancelJob: withLogContext(async (jobId) => {
+      await backend.cancelJob(jobId);
+      emit("job:cancelled", { jobId });
+    }, config.verbose ?? false),
     editJob: withLogContext(
       (jobId, updates) => backend.editJob(jobId, updates),
       config.verbose ?? false
@@ -4305,9 +5272,17 @@ var initJobQueue = (config) => {
       config.verbose ?? false
     ),
     // Job processing — automatically enqueues due cron jobs before each batch
-    createProcessor: (handlers, options) => createProcessor(backend, handlers, options, async () => {
-      await enqueueDueCronJobsImpl();
-    }),
+    createProcessor: (handlers, options) => createProcessor(
+      backend,
+      handlers,
+      options,
+      async () => {
+        await enqueueDueCronJobsImpl();
+      },
+      emit
+    ),
+    // Background supervisor — automated maintenance
+    createSupervisor: (options) => createSupervisor(backend, options, emit),
     // Job events
     getJobEvents: withLogContext(
       (jobId) => backend.getJobEvents(jobId),
@@ -4354,7 +5329,10 @@ var initJobQueue = (config) => {
           tags: options.tags,
           timezone: options.timezone ?? "UTC",
           allowOverlap: options.allowOverlap ?? false,
-          nextRunAt
+          nextRunAt,
+          retryDelay: options.retryDelay ?? null,
+          retryBackoff: options.retryBackoff ?? null,
+          retryDelayMax: options.retryDelayMax ?? null
         };
         return backend.addCronSchedule(input);
       },
@@ -4406,6 +5384,23 @@ var initJobQueue = (config) => {
       () => enqueueDueCronJobsImpl(),
       config.verbose ?? false
     ),
+    // Event hooks
+    on: (event, listener) => {
+      emitter.on(event, listener);
+    },
+    once: (event, listener) => {
+      emitter.once(event, listener);
+    },
+    off: (event, listener) => {
+      emitter.off(event, listener);
+    },
+    removeAllListeners: (event) => {
+      if (event) {
+        emitter.removeAllListeners(event);
+      } else {
+        emitter.removeAllListeners();
+      }
+    },
     // Advanced access
     getPool: () => {
       if (!(backend instanceof PostgresBackend)) {