@nicnocquee/dataqueue 1.38.0 → 1.39.0-beta.20260322125514

package/dist/index.js

@@ -915,7 +915,109 @@ Recommended: Remove sslmode from the connection string when using a custom CA.
   }
   return pool;
 };
+
+// src/job-dependencies.ts
+function batchDepRef(batchIndex) {
+  if (!Number.isInteger(batchIndex) || batchIndex < 0) {
+    throw new Error(
+      `batchDepRef: expected non-negative integer index, got ${batchIndex}`
+    );
+  }
+  return -(batchIndex + 1);
+}
+function normalizeDependsOn(dep) {
+  if (!dep) return { jobIds: void 0, tags: void 0 };
+  const jobIds = dep.jobIds && dep.jobIds.length > 0 ? [...new Set(dep.jobIds)] : void 0;
+  const tags = dep.tags && dep.tags.length > 0 ? [...new Set(dep.tags)] : void 0;
+  return { jobIds, tags };
+}
+function resolveDependsOnJobIdsForBatch(jobIds, insertedIds) {
+  return jobIds.map((id) => {
+    if (id >= 0) return id;
+    const idx = -id - 1;
+    if (idx < 0 || idx >= insertedIds.length) {
+      throw new Error(
+        `Invalid batch-relative job id ${id}: index ${idx} out of range for ${insertedIds.length} inserted job(s)`
+      );
+    }
+    return insertedIds[idx];
+  });
+}
+function tagsAreSuperset(holderTags, requiredTags) {
+  if (!requiredTags || requiredTags.length === 0) return false;
+  if (!holderTags || holderTags.length === 0) return false;
+  const set = new Set(holderTags);
+  for (const t of requiredTags) {
+    if (!set.has(t)) return false;
+  }
+  return true;
+}
+async function validatePrerequisiteJobIdsExist(client, jobIds) {
+  if (jobIds.length === 0) return;
+  const r = await client.query(
+    `SELECT COUNT(*)::int AS c FROM job_queue WHERE id = ANY($1::int[])`,
+    [jobIds]
+  );
+  const c = r.rows[0]?.c ?? 0;
+  if (c !== jobIds.length) {
+    throw new Error(
+      `dependsOn.jobIds: one or more job ids do not exist (${jobIds.join(", ")})`
+    );
+  }
+}
+async function assertNoDependencyCycle(client, newJobId, dependsOnJobIds) {
+  if (dependsOnJobIds.length === 0) return;
+  if (dependsOnJobIds.includes(newJobId)) {
+    throw new Error(
+      `Job ${newJobId} cannot depend on itself (dependsOn.jobIds)`
+    );
+  }
+  const result = await client.query(
+    `
+    WITH RECURSIVE downstream AS (
+      SELECT j.id
+      FROM job_queue j
+      WHERE j.depends_on_job_ids @> ARRAY[$1::integer]::integer[]
+      UNION
+      SELECT j.id
+      FROM job_queue j
+      INNER JOIN downstream d ON j.depends_on_job_ids @> ARRAY[d.id]::integer[]
+    )
+    SELECT 1 FROM downstream WHERE id = ANY($2::integer[]) LIMIT 1
+    `,
+    [newJobId, dependsOnJobIds]
+  );
+  if (result.rows.length > 0) {
+    throw new Error(
+      `Adding job ${newJobId} would create a dependency cycle (dependsOn.jobIds)`
+    );
+  }
+}
+
+// src/backends/postgres.ts
 var MAX_TIMEOUT_MS = 365 * 24 * 60 * 60 * 1e3;
