effect-mq 0.2.0 → 0.3.0

package/src/drizzle-postgres/schema.ts

@@ -7,13 +7,23 @@
  *
  * ```ts
  * // schema.ts
- * import { mqJobAttempts, mqJobs } from "effect-mq/drizzle"
+ * import { mqJobAttempts, mqJobs } from "effect-mq/drizzle-postgres"
  *
  * type DurableJobs = typeof GenerateInvoice._tag | typeof GenerateReport._tag
  * export const jobs = mqJobs<DurableJobs>()
  * export const jobAttempts = mqJobAttempts(jobs)
  * ```
  *
+ * Every factory accepts an `extraConfig` callback — the same shape as
+ * drizzle's own third `pgTable` argument — to add your own indexes (or
+ * checks/policies) on top of the built-in ones:
+ *
+ * ```ts
+ * export const jobs = mqJobs<DurableJobs>("effect_mq_jobs", {
+ *   extraConfig: (t) => [index("jobs_name_recent_idx").on(t.name, t.enqueuedAt.desc())]
+ * })
+ * ```
+ *
  * Then `drizzle-kit generate` emits the CREATE TABLE migrations into your
  * pipeline like any other table. Reads through drizzle are encouraged;
  * writes must go through the `JobStore` (e.g. `store.retry`) so locking and
@@ -23,7 +33,20 @@
  */
 import type * as JobStore from "../JobStore.ts"
 import { sql } from "drizzle-orm"
-import { bigint, boolean, index, integer, jsonb, pgTable, primaryKey, text, timestamp } from "drizzle-orm/pg-core"
+import {
+  type AnyPgColumnBuilder,
+  bigint,
+  boolean,
+  index,
+  integer,
+  jsonb,
+  type PgBuildExtraConfigColumns,
+  pgTable,
+  type PgTableExtraConfigValue,
+  primaryKey,
+  text,
+  timestamp
+} from "drizzle-orm/pg-core"
 
 type JobId = JobStore.JobId
 type QueueName = JobStore.QueueName
@@ -32,40 +55,86 @@ type JobState = JobStore.JobState
 type BackoffPolicy = JobStore.BackoffPolicy
 type KeepPolicy = JobStore.KeepPolicy
 type AttemptOutcome = JobStore.AttemptRecord["outcome"]
+
+/**
+ * Table-factory options: `extraConfig` receives the table's columns (exactly
+ * like drizzle's third `pgTable` argument) and returns additional indexes,
+ * checks, or policies, appended after the built-in ones.
+ *
+ * @since 0.2.1
+ */
+export interface MqTableOptions<Columns extends Record<string, AnyPgColumnBuilder>> {
+  readonly extraConfig?:
+    | ((table: PgBuildExtraConfigColumns<Columns>) => Array<PgTableExtraConfigValue>)
+    | undefined
+}
+
+const jobsColumns = <JobName extends string>() => ({
+  id: text("id").primaryKey().$type<JobId>(),
+  name: text("name").notNull().$type<JobName>(),
+  queue: text("queue").notNull().$type<QueueName>(),
+  state: text("state").notNull().$type<JobState>(),
+  priority: integer("priority").notNull().default(0),
+  /** FIFO order within a priority; bumped on retry so retries go to the tail. */
+  seq: bigint("seq", { mode: "number" }).notNull().generatedByDefaultAsIdentity(),
+  payload: jsonb("payload"),
+  metadata: jsonb("metadata").notNull().default({}).$type<Record<string, string>>(),
+  attemptsMax: integer("attempts_max").notNull(),
+  attemptsMade: integer("attempts_made").notNull().default(0),
+  stalledCount: integer("stalled_count").notNull().default(0),
+  backoff: jsonb("backoff").$type<BackoffPolicy>(),
+  keep: jsonb("keep").$type<KeepPolicy>(),
+  timeoutMs: bigint("timeout_ms", { mode: "number" }),
+  cancelRequested: boolean("cancel_requested").notNull().default(false),
+  dedupeKey: text("dedupe_key"),
+  runAt: timestamp("run_at", { withTimezone: true, mode: "date" }).notNull(),
+  enqueuedAt: timestamp("enqueued_at", { withTimezone: true, mode: "date" }).notNull(),
+  processedAt: timestamp("processed_at", { withTimezone: true, mode: "date" }),
+  finishedAt: timestamp("finished_at", { withTimezone: true, mode: "date" }),
+  exit: jsonb("exit"),
+  failedReason: text("failed_reason"),
+  lockToken: text("lock_token"),
+  lockExpiresAt: timestamp("lock_expires_at", { withTimezone: true, mode: "date" })
+})
+
 /**
  * The jobs table factory. `JobName` types the `name` column — derive it from
  * your job definitions: `mqJobs<typeof GenerateInvoice._tag | typeof Report._tag>()`.
  *
+ * `extend` adds your own columns (tenant ids, object ids, ...) to the table.
+ * At enqueue the Postgres store fills each extended column from the job's
+ * `metadata` entry with the same TS key (NULL when absent); override the
+ * mapping with the store's `extraValues` option. Extended columns are yours
+ * to read with plain drizzle queries — FKs, RLS policies, and `extraConfig`
+ * indexes all work:
+ *
+ * ```ts
+ * export const jobs = mqJobs<JobNames>("effect_mq_jobs", {
+ *   extend: {
+ *     companyId: text("company_id").notNull(),
+ *     objectId: text("object_id")
+ *   },
+ *   extraConfig: (t) => [index("jobs_company_idx").on(t.companyId, t.state)]
+ * })
+ * ```
+ *
  * @since 0.1.0
  */
