effect-mq 0.2.0 → 0.3.0

package/dist/drizzle-postgres/DrizzleJobStore.js

@@ -17,7 +17,7 @@
  * @since 0.1.0
  */
 import * as JobStore from "../JobStore.js";
-import { asc, eq, sql } from "drizzle-orm";
+import { asc, eq, getTableColumns, sql } from "drizzle-orm";
 import * as PgDrizzle from "drizzle-orm/effect-postgres";
 import { getTableConfig } from "drizzle-orm/pg-core";
 import { Clock, Deferred, Duration, Effect, Layer, Option, Stream } from "effect";
@@ -55,6 +55,7 @@ const toRecord = (row) => ({
     keep: row.keep ?? undefined,
     timeoutMs: row.timeoutMs === null || row.timeoutMs === undefined ? undefined : Number(row.timeoutMs),
     cancelRequested: row.cancelRequested,
+    dedupeKey: row.dedupeKey ?? undefined,
     runAt: row.runAt.getTime(),
     enqueuedAt: row.enqueuedAt.getTime(),
     processedAt: row.processedAt?.getTime(),
@@ -75,51 +76,149 @@ export const make = (options) => Effect.gen(function* () {
     const attempts = options.attempts;
     const schedules = options.schedules;
     const queues = options.queues;
+    const dedupe = options.dedupe;
     const jobsName = getTableConfig(jobs).name;
     const attemptsName = getTableConfig(attempts).name;
     const wakeChannel = `effect_mq_wake_${jobsName}`;
+    // Columns the user added via `mqJobs({ extend })`: everything beyond the
+    // factory's own set. They are written at enqueue (and on dedupe replace)
+    // from `extraValues` or the metadata entry with the same TS key.
+    const BASE_JOB_COLUMNS = new Set([
+        "id",
+        "name",
+        "queue",
+        "state",
+        "priority",
+        "seq",
+        "payload",
+        "metadata",
+        "attemptsMax",
+        "attemptsMade",
+        "stalledCount",
+        "backoff",
+        "keep",
+        "timeoutMs",
+        "cancelRequested",
+        "dedupeKey",
+        "runAt",
+        "enqueuedAt",
+        "processedAt",
+        "finishedAt",
+        "exit",
+        "failedReason",
+        "lockToken",
+        "lockExpiresAt"
+    ]);
+    const extendedColumns = Object.entries(getTableColumns(jobs))
+        .filter(([key]) => !BASE_JOB_COLUMNS.has(key))
+        .map(([key, column]) => ({ key, name: column.name }));
+    const extraColumnNames = extendedColumns.length === 0
+        ? sql ``
+        : sql.join(extendedColumns.map((column) => sql `, ${sql.identifier(column.name)}`));
+    const extraColumnValues = (request) => {
+        if (extendedColumns.length === 0)
+            return sql ``;
+        const mapped = options.extraValues?.(request) ?? {};
+        return sql.join(extendedColumns.map((column) => sql `, ${Object.hasOwn(mapped, column.key) ? mapped[column.key] : request.metadata[column.key] ?? null}`));
+    };
+    const extraColumnAssignments = (request) => {
+        if (extendedColumns.length === 0)
+            return sql ``;
+        const mapped = options.extraValues?.(request) ?? {};
+        return sql.join(extendedColumns.map((column) => sql `, ${sql.identifier(column.name)} = ${Object.hasOwn(mapped, column.key) ? mapped[column.key] : request.metadata[column.key] ?? null}`));
+    };
     if (options.validate ?? true) {
         yield* Effect.all([
             db.select({ id: jobs.id }).from(jobs).limit(0),
             db.select({ jobId: attempts.jobId }).from(attempts).limit(0),
             db.select({ key: schedules.key }).from(schedules).limit(0),
-            db.select({ queue: queues.queue }).from(queues).limit(0)
+            db.select({ queue: queues.queue }).from(queues).limit(0),
+            db.select({ key: dedupe.key }).from(dedupe).limit(0)
         ]).pipe(Effect.mapError(storeError(`effect-mq: tables "${jobsName}"/"${attemptsName}" are missing or mismatched — ` +
             `re-export the effect-mq/drizzle schema factories from your drizzle schema and run your migrations (drizzle-kit generate)`)));
     }
-    // Wake plumbing: a local version + deferred chain (same protocol as the
+    // Wake plumbing: a queue-filtered waiter registry (same protocol as the
     // memory driver), fed by (a) local store operations and (b) cross-process
-    // LISTEN notifications.
+    // LISTEN notifications whose payload names the queue ("*" broadcasts).
+    // Filtering matters at scale: without it every enqueue wakes every idle
+    // taker of every queue on the store.
     let wakeVersion = 0;
-    let wake = Deferred.makeUnsafe();
-    const signalWake = () => {
+    let lastBroadcast = 0;
+    const lastWake = new Map();
+    const waiters = new Set();
+    const lastWakeFor = (queue) => Math.max(lastWake.get(queue) ?? 0, lastBroadcast);
+    const signalWake = (queue) => {
         wakeVersion += 1;
-        const current = wake;
-        wake = Deferred.makeUnsafe();
-        Deferred.doneUnsafe(current, Effect.void);
+        if (queue === undefined) {
+            lastBroadcast = wakeVersion;
+        }
+        else {
+            lastWake.set(queue, wakeVersion);
+        }
+        // Snapshot-and-clear BEFORE resolving: doneUnsafe resumes waiting
+        // fibers synchronously, and a woken taker that re-parks registers a
+        // NEW waiter — resolving inside the live Set iteration would visit it
+        // and livelock.
+        const toWake = [];
+        for (const waiter of waiters) {
+            if (queue === undefined || waiter.queues.has(queue)) {
+                waiters.delete(waiter);
+                toWake.push(waiter);
+            }
+        }
+        for (const waiter of toWake) {
+            Deferred.doneUnsafe(waiter.deferred, Effect.void);
+        }
     };
     // Resubscribe forever: if the LISTEN stream ends or fails, wake-ups
     // degrade to the worker's pollInterval until the next attempt succeeds.
-    yield* client.listen(wakeChannel).pipe(Stream.runForEach(() => Effect.sync(signalWake)), Effect.catchCause((cause) => Effect.logWarning("effect-mq: LISTEN subscription failed; wake-ups degraded to polling until resubscribe", cause)), Effect.andThen(Effect.sleep("1 second")), Effect.forever, Effect.forkScoped);
+    yield* client.listen(wakeChannel).pipe(Stream.runForEach((payload) => Effect.sync(() => signalWake(payload === "*" ? undefined : JobStore.QueueName(payload)))), Effect.catchCause((cause) => Effect.logWarning("effect-mq: LISTEN subscription failed; wake-ups degraded to polling until resubscribe", cause)), Effect.andThen(Effect.sleep("1 second")), Effect.forever, Effect.forkScoped);
     if (options.historyTtl !== undefined) {
-        const ttlMs = Duration.toMillis(options.historyTtl);
+        const ttlByState = JobStore.normalizeHistoryTtl(options.historyTtl);
         const sweepMs = Duration.toMillis(options.historySweepInterval ?? "1 minute");
         yield* Effect.gen(function* () {
             yield* Effect.sleep(sweepMs);
             const now = yield* nowDate;
+            // Per-state ceilings, refined by stricter per-row keep ages — a quiet
+            // job name is pruned on the timer, not only when its group is acked.
+            for (const state of ["completed", "failed", "cancelled"]) {
+                const ttl = ttlByState[state];
+                yield* db.execute(sql `
+            DELETE FROM ${jobs}
+            WHERE ${jobs.state} = ${state} AND (
+              ${ttl !== undefined ? sql `${jobs.finishedAt} <= ${new Date(now.getTime() - ttl)}` : sql `FALSE`}
+              OR (
+                COALESCE(
+                  ${jobs.keep}->${state}->>'ageMs',
+                  CASE WHEN ${jobs.keep} ?| array['completed', 'failed', 'cancelled'] THEN NULL
+                    ELSE ${jobs.keep}->>'ageMs' END
+                ) IS NOT NULL
+                AND ${jobs.finishedAt} <= ${now}::timestamptz
+                  - make_interval(secs => (COALESCE(
+                      ${jobs.keep}->${state}->>'ageMs',
+                      CASE WHEN ${jobs.keep} ?| array['completed', 'failed', 'cancelled'] THEN NULL
+                        ELSE ${jobs.keep}->>'ageMs' END
+                    )::double precision) / 1000.0))
+            )
+          `);
+            }
+            // Dead dedup rows: expired windows, or pointers at vanished jobs.
             yield* db.execute(sql `
-          DELETE FROM ${jobs}
-          WHERE ${jobs.state} IN ('completed', 'failed', 'cancelled')
-            AND ${jobs.finishedAt} <= ${new Date(now.getTime() - ttlMs)}
+          DELETE FROM ${dedupe}
+          WHERE (${dedupe.windowExpiresAt} IS NOT NULL AND ${dedupe.windowExpiresAt} <= ${now})
+             OR (${dedupe.windowExpiresAt} IS NULL AND NOT EXISTS (
+               SELECT 1 FROM ${jobs} WHERE ${jobs.id} = ${dedupe.jobId}
+                 AND ${jobs.state} IN ('waiting', 'delayed', 'active')
+             ))
         `);
         }).pipe(Effect.catchCause((cause) => Effect.logWarning("effect-mq: history sweep failed", cause)), Effect.forever, Effect.forkScoped);
     }
     // Local mutation wake-up: bump synchronously, then best-effort NOTIFY so
-    // workers in other processes wake promptly too.
-    const wakeUp = Effect.suspend(() => {
-        signalWake();
-        // The payload must be non-empty: @effect/sql-pg drops falsy payloads.
-        return client.notify(wakeChannel, "1").pipe(Effect.ignore);
+    // workers in other processes wake promptly too. The payload names the
+    // queue (and must be non-empty: @effect/sql-pg drops falsy payloads).
+    const wakeUp = (queue) => Effect.suspend(() => {
+        signalWake(queue);
+        return client.notify(wakeChannel, queue !== undefined && queue.length > 0 ? queue : "*").pipe(Effect.ignore);
     });
     const nowDate = Effect.map(Clock.currentTimeMillis, (ms) => new Date(ms));
     // quote_ident handles quoted/mixed-case table names safely.
@@ -131,9 +230,30 @@ export const make = (options) => Effect.gen(function* () {
         FROM ${attempts} WHERE ${attempts.jobId} = ${jobId}
       `);
     // Retention: drop terminal peers (same name + state) beyond count/age.
-    const applyKeep = (tx, row, now) => Effect.gen(function* () {
-        const keep = row.keep;
+    const keepPolicyFor = (keep, state) => {
         if (keep === null || keep === undefined)
+            return undefined;
+        const policy = state === "completed"
+            ? keep.completed
+            : state === "failed"
+                ? keep.failed
+                : state === "cancelled"
+                    ? keep.cancelled
+                    : undefined;
+        if (policy !== undefined)
+            return policy;
+        // Rows persisted by 0.2.x carry the flat {count, ageMs} shape — honour
+        // it as an all-states policy so upgrades keep pruning.
+        if (keep.completed === undefined && keep.failed === undefined && keep.cancelled === undefined &&
+            ("count" in keep || "ageMs" in keep)) {
+            // SAFETY: the flat legacy shape carries KeepStatePolicy fields.
+            return keep;
+        }
+        return undefined;
+    };
+    const applyKeep = (tx, row, now) => Effect.gen(function* () {
+        const keep = keepPolicyFor(row.keep, row.state);
+        if (keep === undefined)
             return;
         if (keep.ageMs !== undefined) {
             yield* tx.execute(sql `
@@ -159,52 +279,186 @@ export const make = (options) => Effect.gen(function* () {
     const explainMiss = (id) => db.select({ id: jobs.id }).from(jobs).where(eq(jobs.id, id)).pipe(Effect.mapError(storeError("failed to inspect job")), Effect.flatMap((rows) => Effect.fail(rows.length === 0
         ? new JobStore.JobNotFoundError({ jobId: id })
         : new JobStore.LockLostError({ jobId: id }))));
+    // The shared INSERT: store-assigned ids come from the configured
+    // generator (or the seq sequence); loop on the (unlikely) collision with
+    // an existing id — ON CONFLICT DO NOTHING makes the retry safe. Returns
+    // the result or undefined when the caller-supplied id already exists.
+    const insertJob = (exec, request, now) => Effect.gen(function* () {
+        const runAt = new Date(now.getTime() + Math.max(0, request.delayMs));
+        const state = request.delayMs > 0 ? "delayed" : "waiting";
+        const generate = options.idGenerator;
+        for (let i = 0; i < 5; i++) {
+            const generated = request.id === undefined && generate !== undefined
+                ? yield* Effect.suspend(() => {
+                    const raw = generate(request);
+                    return Effect.isEffect(raw) ? raw : Effect.succeed(raw);
+                })
+                : undefined;
+            const idExpr = request.id !== undefined
+                ? sql `${request.id}`
+                : generated !== undefined
+                    ? sql `${generated}`
+                    : sql `'j-' || ${seqExpr}::text`;
+            const rows = rowsOf(yield* exec.execute(sql `
+            INSERT INTO ${jobs} (id, name, queue, state, priority, payload, metadata,
+              attempts_max, backoff, keep, timeout_ms, dedupe_key, run_at, enqueued_at${extraColumnNames})
+            VALUES (${idExpr}, ${request.name}, ${request.queue}, ${state}, ${request.priority},
+              ${JSON.stringify(request.payload ?? null)}::jsonb, ${JSON.stringify(request.metadata)}::jsonb,
+              ${request.attemptsMax},
+              ${request.backoff === undefined ? null : JSON.stringify(request.backoff)}::jsonb,
+              ${request.keep === undefined ? null : JSON.stringify(request.keep)}::jsonb,
+              ${request.timeoutMs ?? null}, ${request.dedupe?.key ?? null}, ${runAt}, ${now}${extraColumnValues(request)})
+            ON CONFLICT (id) DO NOTHING
+            RETURNING ${jobs.id} AS id
+          `).pipe(Effect.mapError(storeError("enqueue failed"))));
+            const inserted = rows[0];
+            if (inserted !== undefined) {
+                return { id: JobId(inserted.id), duplicate: false };
+            }
+            if (request.id !== undefined) {
+                return { id: request.id, duplicate: true };
+            }
+            // generated id collided with an existing user id; try again
+        }
+        return yield* new JobStore.JobStoreError({
+            message: "enqueue failed: could not generate a unique job id"
+        });
+    });
+    // Enqueue with a dedup policy: one transaction locks the (name, key) row
+    // and applies the decision tree (replace-while-delayed, throttle window,
+    // pending dedup) before falling through to a fresh insert.
+    const enqueueDeduped = (request, policy) => db.transaction((tx) => Effect.gen(function* () {
+        const now = yield* nowDate;
+        // The explicit-id duplicate check precedes the dedup tree, matching
+        // the memory and redis drivers.
+        if (request.id !== undefined) {
+            const existing = rowsOf(yield* tx.execute(sql `
+              SELECT ${jobs.id} AS id FROM ${jobs} WHERE ${jobs.id} = ${request.id}
+            `));
+            if (existing.length > 0) {
+                return { id: request.id, duplicate: true, wake: false };
+            }
+        }
+        // A SELECT FOR UPDATE on a missing row locks nothing, so two
+        // concurrent first-enqueues would both insert. The no-op upsert
+        // always takes the row lock: a fresh placeholder (job_id = '')
+        // reads as "no entry" and falls through to the insert below.
+        const rows = rowsOf(yield* tx.execute(sql `
+            INSERT INTO ${dedupe} (name, key, job_id, window_expires_at)
+            VALUES (${request.name}, ${policy.key}, '', NULL)
+            ON CONFLICT (name, key) DO UPDATE SET name = EXCLUDED.name
+            RETURNING ${dedupe.jobId} AS "jobId", ${dedupe.windowExpiresAt} AS "windowExpiresAt"
+          `));
+        const entry = rows[0];
+        if (entry !== undefined && entry.jobId !== "") {
+            // Plain read (no FOR UPDATE): locking the job row here would
+            // invert the jobs-then-dedupe lock order every terminal
+            // transition uses and deadlock under load. The replace branch
+            // compensates with a state-conditional UPDATE.
+            const keyed = rowsOf(yield* tx.execute(sql `
+              SELECT ${jobs.state} AS state FROM ${jobs} WHERE ${jobs.id} = ${entry.jobId}
+            `));
+            const keyedState = keyed[0]?.state;
+            const windowLive = entry.windowExpiresAt !== null &&
+                entry.windowExpiresAt.getTime() > now.getTime();
+            const bumpWindow = policy.extend && policy.ttlMs !== undefined
+                ? tx.execute(sql `
+                UPDATE ${dedupe} SET window_expires_at = ${new Date(now.getTime() + policy.ttlMs)}
+                WHERE ${dedupe.name} = ${request.name} AND ${dedupe.key} = ${policy.key}
+              `).pipe(Effect.asVoid)
+                : Effect.void;
+            // Latest-wins while the keyed job is still delayed. The UPDATE
+            // re-checks the state so a concurrent claim degrades this to a
+            // plain dedup instead of rewriting an active job.
+            if (policy.replace && keyedState === "delayed") {
+                const replaced = rowsOf(yield* tx.execute(sql `
+                UPDATE ${jobs} SET
+                  payload = ${JSON.stringify(request.payload ?? null)}::jsonb,
+                  metadata = ${JSON.stringify(request.metadata)}::jsonb,
+                  priority = ${request.priority},
+                  attempts_max = ${request.attemptsMax},
+                  backoff = ${request.backoff === undefined ? null : JSON.stringify(request.backoff)}::jsonb,
+                  keep = ${request.keep === undefined ? null : JSON.stringify(request.keep)}::jsonb,
+                  timeout_ms = ${request.timeoutMs ?? null},
+                  run_at = ${new Date(now.getTime() + Math.max(0, request.delayMs))}${extraColumnAssignments(request)}
+                WHERE ${jobs.id} = ${entry.jobId} AND ${jobs.state} = 'delayed'
+                RETURNING ${jobs.id} AS id, ${jobs.queue} AS "queue"
+              `));
+                if (replaced.length > 0) {
+                    // A landed replace re-arms the ttl window (the entry must
+                    // outlive the chain it is deduplicating).
+                    if (policy.ttlMs !== undefined) {
+                        yield* tx.execute(sql `
+                    UPDATE ${dedupe} SET window_expires_at = ${new Date(now.getTime() + policy.ttlMs)}
+                    WHERE ${dedupe.name} = ${request.name} AND ${dedupe.key} = ${policy.key}
+                  `);
+                    }
+                    // The replace does not move the job between queues — wake
+                    // the queue that actually holds the now-rescheduled job.
+                    return {
+                        id: JobId(entry.jobId),
+                        duplicate: true,
+                        wake: true,
+                        wakeQueue: JobStore.QueueName(replaced[0]?.queue ?? request.queue)
+                    };
+                }
+                return { id: JobId(entry.jobId), duplicate: true, wake: false };
+            }
+            if (windowLive) {
+                yield* bumpWindow;
+                return { id: JobId(entry.jobId), duplicate: true, wake: false };
+            }
+            const pending = keyedState !== undefined && keyedState !== "completed" &&
+                keyedState !== "failed" && keyedState !== "cancelled";
+            if (entry.windowExpiresAt === null && pending) {
+                return { id: JobId(entry.jobId), duplicate: true, wake: false };
+            }
+            // Dead entry: the new job takes over the key below.
+        }
+        const result = yield* insertJob(tx, request, now);
+        if (!result.duplicate) {
+            yield* tx.execute(sql `
+              INSERT INTO ${dedupe} (name, key, job_id, window_expires_at)
+              VALUES (${request.name}, ${policy.key}, ${result.id},
+                ${policy.ttlMs === undefined ? null : new Date(now.getTime() + policy.ttlMs)})
+              ON CONFLICT (name, key) DO UPDATE SET
+                job_id = EXCLUDED.job_id, window_expires_at = EXCLUDED.window_expires_at
+            `);
+        }
+        return { ...result, wake: !result.duplicate };
+    })).pipe(
+    // Residual lock-order inversions (replace vs cancel of the same
+    // delayed job) surface as Postgres deadlocks (40P01); one side is
+    // killed and safe to retry.
+    Effect.retry({
+        times: 3,
+        while: (error) => String(error).includes("40P01") || String(error).includes("deadlock detected")
+    }), Effect.mapError((error) => error instanceof JobStore.JobStoreError ? error : storeError("enqueue failed")(error)));
+    // A job leaving the pending states frees its pending-mode dedup row; live
+    // throttle windows deliberately outlast the job.
+    const releaseDedupe = (exec, name, dedupeKey, jobId, now) => dedupeKey === null
+        ? Effect.void
+        : exec.execute(sql `
+          DELETE FROM ${dedupe}
+          WHERE ${dedupe.name} = ${name} AND ${dedupe.key} = ${dedupeKey}
+            AND ${dedupe.jobId} = ${jobId}
+            AND (${dedupe.windowExpiresAt} IS NULL OR ${dedupe.windowExpiresAt} <= ${now})
+        `).pipe(Effect.asVoid);
     const store = {
         enqueue: (request) => Effect.gen(function* () {
-            const now = yield* nowDate;
-            const runAt = new Date(now.getTime() + Math.max(0, request.delayMs));
-            const state = request.delayMs > 0 ? "delayed" : "waiting";
-            // Store-assigned ids come from the configured generator (or the
-            // seq sequence); loop on the (unlikely) collision with an existing
-            // id — ON CONFLICT DO NOTHING makes the retry safe.
-            const generate = options.idGenerator;
-            for (let i = 0; i < 5; i++) {
-                const generated = request.id === undefined && generate !== undefined
-                    ? yield* Effect.suspend(() => {
-                        const raw = generate(request);
-                        return Effect.isEffect(raw) ? raw : Effect.succeed(raw);
-                    })
-                    : undefined;
-                const idExpr = request.id !== undefined
-                    ? sql `${request.id}`
-                    : generated !== undefined
-                        ? sql `${generated}`
-                        : sql `'j-' || ${seqExpr}::text`;
-                const rows = rowsOf(yield* db.execute(sql `
-              INSERT INTO ${jobs} (id, name, queue, state, priority, payload, metadata,
-                attempts_max, backoff, keep, timeout_ms, run_at, enqueued_at)
-              VALUES (${idExpr}, ${request.name}, ${request.queue}, ${state}, ${request.priority},
-                ${JSON.stringify(request.payload ?? null)}::jsonb, ${JSON.stringify(request.metadata)}::jsonb,
-                ${request.attemptsMax},
-                ${request.backoff === undefined ? null : JSON.stringify(request.backoff)}::jsonb,
-                ${request.keep === undefined ? null : JSON.stringify(request.keep)}::jsonb,
-                ${request.timeoutMs ?? null}, ${runAt}, ${now})
-              ON CONFLICT (id) DO NOTHING
-              RETURNING ${jobs.id} AS id
-            `).pipe(Effect.mapError(storeError("enqueue failed"))));
-                const inserted = rows[0];
-                if (inserted !== undefined) {
-                    yield* wakeUp;
-                    return { id: JobId(inserted.id), duplicate: false };
-                }
-                if (request.id !== undefined) {
-                    return { id: request.id, duplicate: true };
+            if (request.dedupe !== undefined) {
+                const result = yield* enqueueDeduped(request, request.dedupe);
+                if (result.wake) {
+                    yield* wakeUp("wakeQueue" in result && result.wakeQueue !== undefined ? result.wakeQueue : request.queue);
                 }
-                // generated id collided with an existing user id; try again
+                return { id: result.id, duplicate: result.duplicate };
             }
-            return yield* new JobStore.JobStoreError({
-                message: "enqueue failed: could not generate a unique job id"
-            });
+            const now = yield* nowDate;
+            const result = yield* insertJob(db, request, now);
+            if (!result.duplicate) {
+                yield* wakeUp(request.queue);
+            }
+            return result;
         }),
         claim: (claimOptions) => Effect.suspend(() => {
             // Snapshot BEFORE the transaction: any wake that fires while the
@@ -244,7 +498,7 @@ export const make = (options) => Effect.gen(function* () {
                 ${jobs.attemptsMax} AS "attemptsMax", ${jobs.attemptsMade} AS "attemptsMade",
                 ${jobs.stalledCount} AS "stalledCount", ${jobs.backoff} AS "backoff",
                 ${jobs.keep} AS "keep", ${jobs.timeoutMs} AS "timeoutMs",
-                ${jobs.cancelRequested} AS "cancelRequested",
+                ${jobs.cancelRequested} AS "cancelRequested", ${jobs.dedupeKey} AS "dedupeKey",
                 ${jobs.runAt} AS "runAt", ${jobs.enqueuedAt} AS "enqueuedAt",
                 ${jobs.processedAt} AS "processedAt", ${jobs.finishedAt} AS "finishedAt",
                 ${jobs.exit} AS "exit", ${jobs.failedReason} AS "failedReason"
@@ -289,7 +543,8 @@ export const make = (options) => Effect.gen(function* () {
                 attempts_made = ${jobs.attemptsMade} + 1, lock_token = NULL, lock_expires_at = NULL
               WHERE ${jobs.id} = ${id} AND ${jobs.state} = 'active' AND ${jobs.lockToken} = ${token}
               RETURNING ${jobs.processedAt} AS "processedAt", ${jobs.name} AS "name",
-                ${jobs.state} AS "state", ${jobs.keep} AS "keep"
+                ${jobs.state} AS "state", ${jobs.keep} AS "keep", ${jobs.dedupeKey} AS "dedupeKey",
+                ${jobs.queue} AS "queue"
             `));
             const row = rows[0];
             if (row === undefined) {
@@ -305,14 +560,18 @@ export const make = (options) => Effect.gen(function* () {
                         : "retried";
             yield* insertAttempt(tx, id, ledgerOutcome, row.processedAt, now, outcome._tag === "Cancelled" || cancelledRetry ? undefined : outcome.exit);
             if (outcome._tag !== "Retry" || cancelledRetry) {
+                yield* releaseDedupe(tx, row.name, row.dedupeKey, id, now);
                 yield* applyKeep(tx, row, now);
             }
+            return outcome._tag === "Retry" && !cancelledRetry
+                ? JobStore.QueueName(row.queue)
+                : undefined;
         })).pipe(Effect.mapError((error) => error instanceof JobStore.JobNotFoundError || error instanceof JobStore.LockLostError ||
             error instanceof JobStore.JobStoreError
             ? error
-            : storeError("ack failed")(error)), Effect.tap(() => outcome._tag === "Retry" ? wakeUp : Effect.void)),
+            : storeError("ack failed")(error)), Effect.tap((queue) => queue !== undefined ? wakeUp(queue) : Effect.void), Effect.asVoid),
         release: (id, token) => Effect.gen(function* () {
-            const cancelled = yield* db.transaction((tx) => Effect.gen(function* () {
+            const released = yield* db.transaction((tx) => Effect.gen(function* () {
                 const now = yield* nowDate;
                 // A cancel that arrived while the worker was shutting down is
                 // honoured instead of reviving the job.
@@ -324,22 +583,24 @@ export const make = (options) => Effect.gen(function* () {
                   lock_token = NULL, lock_expires_at = NULL
                 WHERE ${jobs.id} = ${id} AND ${jobs.state} = 'active' AND ${jobs.lockToken} = ${token}
                 RETURNING ${jobs.id} AS id, (${jobs.state} = 'cancelled') AS cancelled,
-                  ${jobs.processedAt} AS "processedAt", ${jobs.name} AS "name", ${jobs.keep} AS "keep"
+                  ${jobs.processedAt} AS "processedAt", ${jobs.name} AS "name", ${jobs.keep} AS "keep",
+                  ${jobs.dedupeKey} AS "dedupeKey", ${jobs.queue} AS "queue"
               `));
                 const row = rows[0];
                 if (row === undefined)
                     return undefined;
                 if (row.cancelled) {
                     yield* insertAttempt(tx, id, "cancelled", row.processedAt, now, undefined);
+                    yield* releaseDedupe(tx, row.name, row.dedupeKey, id, now);
                     yield* applyKeep(tx, { name: row.name, state: "cancelled", keep: row.keep }, now);
                 }
-                return row.cancelled;
+                return { cancelled: row.cancelled, queue: JobStore.QueueName(row.queue) };
             })).pipe(Effect.mapError((error) => error instanceof JobStore.JobStoreError ? error : storeError("release failed")(error)));
-            if (cancelled === undefined) {
+            if (released === undefined) {
                 return yield* explainMiss(id);
             }
-            if (!cancelled) {
-                yield* wakeUp;
+            if (!released.cancelled) {
+                yield* wakeUp(released.queue);
             }
         }),
         extendLocks: (locks, durationMs) => Effect.gen(function* () {
@@ -399,11 +660,14 @@ export const make = (options) => Effect.gen(function* () {
                 cancel_requested = FALSE
               WHERE ${jobs.state} = 'active' AND ${jobs.lockExpiresAt} <= ${now}::timestamptz
               RETURNING ${jobs.id} AS "id", ${jobs.state} AS "state", ${jobs.processedAt} AS "processedAt",
-                ${jobs.name} AS "name", ${jobs.keep} AS "keep"
+                ${jobs.name} AS "name", ${jobs.keep} AS "keep", ${jobs.dedupeKey} AS "dedupeKey"
             `));
             const recovered = [];
             for (const row of rows) {
                 yield* insertAttempt(tx, row.id, row.state === "cancelled" ? "cancelled" : "stalled", row.processedAt, now, undefined);
+                if (row.state === "cancelled" || row.state === "failed") {
+                    yield* releaseDedupe(tx, row.name, row.dedupeKey, row.id, now);
+                }
                 if (row.state === "cancelled") {
                     yield* applyKeep(tx, { name: row.name, state: "cancelled", keep: row.keep }, now);
                 }
@@ -412,11 +676,13 @@ export const make = (options) => Effect.gen(function* () {
                 }
             }
             return recovered;
-        })).pipe(Effect.mapError((error) => error instanceof JobStore.JobStoreError ? error : storeError("recoverStalled failed")(error)), Effect.tap((recovered) => recovered.some((entry) => !entry.failed) ? wakeUp : Effect.void)),
-        awaitWake: (_queues, wakeToken) => Effect.suspend(() => {
-            if (wakeVersion > wakeToken)
+        })).pipe(Effect.mapError((error) => error instanceof JobStore.JobStoreError ? error : storeError("recoverStalled failed")(error)), Effect.tap((recovered) => recovered.some((entry) => !entry.failed) ? wakeUp() : Effect.void)),
+        awaitWake: (queues, wakeToken) => Effect.suspend(() => {
+            if (queues.some((queue) => lastWakeFor(queue) > wakeToken))
                 return Effect.void;
-            return Deferred.await(wake);
+            const waiter = { queues: new Set(queues), deferred: Deferred.makeUnsafe() };
+            waiters.add(waiter);
+            return Deferred.await(waiter.deferred).pipe(Effect.ensuring(Effect.sync(() => waiters.delete(waiter))));
         }),
         getJob: (id) => db.select().from(jobs).where(eq(jobs.id, id)).pipe(Effect.mapError(storeError("getJob failed")), Effect.map((rows) => {
             const row = rows[0];
@@ -483,7 +749,7 @@ export const make = (options) => Effect.gen(function* () {
               exit = NULL, failed_reason = NULL, finished_at = NULL, processed_at = NULL,
               run_at = ${now}, seq = ${seqExpr}
             WHERE ${jobs.id} = ${id} AND ${jobs.state} = 'failed'
-            RETURNING ${jobs.id} AS id
+            RETURNING ${jobs.id} AS id, ${jobs.queue} AS "queue"
           `).pipe(Effect.mapError(storeError("retry failed"))));
             if (rows.length === 0) {
                 const existing = yield* db.select({ state: jobs.state }).from(jobs)
@@ -494,7 +760,7 @@ export const make = (options) => Effect.gen(function* () {
                 }
                 return yield* new JobStore.JobNotRetryableError({ jobId: id, state: found.state });
             }
-            yield* wakeUp;
+            yield* wakeUp(JobStore.QueueName(rows[0]?.queue ?? ""));
         }),
         cancel: (id) => db.transaction((tx) => Effect.gen(function* () {
             const now = yield* nowDate;
@@ -507,7 +773,8 @@ export const make = (options) => Effect.gen(function* () {
                 cancel_requested = CASE WHEN ${jobs.state} = 'active' THEN TRUE ELSE ${jobs.cancelRequested} END
               WHERE ${jobs.id} = ${id} AND ${jobs.state} IN ('waiting', 'delayed', 'active')
               RETURNING ${jobs.id} AS id, ${jobs.state} AS state,
-                ${jobs.processedAt} AS "processedAt", ${jobs.name} AS "name", ${jobs.keep} AS "keep"
+                ${jobs.processedAt} AS "processedAt", ${jobs.name} AS "name", ${jobs.keep} AS "keep",
+                ${jobs.dedupeKey} AS "dedupeKey"
             `));
             const row = rows[0];
             if (row === undefined) {
@@ -522,6 +789,7 @@ export const make = (options) => Effect.gen(function* () {
             }
             if (row.state === "cancelled") {
                 yield* insertAttempt(tx, id, "cancelled", row.processedAt, now, undefined);
+                yield* releaseDedupe(tx, row.name, row.dedupeKey, id, now);
                 yield* applyKeep(tx, { name: row.name, state: "cancelled", keep: row.keep }, now);
             }
         })).pipe(Effect.mapError((error) => error instanceof JobStore.JobNotFoundError ||
@@ -534,7 +802,7 @@ export const make = (options) => Effect.gen(function* () {
             const rows = rowsOf(yield* db.execute(sql `
             UPDATE ${jobs} SET state = 'waiting', run_at = ${now}
             WHERE ${jobs.id} = ${id} AND ${jobs.state} = 'delayed'
-            RETURNING ${jobs.id} AS id
+            RETURNING ${jobs.id} AS id, ${jobs.queue} AS "queue"
           `).pipe(Effect.mapError(storeError("promote failed"))));
             if (rows.length === 0) {
                 const existing = rowsOf(yield* db.execute(sql `
@@ -546,7 +814,7 @@ export const make = (options) => Effect.gen(function* () {
                 }
                 return yield* new JobStore.JobNotPromotableError({ jobId: id, state: found.state });
             }
-            yield* wakeUp;
+            yield* wakeUp(JobStore.QueueName(rows[0]?.queue ?? ""));
         }),
         pause: (queue) => db.execute(sql `
           INSERT INTO ${queues} (queue, paused) VALUES (${queue}, TRUE)
@@ -554,7 +822,7 @@ export const make = (options) => Effect.gen(function* () {
         `).pipe(Effect.mapError(storeError("pause failed")), Effect.asVoid),
         resume: (queue) => db.execute(sql `
           UPDATE ${queues} SET paused = FALSE WHERE ${queues.queue} = ${queue}
-        `).pipe(Effect.mapError(storeError("resume failed")), Effect.andThen(wakeUp)),
+        `).pipe(Effect.mapError(storeError("resume failed")), Effect.andThen(wakeUp(queue))),
         pausedQueues: () => db.execute(sql `
           SELECT ${queues.queue} AS queue FROM ${queues} WHERE ${queues.paused} = TRUE
         `).pipe(Effect.mapError(storeError("pausedQueues failed")), Effect.map((result) => rowsOf(result).map((row) => JobStore.QueueName(row.queue)))),
@@ -580,7 +848,7 @@ export const make = (options) => Effect.gen(function* () {
                 AND ${schedules.everyMs} IS NOT DISTINCT FROM EXCLUDED.every_ms
               THEN ${schedules.nextRunAt}
               ELSE EXCLUDED.next_run_at END
-        `).pipe(Effect.mapError(storeError("upsertSchedule failed")), Effect.asVoid),
+        `).pipe(Effect.mapError(storeError("upsertSchedule failed")), Effect.andThen(wakeUp(schedule.queue))),
         removeSchedule: (key) => db.execute(sql `
           DELETE FROM ${schedules} WHERE ${schedules.key} = ${key}
           RETURNING ${schedules.key} AS key