+var JOB_DEPENDS_ON_PREDICATE = `
+            AND (
+              candidate.depends_on_job_ids IS NULL
+              OR cardinality(candidate.depends_on_job_ids) = 0
+              OR NOT EXISTS (
+                SELECT 1
+                FROM unnest(candidate.depends_on_job_ids) AS dep(id)
+                LEFT JOIN job_queue prereq ON prereq.id = dep.id
+                WHERE prereq.id IS NULL OR prereq.status <> 'completed'
+              )
+            )
+            AND (
+              candidate.depends_on_tags IS NULL
+              OR cardinality(candidate.depends_on_tags) = 0
+              OR NOT EXISTS (
+                SELECT 1 FROM job_queue blocker
+                WHERE blocker.id <> candidate.id
+                  AND blocker.status IN ('pending', 'processing', 'waiting')
+                  AND blocker.tags IS NOT NULL
+                  AND blocker.tags @> candidate.depends_on_tags
+              )
+            )`;
 function parseTimeoutString(timeout) {
   const match = timeout.match(/^(\d+)(s|m|h|d)$/);
   if (!match) {
@@ -1022,18 +1124,35 @@ var PostgresBackend = class {
     retryBackoff = void 0,
     retryDelayMax = void 0,
     deadLetterJobType = void 0,
-    group = void 0
+    group = void 0,
+    dependsOn
   }, options) {
     const externalClient = options?.db;
     const client = externalClient ?? await this.pool.connect();
+    let manageTx = false;
     try {
+      const { jobIds: depJobIdsRaw, tags: depTags } = normalizeDependsOn(dependsOn);
+      let resolvedDepJobIds = [];
+      if (depJobIdsRaw?.length) {
+        if (depJobIdsRaw.some((id) => id < 0)) {
+          throw new Error(
+            "dependsOn.jobIds: batch-relative (negative) ids are only supported in addJobs()"
+          );
+        }
+        resolvedDepJobIds = depJobIdsRaw;
+        await validatePrerequisiteJobIdsExist(client, resolvedDepJobIds);
+      }
+      const dependsOnJobIdsParam = resolvedDepJobIds.length > 0 ? resolvedDepJobIds : null;
+      const dependsOnTagsParam = depTags?.length ? depTags : null;
+      manageTx = resolvedDepJobIds.length > 0 && !externalClient;
+      if (manageTx) await client.query("BEGIN");
       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, dead_letter_job_type, group_id, group_tier) 
-           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15) 
+            (job_type, payload, max_attempts, priority, run_at, timeout_ms, force_kill_on_timeout, tags, idempotency_key, retry_delay, retry_backoff, retry_delay_max, dead_letter_job_type, group_id, group_tier, depends_on_job_ids, depends_on_tags) 
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17) 
            ${onConflict}
            RETURNING id`,
           [
@@ -1051,14 +1170,16 @@ var PostgresBackend = class {
             retryDelayMax ?? null,
             deadLetterJobType ?? null,
             group?.id ?? null,
-            group?.tier ?? null
+            group?.tier ?? null,
+            dependsOnJobIdsParam,
+            dependsOnTagsParam
           ]
         );
       } 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, dead_letter_job_type, group_id, group_tier) 
-           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14) 
+            (job_type, payload, max_attempts, priority, timeout_ms, force_kill_on_timeout, tags, idempotency_key, retry_delay, retry_backoff, retry_delay_max, dead_letter_job_type, group_id, group_tier, depends_on_job_ids, depends_on_tags) 
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16) 
            ${onConflict}
            RETURNING id`,
           [
@@ -1075,11 +1196,14 @@ var PostgresBackend = class {
             retryDelayMax ?? null,
             deadLetterJobType ?? null,
             group?.id ?? null,
-            group?.tier ?? null
+            group?.tier ?? null,
+            dependsOnJobIdsParam,
+            dependsOnTagsParam
           ]
         );
       }
       if (result.rows.length === 0 && idempotencyKey) {
+        if (manageTx) await client.query("ROLLBACK");
         const existing = await client.query(
           `SELECT id FROM job_queue WHERE idempotency_key = $1`,
           [idempotencyKey]
@@ -1090,37 +1214,46 @@ var PostgresBackend = class {
           );
           return existing.rows[0].id;
         }
+        if (manageTx) await client.query("ROLLBACK");
         throw new Error(
           `Failed to insert job and could not find existing job with idempotency key "${idempotencyKey}"`
         );
       }
       const jobId = result.rows[0].id;
+      if (resolvedDepJobIds.length > 0) {
+        await assertNoDependencyCycle(client, jobId, resolvedDepJobIds);
+      }
       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}"` : ""}`
       );
+      const addedMeta = {
+        jobType,
+        payload,
+        tags,
+        idempotencyKey,
+        dependsOn: dependsOnJobIdsParam || dependsOnTagsParam ? dependsOn : void 0
+      };
       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 })
-            ]
+            [jobId, "added" /* Added */, JSON.stringify(addedMeta)]
           );
         } catch (error) {
           log(`Error recording job event for job ${jobId}: ${error}`);
         }
       } else {
-        await this.recordJobEvent(jobId, "added" /* Added */, {
-          jobType,
-          payload,
-          tags,
-          idempotencyKey
-        });
+        await this.recordJobEvent(jobId, "added" /* Added */, addedMeta);
       }