-export const mqJobs = <JobName extends string = string>(
-  tableName = "effect_mq_jobs"
+export const mqJobs = <
+  JobName extends string = string,
+  Extend extends Record<string, AnyPgColumnBuilder> = Record<never, never>
+>(
+  tableName = "effect_mq_jobs",
+  options?: MqTableOptions<ReturnType<typeof jobsColumns<JobName>> & Extend> & {
+    /** Extra columns appended to the factory's own (see the JSDoc example). */
+    readonly extend?: Extend | undefined
+  }
 ) =>
   pgTable(tableName, {
-    id: text("id").primaryKey().$type<JobId>(),
-    name: text("name").notNull().$type<JobName>(),
-    queue: text("queue").notNull().$type<QueueName>(),
-    state: text("state").notNull().$type<JobState>(),
-    priority: integer("priority").notNull().default(0),
-    /** FIFO order within a priority; bumped on retry so retries go to the tail. */
-    seq: bigint("seq", { mode: "number" }).notNull().generatedByDefaultAsIdentity(),
-    payload: jsonb("payload"),
-    metadata: jsonb("metadata").notNull().default({}).$type<Record<string, string>>(),
-    attemptsMax: integer("attempts_max").notNull(),
-    attemptsMade: integer("attempts_made").notNull().default(0),
-    stalledCount: integer("stalled_count").notNull().default(0),
-    backoff: jsonb("backoff").$type<BackoffPolicy>(),
-    keep: jsonb("keep").$type<KeepPolicy>(),
-    timeoutMs: bigint("timeout_ms", { mode: "number" }),
-    cancelRequested: boolean("cancel_requested").notNull().default(false),
-    runAt: timestamp("run_at", { withTimezone: true, mode: "date" }).notNull(),
-    enqueuedAt: timestamp("enqueued_at", { withTimezone: true, mode: "date" }).notNull(),
-    processedAt: timestamp("processed_at", { withTimezone: true, mode: "date" }),
-    finishedAt: timestamp("finished_at", { withTimezone: true, mode: "date" }),
-    exit: jsonb("exit"),
-    failedReason: text("failed_reason"),
-    lockToken: text("lock_token"),
-    lockExpiresAt: timestamp("lock_expires_at", { withTimezone: true, mode: "date" })
+    ...jobsColumns<JobName>(),
+    // SAFETY: when `extend` is absent, `Extend` was never inferred from a
+    // value and stays at its empty-record default, which {} satisfies.
+    ...options?.extend ?? ({} as Extend)
   }, (table) => [
     // Claim path: pop highest priority, FIFO within it.
     index(`${tableName}_ready_idx`)
@@ -79,14 +148,24 @@ export const mqJobs = <JobName extends string = string>(
     index(`${tableName}_active_idx`)
       .on(table.lockExpiresAt)
       .where(sql`${table.state} = 'active'`),
-    // History/retention queries.
+    // History/retention queries (leading `name` also serves name-only filters).
     index(`${tableName}_history_idx`).on(table.name, table.state, table.finishedAt),
     // Listing (newest first, keyset pagination).
     index(`${tableName}_listing_idx`).on(table.enqueuedAt.desc(), table.id.desc()),
     // Metadata containment queries.
-    index(`${tableName}_metadata_idx`).using("gin", table.metadata.op("jsonb_path_ops"))
+    index(`${tableName}_metadata_idx`).using("gin", table.metadata.op("jsonb_path_ops")),
+    ...options?.extraConfig?.(table) ?? []
   ])
 
+const attemptsColumns = (jobs: MqJobsTable) => ({
+  jobId: text("job_id").notNull().references(() => jobs.id, { onDelete: "cascade" }).$type<JobId>(),
+  attempt: integer("attempt").notNull(),
+  outcome: text("outcome").notNull().$type<AttemptOutcome>(),
+  startedAt: timestamp("started_at", { withTimezone: true, mode: "date" }),
+  finishedAt: timestamp("finished_at", { withTimezone: true, mode: "date" }).notNull(),
+  exit: jsonb("exit")
+})
+
 /**
  * The job run-ledger table factory (one row per attempt, including
  * successes and stall recoveries).
@@ -95,54 +174,84 @@ export const mqJobs = <JobName extends string = string>(
  */
 export const mqJobAttempts = (
   jobs: ReturnType<typeof mqJobs<any>>,
-  tableName = "effect_mq_job_attempts"
+  tableName = "effect_mq_job_attempts",
+  options?: MqTableOptions<ReturnType<typeof attemptsColumns>>
 ) =>
-  pgTable(tableName, {
-    jobId: text("job_id").notNull().references(() => jobs.id, { onDelete: "cascade" }).$type<JobId>(),
-    attempt: integer("attempt").notNull(),
-    outcome: text("outcome").notNull().$type<AttemptOutcome>(),
-    startedAt: timestamp("started_at", { withTimezone: true, mode: "date" }),
-    finishedAt: timestamp("finished_at", { withTimezone: true, mode: "date" }).notNull(),
-    exit: jsonb("exit")
-  }, (table) => [
-    primaryKey({ columns: [table.jobId, table.attempt] })
+  pgTable(tableName, attemptsColumns(jobs), (table) => [
+    primaryKey({ columns: [table.jobId, table.attempt] }),
+    ...options?.extraConfig?.(table) ?? []
   ])
 
+const schedulesColumns = () => ({
+  key: text("key").primaryKey().$type<ScheduleKey>(),
+  jobName: text("job_name").notNull(),
+  queue: text("queue").notNull().$type<QueueName>(),
+  cron: text("cron"),
+  tz: text("tz"),
+  everyMs: bigint("every_ms", { mode: "number" }),
+  payload: jsonb("payload"),
+  metadata: jsonb("metadata").notNull().default({}).$type<Record<string, string>>(),
+  priority: integer("priority").notNull().default(0),
+  attemptsMax: integer("attempts_max").notNull(),
+  backoff: jsonb("backoff").$type<BackoffPolicy>(),
+  keep: jsonb("keep").$type<KeepPolicy>(),
+  timeoutMs: bigint("timeout_ms", { mode: "number" }),
+  nextRunAt: timestamp("next_run_at", { withTimezone: true, mode: "date" }).notNull()
+})
+
 /**
  * Repeatable-job schedules (one row per `Job.schedule` key).
  *
  * @since 0.2.0
  */
-export const mqSchedules = (tableName = "effect_mq_schedules") =>
-  pgTable(tableName, {
-    key: text("key").primaryKey().$type<ScheduleKey>(),
-    jobName: text("job_name").notNull(),
-    queue: text("queue").notNull().$type<QueueName>(),
-    cron: text("cron"),
-    tz: text("tz"),
-    everyMs: bigint("every_ms", { mode: "number" }),
-    payload: jsonb("payload"),
-    metadata: jsonb("metadata").notNull().default({}).$type<Record<string, string>>(),
-    priority: integer("priority").notNull().default(0),
-    attemptsMax: integer("attempts_max").notNull(),
-    backoff: jsonb("backoff").$type<BackoffPolicy>(),
-    keep: jsonb("keep").$type<KeepPolicy>(),
-    timeoutMs: bigint("timeout_ms", { mode: "number" }),
-    nextRunAt: timestamp("next_run_at", { withTimezone: true, mode: "date" }).notNull()
-  }, (table) => [
-    index(`${tableName}_due_idx`).on(table.nextRunAt)
+export const mqSchedules = (
+  tableName = "effect_mq_schedules",
+  options?: MqTableOptions<ReturnType<typeof schedulesColumns>>
+) =>
+  pgTable(tableName, schedulesColumns(), (table) => [
+    index(`${tableName}_due_idx`).on(table.nextRunAt),
+    ...options?.extraConfig?.(table) ?? []
   ])
 
+const dedupeColumns = () => ({
+  name: text("name").notNull(),
+  key: text("key").notNull(),
+  jobId: text("job_id").notNull().$type<JobId>(),
+  /** Set for ttl/throttle windows; NULL rows live as long as their job is pending. */
+  windowExpiresAt: timestamp("window_expires_at", { withTimezone: true, mode: "date" })
+})
+
+/**
+ * Dedup-key registry (one row per job name + dedup key; see `DedupePolicy`).
+ *
+ * @since 0.3.0
+ */
+export const mqDedupe = (
+  tableName = "effect_mq_dedupe",
+  options?: MqTableOptions<ReturnType<typeof dedupeColumns>>
+) =>
+  pgTable(tableName, dedupeColumns(), (table) => [
+    primaryKey({ columns: [table.name, table.key] }),
+    ...options?.extraConfig?.(table) ?? []
+  ])
+
+const queueControlColumns = () => ({
+  queue: text("queue").primaryKey().$type<QueueName>(),
+  paused: boolean("paused").notNull().default(false)
+})
+
 /**
  * Durable queue control flags (pause/resume).
  *
  * @since 0.2.0
  */
-export const mqQueueControl = (tableName = "effect_mq_queue_control") =>
-  pgTable(tableName, {
-    queue: text("queue").primaryKey().$type<QueueName>(),
-    paused: boolean("paused").notNull().default(false)
-  })
+export const mqQueueControl = (
+  tableName = "effect_mq_queue_control",
+  options?: MqTableOptions<ReturnType<typeof queueControlColumns>>
+) =>
+  pgTable(tableName, queueControlColumns(), (table) => [
+    ...options?.extraConfig?.(table) ?? []
+  ])
 
 /**
  * @since 0.1.0
@@ -163,3 +272,8 @@ export type MqSchedulesTable = ReturnType<typeof mqSchedules>
  * @since 0.2.0
  */
 export type MqQueueControlTable = ReturnType<typeof mqQueueControl>
+
+/**
+ * @since 0.3.0
+ */
+export type MqDedupeTable = ReturnType<typeof mqDedupe>

package/src/redis/RedisJobStore.ts

@@ -25,9 +25,11 @@ export interface RedisJobStoreOptions {
   readonly prefix?: string | undefined
   /**
    * Store-level retention ceiling: terminal records older than this are
-   * removed by a periodic sweep. Per-job `keep` may only be stricter.
+   * removed by a periodic sweep — one duration for all terminal states or a
+   * per-state split (`{ completed: "1 day", failed: "30 days" }`). The sweep
+   * also honours stricter per-job `keep.age` rules.
    */
-  readonly historyTtl?: Duration.Input | undefined
+  readonly historyTtl?: JobStore.HistoryTtlInput | undefined
   /** History sweep cadence (default 1 minute). */
   readonly historySweepInterval?: Duration.Input | undefined
   /**
@@ -81,6 +83,7 @@ const toRecord = (hash: ReadonlyMap<string, string>): JobStore.JobRecord => ({
   keep: optionalJson<JobStore.KeepPolicy>(hash.get("keep")),
   timeoutMs: optionalNumber(hash.get("timeoutMs")),
   cancelRequested: hash.get("cancelRequested") === "1",
+  dedupeKey: optionalString(hash.get("dedupeKey")),
   runAt: Number(hash.get("runAt") ?? 0),
   enqueuedAt: Number(hash.get("enqueuedAt") ?? 0),
   processedAt: optionalNumber(hash.get("processedAt")),
@@ -151,23 +154,52 @@ export const make = (
     const evalListSchedules = redis.eval(scripts.listSchedules)
     const evalDueSchedules = redis.eval(scripts.dueSchedules)
     const evalAdvanceSchedule = redis.eval(scripts.advanceSchedule)
-    const evalSweepHistory = redis.eval(scripts.sweepHistory)
+    const evalSweepState = redis.eval(scripts.sweepState)
+    const evalSweepDedupes = redis.eval(scripts.sweepDedupes)
 
-    // Wake protocol: a local version + Deferred chain (same-process wake-ups
+    // Wake protocol: a queue-filtered waiter registry (same-process wake-ups
     // never depend on the pub/sub round trip), with the channel carrying
-    // cross-process wake-ups. Same shape as the Postgres driver's NOTIFY.
+    // cross-process wake-ups — the message 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<void>()
-    const signalWakeLocal = () => {
+    let lastBroadcast = 0
+    const lastWake = new Map<JobStore.QueueName, number>()
+    interface Waiter {
+      readonly queues: ReadonlySet<JobStore.QueueName>
+      readonly deferred: Deferred.Deferred<void>
+    }
+    const waiters = new Set<Waiter>()
+    const lastWakeFor = (queue: JobStore.QueueName) => Math.max(lastWake.get(queue) ?? 0, lastBroadcast)
+    const signalWakeLocal = (queue?: JobStore.QueueName) => {
       wakeVersion += 1
-      const current = wake
-      wake = Deferred.makeUnsafe<void>()
-      Deferred.doneUnsafe(current, Exit.succeed<void>(void 0))
+      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: Array<Waiter> = []
+      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, Exit.succeed<void>(void 0))
+      }
     }
-    const wakeUp = Effect.suspend(() => {
-      signalWakeLocal()
-      return redis.send("PUBLISH", wakeChannel, "1").pipe(Effect.ignore)
-    })
+    const wakeUp = (queue?: JobStore.QueueName): Effect.Effect<void> =>
+      Effect.suspend(() => {
+        signalWakeLocal(queue)
+        return redis.send("PUBLISH", wakeChannel, queue !== undefined && queue.length > 0 ? queue : "*").pipe(
+          Effect.ignore
+        )
+      })
 
     // Cross-process wake-ups. The pump resubscribes on connection loss (Bun
     // subscribers do not auto-reconnect); the retry delay only ever runs
@@ -176,8 +208,8 @@ export const make = (
       Effect.gen(function*() {
         const messages = yield* redis.subscribe(wakeChannel)
         while (true) {
-          yield* Queue.take(messages)
-          signalWakeLocal()
+          const message = yield* Queue.take(messages)
+          signalWakeLocal(message.message === "*" ? undefined : JobStore.QueueName(message.message))
         }
       })
     ).pipe(
@@ -187,13 +219,26 @@ export const make = (
     )
 
     if (options?.historyTtl !== undefined) {
-      const ttlMs = Duration.toMillis(options.historyTtl)
+      const ttlByState = JobStore.normalizeHistoryTtl(options.historyTtl)
       const intervalMs = Duration.toMillis(options.historySweepInterval ?? "1 minute")
       yield* Effect.gen(function*() {
         yield* Effect.sleep(intervalMs)
         const now = yield* Clock.currentTimeMillis
-        while ((yield* evalSweepHistory(prefix, now - ttlMs, 500)) !== "0") {
-          // bounded batches until the window is clean
+        // Per-state ceilings refined by stricter per-row keep ages, paged by
+        // an offset cursor so young rows are visited once per sweep.
+        for (const state of ["completed", "failed", "cancelled"] as const) {
+          const ttl = ttlByState[state]
+          let offset = 0
+          while (true) {
+            const page: { scanned: number; deleted: number } = JSON.parse(
+              yield* evalSweepState(prefix, state, ttl === undefined ? "" : String(ttl), 200, offset, now)
+            )
+            if (page.scanned < 200) break
+            offset += page.scanned - page.deleted
+          }
+        }
+        while ((yield* evalSweepDedupes(prefix, 200, now)) !== "0") {
+          // bounded batches until the dedup backlog is clean
         }
       }).pipe(
         Effect.catchCause((cause) => Effect.logError("effect-mq: redis history sweep failed", cause)),
@@ -228,7 +273,11 @@ export const make = (
         request.keep === undefined ? "" : JSON.stringify(request.keep),
         request.timeoutMs === undefined ? "" : String(request.timeoutMs),
         Math.max(0, request.delayMs),
-        now
+        now,
+        request.dedupe?.key ?? "",
+        request.dedupe?.ttlMs === undefined ? "" : String(request.dedupe.ttlMs),
+        request.dedupe?.extend === true ? "1" : "0",
+        request.dedupe?.replace === true ? "1" : "0"
       )
 
     const store: JobStore.Service = {
@@ -253,6 +302,7 @@ export const make = (
               wake?: boolean
               collision?: boolean
               error?: string
+              queue?: string
             } = JSON.parse(yield* enqueueOnce(request, mode, candidate, now))
             if (reply.collision === true) continue
             if (reply.error !== undefined || reply.id === undefined) {
@@ -261,7 +311,8 @@ export const make = (
               })
             }
             if (reply.wake === true) {
-              yield* wakeUp
+              // A replace-while-delayed reply names the keyed job's queue.
+              yield* wakeUp(reply.queue !== undefined ? JobStore.QueueName(reply.queue) : request.queue)
             }
             return { id: JobStore.JobId(reply.id), duplicate: reply.duplicate === true }
           }
@@ -311,7 +362,7 @@ export const make = (
             ? ""
             : JSON.stringify(outcome.exit)
           const delayMs = outcome._tag === "Retry" ? Math.max(0, outcome.delayMs) : 0
-          const reply: { error?: string; wake?: boolean } = JSON.parse(
+          const reply: { error?: string; wake?: boolean; queue?: string } = JSON.parse(
             yield* evalAck(prefix, id, token, outcome._tag, exitJson, delayMs, now).pipe(
               Effect.mapError(storeError("ack failed"))
             )
@@ -319,20 +370,20 @@ export const make = (
           if (reply.error === "notfound") return yield* new JobStore.JobNotFoundError({ jobId: id })
           if (reply.error === "locklost") return yield* new JobStore.LockLostError({ jobId: id })
           if (reply.wake === true) {
-            yield* wakeUp
+            yield* wakeUp(reply.queue !== undefined ? JobStore.QueueName(reply.queue) : undefined)
           }
         }),
 
       release: (id, token) =>
         Effect.gen(function*() {
           const now = yield* Clock.currentTimeMillis
-          const reply: { error?: string; wake?: boolean } = JSON.parse(
+          const reply: { error?: string; wake?: boolean; queue?: string } = JSON.parse(
             yield* evalRelease(prefix, id, token, now).pipe(Effect.mapError(storeError("release failed")))
           )
           if (reply.error === "notfound") return yield* new JobStore.JobNotFoundError({ jobId: id })
           if (reply.error === "locklost") return yield* new JobStore.LockLostError({ jobId: id })
           if (reply.wake === true) {
-            yield* wakeUp
+            yield* wakeUp(reply.queue !== undefined ? JobStore.QueueName(reply.queue) : undefined)
           }
         }),
 
@@ -362,15 +413,19 @@ export const make = (
           )
           const result = recovered.map((entry) => ({ id: JobStore.JobId(entry.id), failed: entry.failed }))
           if (result.some((entry) => !entry.failed)) {
-            yield* wakeUp
+            yield* wakeUp()
           }
           return result
         }).pipe(Effect.mapError(storeError("recoverStalled failed"))),
 
-      awaitWake: (_queues, wakeToken) =>
+      awaitWake: (queues, wakeToken) =>
         Effect.suspend(() => {
-          if (wakeVersion > wakeToken) return Effect.void
-          return Deferred.await(wake)
+          if (queues.some((queue) => lastWakeFor(queue) > wakeToken)) return Effect.void
+          const waiter: Waiter = { queues: new Set(queues), deferred: Deferred.makeUnsafe<void>() }
+          waiters.add(waiter)
+          return Deferred.await(waiter.deferred).pipe(
+            Effect.ensuring(Effect.sync(() => waiters.delete(waiter)))
+          )
         }),
 
       getJob: (id) =>
@@ -435,14 +490,14 @@ export const make = (
       retry: (id) =>
         Effect.gen(function*() {
           const now = yield* Clock.currentTimeMillis
-          const reply: { error?: string; state?: JobStore.JobState } = JSON.parse(
+          const reply: { error?: string; state?: JobStore.JobState; queue?: string } = JSON.parse(
             yield* evalRetry(prefix, id, now).pipe(Effect.mapError(storeError("retry failed")))
           )
           if (reply.error === "notfound") return yield* new JobStore.JobNotFoundError({ jobId: id })
           if (reply.error === "state") {
             return yield* new JobStore.JobNotRetryableError({ jobId: id, state: reply.state ?? "failed" })
           }
-          yield* wakeUp
+          yield* wakeUp(reply.queue !== undefined ? JobStore.QueueName(reply.queue) : undefined)
         }),
 
       counts: (queue) =>
@@ -491,14 +546,14 @@ export const make = (
       promote: (id) =>
         Effect.gen(function*() {
           const now = yield* Clock.currentTimeMillis
-          const reply: { error?: string; state?: JobStore.JobState } = JSON.parse(
+          const reply: { error?: string; state?: JobStore.JobState; queue?: string } = JSON.parse(
             yield* evalPromote(prefix, id, now).pipe(Effect.mapError(storeError("promote failed")))
           )
           if (reply.error === "notfound") return yield* new JobStore.JobNotFoundError({ jobId: id })
           if (reply.error === "state") {
             return yield* new JobStore.JobNotPromotableError({ jobId: id, state: reply.state ?? "completed" })
           }
-          yield* wakeUp
+          yield* wakeUp(reply.queue !== undefined ? JobStore.QueueName(reply.queue) : undefined)
         }),
 
       pause: (queue) =>
@@ -510,7 +565,7 @@ export const make = (
       resume: (queue) =>
         redis.send("SREM", `${prefix}:paused`, queue).pipe(
           Effect.mapError(storeError("resume failed")),
-          Effect.flatMap((removed) => Number(removed) > 0 ? wakeUp : Effect.void)
+          Effect.flatMap((removed) => Number(removed) > 0 ? wakeUp(queue) : Effect.void)
         ),
 
       pausedQueues: () =>
@@ -542,7 +597,7 @@ export const make = (
           schedule.nextRunAt
         ).pipe(
           Effect.mapError(storeError("upsertSchedule failed")),
-          Effect.andThen(wakeUp)
+          Effect.andThen(wakeUp(schedule.queue))
         ),
 
       removeSchedule: (key) =>