+      if (manageTx) await client.query("COMMIT");
       return jobId;
     } catch (error) {
+      if (manageTx) {
+        try {
+          await client.query("ROLLBACK");
+        } catch {
+        }
+      }
       log(`Error adding job: ${error}`);
       throw error;
     } finally {
@@ -1138,7 +1271,50 @@ var PostgresBackend = class {
     const externalClient = options?.db;
     const client = externalClient ?? await this.pool.connect();
     try {
-      const COLS_PER_JOB = 15;
+      const needsSequential = jobs.some((j) => {
+        const n = normalizeDependsOn(j.dependsOn);
+        return Boolean(n.jobIds?.length || n.tags?.length);
+      });
+      if (needsSequential) {
+        const useOuterTx = !externalClient;
+        if (useOuterTx) await client.query("BEGIN");
+        try {
+          const ids2 = [];
+          for (let i = 0; i < jobs.length; i++) {
+            let job = jobs[i];
+            const nd = normalizeDependsOn(job.dependsOn);
+            if (nd.jobIds?.some((id2) => id2 < 0)) {
+              const resolvedJobIds = resolveDependsOnJobIdsForBatch(
+                nd.jobIds,
+                ids2
+              );
+              job = {
+                ...job,
+                dependsOn: {
+                  jobIds: resolvedJobIds,
+                  tags: job.dependsOn?.tags
+                }
+              };
+            }
+            const id = await this.addJob(job, { db: client });
+            ids2.push(id);
+          }
+          if (useOuterTx) await client.query("COMMIT");
+          log(
+            `Batch-inserted ${jobs.length} jobs (sequential), IDs: [${ids2.join(", ")}]`
+          );
+          return ids2;
+        } catch (e) {
+          if (!externalClient) {
+            try {
+              await client.query("ROLLBACK");
+            } catch {
+            }
+          }
+          throw e;
+        }
+      }
+      const COLS_PER_JOB = 17;
       const valueClauses = [];
       const params = [];
       const hasAnyIdempotencyKey = jobs.some((j) => j.idempotencyKey);
@@ -1161,7 +1337,7 @@ var PostgresBackend = class {
         } = 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}, $${base + 15})`
+          `($${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}, $${base + 15}, $${base + 16}, $${base + 17})`
         );
         params.push(
           jobType,
@@ -1178,13 +1354,15 @@ var PostgresBackend = class {
           retryDelayMax ?? null,
           deadLetterJobType ?? null,
           group?.id ?? null,
-          group?.tier ?? null
+          group?.tier ?? null,
+          null,
+          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, dead_letter_job_type, group_id, group_tier)
+          (job_type, payload, max_attempts, priority, run_at, timeout_ms, force_kill_on_timeout, tags, idempotency_key, retry_delay, retry_backoff, retry_delay_max, dead_letter_job_type, group_id, group_tier, depends_on_job_ids, depends_on_tags)
          VALUES ${valueClauses.join(", ")}
          ${onConflict}
          RETURNING id, idempotency_key`,
@@ -1235,6 +1413,7 @@ var PostgresBackend = class {
         const job = jobs[i];
         const wasInserted = !job.idempotencyKey || !missingKeys.includes(job.idempotencyKey);
         if (wasInserted) {
+          const nd = normalizeDependsOn(job.dependsOn);
           newJobEvents.push({
             jobId: ids[i],
             eventType: "added" /* Added */,
@@ -1242,7 +1421,8 @@ var PostgresBackend = class {
               jobType: job.jobType,
               payload: job.payload,
               tags: job.tags,
-              idempotencyKey: job.idempotencyKey
+              idempotencyKey: job.idempotencyKey,
+              ...nd.jobIds?.length || nd.tags?.length ? { dependsOn: job.dependsOn } : {}
             }
           });
         }
@@ -1284,7 +1464,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", 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", dead_letter_job_type AS "deadLetterJobType", dead_lettered_at AS "deadLetteredAt", dead_letter_job_id AS "deadLetterJobId", group_id AS "groupId", group_tier AS "groupTier", output 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", dead_letter_job_type AS "deadLetterJobType", dead_lettered_at AS "deadLetteredAt", dead_letter_job_id AS "deadLetterJobId", group_id AS "groupId", group_tier AS "groupTier", depends_on_job_ids AS "dependsOnJobIds", depends_on_tags AS "dependsOnTags", output FROM job_queue WHERE id = $1`,
         [id]
       );
       if (result.rows.length === 0) {
@@ -1311,7 +1491,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, retry_delay AS "retryDelay", retry_backoff AS "retryBackoff", retry_delay_max AS "retryDelayMax", dead_letter_job_type AS "deadLetterJobType", dead_lettered_at AS "deadLetteredAt", dead_letter_job_id AS "deadLetterJobId", group_id AS "groupId", group_tier AS "groupTier", output 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", dead_letter_job_type AS "deadLetterJobType", dead_lettered_at AS "deadLetteredAt", dead_letter_job_id AS "deadLetterJobId", group_id AS "groupId", group_tier AS "groupTier", depends_on_job_ids AS "dependsOnJobIds", depends_on_tags AS "dependsOnTags", 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}`);
@@ -1333,7 +1513,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, retry_delay AS "retryDelay", retry_backoff AS "retryBackoff", retry_delay_max AS "retryDelayMax", dead_letter_job_type AS "deadLetterJobType", dead_lettered_at AS "deadLetteredAt", dead_letter_job_id AS "deadLetterJobId", group_id AS "groupId", group_tier AS "groupTier", output 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", dead_letter_job_type AS "deadLetterJobType", dead_lettered_at AS "deadLetteredAt", dead_letter_job_id AS "deadLetterJobId", group_id AS "groupId", group_tier AS "groupTier", depends_on_job_ids AS "dependsOnJobIds", depends_on_tags AS "dependsOnTags", output FROM job_queue ORDER BY created_at DESC LIMIT $1 OFFSET $2`,
         [limit, offset]
       );
       log(`Found ${result.rows.length} jobs (all)`);
@@ -1353,7 +1533,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, retry_delay AS "retryDelay", retry_backoff AS "retryBackoff", retry_delay_max AS "retryDelayMax", dead_letter_job_type AS "deadLetterJobType", dead_lettered_at AS "deadLetteredAt", dead_letter_job_id AS "deadLetterJobId", group_id AS "groupId", group_tier AS "groupTier", output 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", dead_letter_job_type AS "deadLetterJobType", dead_lettered_at AS "deadLetteredAt", dead_letter_job_id AS "deadLetterJobId", group_id AS "groupId", group_tier AS "groupTier", depends_on_job_ids AS "dependsOnJobIds", depends_on_tags AS "dependsOnTags", output FROM job_queue`;
       const params = [];
       const where = [];
       let paramIdx = 1;
@@ -1454,7 +1634,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, retry_delay AS "retryDelay", retry_backoff AS "retryBackoff", retry_delay_max AS "retryDelayMax", dead_letter_job_type AS "deadLetterJobType", dead_lettered_at AS "deadLetteredAt", dead_letter_job_id AS "deadLetterJobId", group_id AS "groupId", group_tier AS "groupTier", output
+      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", dead_letter_job_type AS "deadLetterJobType", dead_lettered_at AS "deadLetteredAt", dead_letter_job_id AS "deadLetterJobId", group_id AS "groupId", group_tier AS "groupTier", depends_on_job_ids AS "dependsOnJobIds", depends_on_tags AS "dependsOnTags", output
          FROM job_queue`;
       let params = [];
       switch (mode) {
@@ -1546,11 +1726,12 @@ var PostgresBackend = class {
               )
             )
             ${jobTypeFilter}
+            ${JOB_DEPENDS_ON_PREDICATE}
             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", dead_letter_job_type AS "deadLetterJobType", dead_lettered_at AS "deadLetteredAt", dead_letter_job_id AS "deadLetterJobId", group_id AS "groupId", group_tier AS "groupTier", output
+          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", dead_letter_job_type AS "deadLetterJobType", dead_lettered_at AS "deadLetteredAt", dead_letter_job_id AS "deadLetterJobId", group_id AS "groupId", group_tier AS "groupTier", depends_on_job_ids AS "dependsOnJobIds", depends_on_tags AS "dependsOnTags", output
         `,
           params
         );
@@ -1576,6 +1757,7 @@ var PostgresBackend = class {
               )
             )
             ${jobTypeFilter}
+            ${JOB_DEPENDS_ON_PREDICATE}
             FOR UPDATE SKIP LOCKED
           ),
           ranked AS (
@@ -1618,7 +1800,7 @@ var PostgresBackend = class {
               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", dead_letter_job_type AS "deadLetterJobType", dead_lettered_at AS "deadLetteredAt", dead_letter_job_id AS "deadLetterJobId", group_id AS "groupId", group_tier AS "groupTier", output
+          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", dead_letter_job_type AS "deadLetterJobType", dead_lettered_at AS "deadLetteredAt", dead_letter_job_id AS "deadLetterJobId", group_id AS "groupId", group_tier AS "groupTier", depends_on_job_ids AS "dependsOnJobIds", depends_on_tags AS "dependsOnTags", output
         `,
           constrainedParams
         );
@@ -1675,6 +1857,75 @@ var PostgresBackend = class {
       client.release();
     }
   }
+  /**
+   * Cancel pending/waiting jobs that depend on any seed job (by job id or tag superset), transitively.
+   *
+   * @param client - Database client (must be inside an open transaction when used from fail/cancel).
+   * @param initialSeeds - Job ids that just failed or were cancelled.
+   * @param rootJobId - Original job id for event metadata.
+   */
+  async propagateDependencyCancellations(client, initialSeeds, rootJobId) {
+    const seeds = [...new Set(initialSeeds.filter((id) => id > 0))];
+    if (seeds.length === 0) return;
+    const cancelled = /* @__PURE__ */ new Set();
+    const reasonJson = JSON.stringify({
+      rootJobId,
+      dependencyCascade: true
+    });
+    let frontier = seeds;
+    while (frontier.length > 0) {
+      const res = await client.query(
+        `
+        SELECT DISTINCT j.id
+        FROM job_queue j
+        CROSS JOIN unnest($1::int[]) AS s(id)
+        INNER JOIN job_queue sx ON sx.id = s.id
+        WHERE j.status IN ('pending', 'waiting')
+          AND j.id <> sx.id
+          AND (
+            j.depends_on_job_ids @> ARRAY[s.id]::integer[]
+            OR (
+              j.depends_on_tags IS NOT NULL
+              AND cardinality(j.depends_on_tags) > 0
+              AND sx.tags IS NOT NULL
+              AND sx.tags @> j.depends_on_tags
+            )
+          )
+        `,
+        [frontier]
+      );
+      const toCancel = [];
+      for (const row of res.rows) {
+        const pid = row.id;
+        if (cancelled.has(pid)) continue;
+        cancelled.add(pid);
+        toCancel.push(pid);
+      }
+      if (toCancel.length === 0) break;
+      await client.query(
+        `
+        UPDATE job_queue
+        SET status = 'cancelled',
+            updated_at = NOW(),
+            last_cancelled_at = NOW(),
+            wait_until = NULL,
+            wait_token_id = NULL,
+            pending_reason = $2
+        WHERE id = ANY($1::int[])
+          AND status IN ('pending', 'waiting')
+        `,
+        [toCancel, reasonJson]
+      );
+      const meta = JSON.stringify({ rootJobId, dependencyCascade: true });
+      for (const jid of toCancel) {
+        await client.query(
+          `INSERT INTO job_events (job_id, event_type, metadata) VALUES ($1, $2, $3)`,
+          [jid, "cancelled" /* Cancelled */, meta]
+        );
+      }
+      frontier = toCancel;
+    }
+  }
   async failJob(jobId, error, failureReason) {
     const client = await this.pool.connect();
     try {
@@ -1744,8 +1995,8 @@ var PostgresBackend = class {
         });
         const deadLetterInsert = await client.query(
           `INSERT INTO job_queue
-            (job_type, payload, max_attempts, priority, run_at)
-           VALUES ($1, $2, $3, $4, NOW())
+            (job_type, payload, max_attempts, priority, run_at, depends_on_job_ids, depends_on_tags)
+           VALUES ($1, $2, $3, $4, NOW(), NULL, NULL)
            RETURNING id`,
           [failedJob.deadLetterJobType, deadLetterPayload, 1, 0]
         );
@@ -1782,6 +2033,7 @@ var PostgresBackend = class {
           })
         ]
       );
+      await this.propagateDependencyCancellations(client, [jobId], jobId);
       await client.query("COMMIT");
       log(
         `Failed job ${jobId}${deadLetterJobId ? ` and routed to dead-letter job ${deadLetterJobId}` : ""}`
@@ -1877,7 +2129,8 @@ var PostgresBackend = class {
   async cancelJob(jobId) {
     const client = await this.pool.connect();
     try {
-      await client.query(
+      await client.query("BEGIN");
+      const upd = await client.query(
         `
         UPDATE job_queue
         SET status = 'cancelled', updated_at = NOW(), last_cancelled_at = NOW(),
@@ -1886,9 +2139,25 @@ var PostgresBackend = class {
       `,
         [jobId]
       );
-      await this.recordJobEvent(jobId, "cancelled" /* Cancelled */);
+      if (upd.rowCount === 0) {
+        await client.query("ROLLBACK");
+        log(
+          `Job ${jobId} could not be cancelled (not in pending/waiting state or does not exist)`
+        );
+        return;
+      }
+      await client.query(
+        `INSERT INTO job_events (job_id, event_type, metadata) VALUES ($1, $2, $3)`,
+        [jobId, "cancelled" /* Cancelled */, null]
+      );
+      await this.propagateDependencyCancellations(client, [jobId], jobId);
+      await client.query("COMMIT");
       log(`Cancelled job ${jobId}`);
     } catch (error) {
+      try {
+        await client.query("ROLLBACK");
+      } catch {
+      }
       log(`Error cancelling job ${jobId}: ${error}`);
       throw error;
     } finally {
@@ -2921,6 +3190,8 @@ local retryDelayMax = ARGV[13]    -- "null" or seconds string
 local deadLetterJobType = ARGV[14] -- "null" or jobType string
 local groupId = ARGV[15]          -- "null" or group ID
 local groupTier = ARGV[16]        -- "null" or group tier
+local dependsOnJobIdsJson = ARGV[17] -- "null" or JSON array of job ids
+local dependsOnTagsJson = ARGV[18]   -- "null" or JSON array of tags
 
 -- Idempotency check
 if idempotencyKey ~= "null" then
@@ -2972,9 +3243,18 @@ redis.call('HMSET', jobKey,
   'deadLetteredAt', 'null',
   'deadLetterJobId', 'null',
   'groupId', groupId,
-  'groupTier', groupTier
+  'groupTier', groupTier,
+  'dependsOnJobIds', dependsOnJobIdsJson,
+  'dependsOnTags', dependsOnTagsJson
 )
 
+if dependsOnJobIdsJson ~= "null" then
+  local depIds = cjson.decode(dependsOnJobIdsJson)
+  for _, parentId in ipairs(depIds) do
+    redis.call('SADD', prefix .. 'dep:' .. tostring(parentId), tostring(id))
+  end
+end
+
 -- Status index
 redis.call('SADD', prefix .. 'status:pending', id)
 
@@ -3037,6 +3317,8 @@ for i, job in ipairs(jobs) do
   local deadLetterJobType = tostring(job.deadLetterJobType)
   local groupId = tostring(job.groupId)
   local groupTier = tostring(job.groupTier)
+  local dependsOnJobIdsJson = (job.dependsOnJobIds ~= nil and job.dependsOnJobIds ~= cjson.null) and tostring(job.dependsOnJobIds) or "null"
+  local dependsOnTagsJson = (job.dependsOnTags ~= nil and job.dependsOnTags ~= cjson.null) and tostring(job.dependsOnTags) or "null"
 
   -- Idempotency check
   local skip = false
@@ -3091,9 +3373,18 @@ for i, job in ipairs(jobs) do
       'deadLetteredAt', 'null',
       'deadLetterJobId', 'null',
       'groupId', groupId,
-      'groupTier', groupTier
+      'groupTier', groupTier,
+      'dependsOnJobIds', dependsOnJobIdsJson,
+      'dependsOnTags', dependsOnTagsJson
     )
 
+    if dependsOnJobIdsJson ~= "null" then
+      local depIds = cjson.decode(dependsOnJobIdsJson)
+      for _, parentId in ipairs(depIds) do
+        redis.call('SADD', prefix .. 'dep:' .. tostring(parentId), tostring(id))
+      end
+    end
+
     -- Status index
     redis.call('SADD', prefix .. 'status:pending', id)
 
@@ -3257,6 +3548,48 @@ for i = 1, #candidates, 2 do
           end
         end
 
+        if canClaim then
+          local depIdsJson = redis.call('HGET', jk, 'dependsOnJobIds')
+          local depTagsJson = redis.call('HGET', jk, 'dependsOnTags')
+          local depsOk = true
+          if depIdsJson and depIdsJson ~= 'null' then
+            local dids = cjson.decode(depIdsJson)
+            for _, pid in ipairs(dids) do
+              local pst = redis.call('HGET', prefix .. 'job:' .. pid, 'status')
+              if pst ~= 'completed' then depsOk = false break end
+            end
+          end
+          if depsOk and depTagsJson and depTagsJson ~= 'null' then
+            local req = cjson.decode(depTagsJson)
+            if #req > 0 then
+              for _, stname in ipairs({'pending','processing','waiting'}) do
+                local members = redis.call('SMEMBERS', prefix .. 'status:' .. stname)
+                for _, oid in ipairs(members) do
+                  if oid ~= jobId then
+                    local otags = redis.call('HGET', prefix .. 'job:' .. oid, 'tags')
+                    if otags and otags ~= 'null' then
+                      local oarr = cjson.decode(otags)
+                      local tagset = {}
+                      for _, t in ipairs(oarr) do tagset[t] = true end
+                      local all = true
+                      for _, rt in ipairs(req) do
+                        if not tagset[rt] then all = false break end
+                      end
+                      if all then depsOk = false break end
+                    end
+                  end
+                end
+                if not depsOk then break end
+              end
+            end
+          end
+          if not depsOk then
+            table.insert(putBack, score)
+            table.insert(putBack, jobId)
+            canClaim = false
+          end
+        end
+
         if canClaim then
           -- Claim this job
           local attempts = tonumber(redis.call('HGET', jk, 'attempts'))
@@ -3337,6 +3670,14 @@ if groupId and groupId ~= 'null' then
   end
 end
 
+local depIdsJson = redis.call('HGET', jk, 'dependsOnJobIds')
+if depIdsJson and depIdsJson ~= 'null' then
+  local dids = cjson.decode(depIdsJson)
+  for _, pid in ipairs(dids) do
+    redis.call('SREM', prefix .. 'dep:' .. tostring(pid), jobId)
+  end
+end
+
 return 1
 `;
 var FAIL_JOB_SCRIPT = `
@@ -3484,7 +3825,11 @@ if nextAttemptAt == 'null' and deadLetterJobType and deadLetterJobType ~= 'null'
     'retryDelayMax', 'null',
     'deadLetterJobType', 'null',
     'deadLetteredAt', 'null',
-    'deadLetterJobId', 'null'
+    'deadLetterJobId', 'null',
+    'dependsOnJobIds', 'null',
+    'dependsOnTags', 'null',
+    'groupId', 'null',
+    'groupTier', 'null'
   )
 
   redis.call('SADD', prefix .. 'status:pending', deadLetterJobId)
@@ -3499,6 +3844,14 @@ if nextAttemptAt == 'null' and deadLetterJobType and deadLetterJobType ~= 'null'
   )
 end
 
+local depIdsJsonFail = redis.call('HGET', jk, 'dependsOnJobIds')
+if depIdsJsonFail and depIdsJsonFail ~= 'null' then
+  local dids = cjson.decode(depIdsJsonFail)
+  for _, pid in ipairs(dids) do
+    redis.call('SREM', prefix .. 'dep:' .. tostring(pid), jobId)
+  end
+end
+
 return deadLetterJobId
 `;
 var RETRY_JOB_SCRIPT = `
@@ -3565,6 +3918,14 @@ redis.call('ZREM', prefix .. 'queue', jobId)
 redis.call('ZREM', prefix .. 'delayed', jobId)
 redis.call('ZREM', prefix .. 'waiting', jobId)
 
+local depIdsJsonCan = redis.call('HGET', jk, 'dependsOnJobIds')
+if depIdsJsonCan and depIdsJsonCan ~= 'null' then
+  local dids = cjson.decode(depIdsJsonCan)
+  for _, pid in ipairs(dids) do
+    redis.call('SREM', prefix .. 'dep:' .. tostring(pid), jobId)
+  end
+end
+
 return 1
 `;
 var PROLONG_JOB_SCRIPT = `
@@ -3916,9 +4277,29 @@ function deserializeJob(h) {
     deadLetterJobId: numOrNull(h.deadLetterJobId),
     groupId: nullish(h.groupId),
     groupTier: nullish(h.groupTier),
-    output: parseJsonField(h.output)
+    output: parseJsonField(h.output),
+    dependsOnJobIds: parseOptionalIntArray(h.dependsOnJobIds),
+    dependsOnTags: parseOptionalStringArray(h.dependsOnTags)
   };
 }
+function parseOptionalIntArray(raw) {
+  if (!raw || raw === "null") return null;
+  try {
+    const arr = JSON.parse(raw);
+    return Array.isArray(arr) && arr.length > 0 ? arr : null;
+  } catch {
+    return null;
+  }
+}
+function parseOptionalStringArray(raw) {
+  if (!raw || raw === "null") return null;
+  try {
+    const arr = JSON.parse(raw);
+    return Array.isArray(arr) && arr.length > 0 ? arr : null;
+  } catch {
+    return null;
+  }
+}
 function parseJsonField(raw) {
   if (!raw || raw === "null") return null;
   try {
@@ -3985,6 +4366,61 @@ var RedisBackend = class {
   nowMs() {
     return Date.now();
   }
+  /**
+   * Cancel pending/waiting jobs that depend on seed jobs (job id or tag), transitively.
+   *
+   * @param initialSeeds - Job ids that failed or were cancelled.
+   * @param rootJobId - Root id for event metadata.
+   */
+  async propagateDependencyCancellationsRedis(initialSeeds, rootJobId) {
+    const cancelled = /* @__PURE__ */ new Set();
+    let frontier = [...new Set(initialSeeds.filter((id) => id > 0))];
+    while (frontier.length > 0) {
+      const pendingRaw = await this.client.sunion(
+        `${this.prefix}status:pending`,
+        `${this.prefix}status:waiting`
+      );
+      const toCancel = [];
+      for (const pidStr of pendingRaw) {
+        const pid = Number(pidStr);
+        if (cancelled.has(pid)) continue;
+        const job = await this.getJob(pid);
+        if (!job || job.status !== "pending" && job.status !== "waiting") {
+          continue;
+        }
+        for (const seedId of frontier) {
+          if (pid === seedId) continue;
+          const seedJob = await this.getJob(seedId);
+          if (!seedJob) continue;
+          const byJobId = job.dependsOnJobIds?.includes(seedId) ?? false;
+          const byTag = job.dependsOnTags && job.dependsOnTags.length > 0 && tagsAreSuperset(seedJob.tags, job.dependsOnTags);
+          if (byJobId || byTag) {
+            toCancel.push(pid);
+            break;
+          }
+        }
+      }
+      if (toCancel.length === 0) break;
+      const now = this.nowMs();
+      for (const jid of toCancel) {
+        const ok = await this.client.eval(
+          CANCEL_JOB_SCRIPT,
+          1,
+          this.prefix,
+          jid,
+          now
+        );
+        if (Number(ok) === 1) {
+          cancelled.add(jid);
+          await this.recordJobEvent(jid, "cancelled" /* Cancelled */, {
+            rootJobId,
+            dependencyCascade: true
+          });
+        }
+      }
+      frontier = toCancel;
+    }
+  }
   // ── Events ──────────────────────────────────────────────────────────
   async recordJobEvent(jobId, eventType, metadata) {
     try {
@@ -4030,13 +4466,22 @@ var RedisBackend = class {
     retryBackoff = void 0,
     retryDelayMax = void 0,
     deadLetterJobType = void 0,
-    group = void 0
+    group = void 0,
+    dependsOn
   }, 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 { jobIds: depJobIdsRaw, tags: depTags } = normalizeDependsOn(dependsOn);
+    if (depJobIdsRaw?.some((id) => id < 0)) {
+      throw new Error(
+        "dependsOn.jobIds: batch-relative (negative) ids are only supported in addJobs()"
+      );
+    }
+    const dependsOnJobIdsJson = depJobIdsRaw && depJobIdsRaw.length > 0 ? JSON.stringify(depJobIdsRaw) : "null";
+    const dependsOnTagsJson = depTags && depTags.length > 0 ? JSON.stringify(depTags) : "null";
     const now = this.nowMs();
     const runAtMs = runAt ? runAt.getTime() : 0;
     const result = await this.client.eval(
@@ -4058,7 +4503,9 @@ var RedisBackend = class {
       retryDelayMax !== void 0 ? retryDelayMax.toString() : "null",
       deadLetterJobType ?? "null",
       group?.id ?? "null",
-      group?.tier ?? "null"
+      group?.tier ?? "null",
+      dependsOnJobIdsJson,
+      dependsOnTagsJson
     );
     const jobId = Number(result);
     log(
@@ -4068,7 +4515,8 @@ var RedisBackend = class {
       jobType,
       payload,
       tags,
-      idempotencyKey
+      idempotencyKey,
+      dependsOn: dependsOnJobIdsJson !== "null" || dependsOnTagsJson !== "null" ? dependsOn : void 0
     });
     return jobId;
   }
@@ -4083,24 +4531,58 @@ var RedisBackend = class {
         "The db option is not supported with the Redis backend. Transactional job creation is only available with PostgreSQL."
       );
     }
+    const needsSequential = jobs.some((j) => {
+      const n = normalizeDependsOn(j.dependsOn);
+      return Boolean(n.jobIds?.length || n.tags?.length);
+    });
+    if (needsSequential) {
+      const ids2 = [];
+      for (let i = 0; i < jobs.length; i++) {
+        let job = jobs[i];
+        const nd = normalizeDependsOn(job.dependsOn);
+        if (nd.jobIds?.some((id) => id < 0)) {
+          const resolvedJobIds = resolveDependsOnJobIdsForBatch(
+            nd.jobIds,
+            ids2
+          );
+          job = {
+            ...job,
+            dependsOn: {
+              jobIds: resolvedJobIds,
+              tags: job.dependsOn?.tags
+            }
+          };
+        }
+        ids2.push(await this.addJob(job));
+      }
+      log(
+        `Batch-inserted ${jobs.length} jobs (sequential), IDs: [${ids2.join(", ")}]`
+      );
+      return ids2;
+    }
     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",
-      deadLetterJobType: job.deadLetterJobType ?? "null",
-      groupId: job.group?.id ?? "null",
-      groupTier: job.group?.tier ?? "null"
-    }));
+    const jobsPayload = jobs.map((job) => {
+      const nd = normalizeDependsOn(job.dependsOn);
+      return {
+        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",
+        deadLetterJobType: job.deadLetterJobType ?? "null",
+        groupId: job.group?.id ?? "null",
+        groupTier: job.group?.tier ?? "null",
+        dependsOnJobIds: nd.jobIds?.length ? JSON.stringify(nd.jobIds) : null,
+        dependsOnTags: nd.tags?.length ? JSON.stringify(nd.tags) : null
+      };
+    });
     const result = await this.client.eval(
       ADD_JOBS_SCRIPT,
       1,
@@ -4270,6 +4752,7 @@ var RedisBackend = class {
       failureReason,
       deadLetterJobId
     });
+    await this.propagateDependencyCancellationsRedis([jobId], jobId);
     if (deadLetterJobId) {
       const sourceJob = await this.client.hget(
         `${this.prefix}job:${jobId}`,
@@ -4338,9 +4821,22 @@ var RedisBackend = class {
   }
   async cancelJob(jobId) {
     const now = this.nowMs();
-    await this.client.eval(CANCEL_JOB_SCRIPT, 1, this.prefix, jobId, now);
-    await this.recordJobEvent(jobId, "cancelled" /* Cancelled */);
-    log(`Cancelled job ${jobId}`);
+    const ok = await this.client.eval(
+      CANCEL_JOB_SCRIPT,
+      1,
+      this.prefix,
+      jobId,
+      now
+    );
+    if (Number(ok) === 1) {
+      await this.recordJobEvent(jobId, "cancelled" /* Cancelled */);
+      await this.propagateDependencyCancellationsRedis([jobId], jobId);
+      log(`Cancelled job ${jobId}`);
+    } else {
+      log(
+        `Job ${jobId} could not be cancelled (not in pending/waiting state or does not exist)`
+      );
+    }
   }
   async cancelAllUpcomingJobs(filters) {
     let ids = await this.client.smembers(`${this.prefix}status:pending`);
@@ -5667,6 +6163,6 @@ var withLogContext = (fn, verbose) => (...args) => {
   return fn(...args);
 };
 
-export { FailureReason, JobEventType, PostgresBackend, WaitSignal, getNextCronOccurrence, initJobQueue, testHandlerSerialization, validateCronExpression, validateHandlerSerializable2 as validateHandlerSerializable };
+export { FailureReason, JobEventType, PostgresBackend, WaitSignal, assertNoDependencyCycle, batchDepRef, getNextCronOccurrence, initJobQueue, normalizeDependsOn, resolveDependsOnJobIdsForBatch, tagsAreSuperset, testHandlerSerialization, validateCronExpression, validateHandlerSerializable2 as validateHandlerSerializable, validatePrerequisiteJobIdsExist };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map