effect-mq 0.1.0 → 0.3.0

package/dist/drizzle-postgres/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/drizzle-postgres/schema.ts"],"names":[],"mappings":"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"}

package/dist/drizzle-postgres/schema.js

@@ -0,0 +1,150 @@
+import { sql } from "drizzle-orm";
+import { bigint, boolean, index, integer, jsonb, pgTable, primaryKey, text, timestamp } from "drizzle-orm/pg-core";
+const jobsColumns = () => ({
+    id: text("id").primaryKey().$type(),
+    name: text("name").notNull().$type(),
+    queue: text("queue").notNull().$type(),
+    state: text("state").notNull().$type(),
+    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(),
+    attemptsMax: integer("attempts_max").notNull(),
+    attemptsMade: integer("attempts_made").notNull().default(0),
+    stalledCount: integer("stalled_count").notNull().default(0),
+    backoff: jsonb("backoff").$type(),
+    keep: jsonb("keep").$type(),
+    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 = (tableName = "effect_mq_jobs", options) => pgTable(tableName, {
+    ...jobsColumns(),
+    // SAFETY: when `extend` is absent, `Extend` was never inferred from a
+    // value and stays at its empty-record default, which {} satisfies.
+    ...options?.extend ?? {}
+}, (table) => [
+    // Claim path: pop highest priority, FIFO within it.
+    index(`${tableName}_ready_idx`)
+        .on(table.queue, table.priority.desc(), table.seq.asc())
+        .where(sql `${table.state} = 'waiting'`),
+    // Delayed promotion + nextRunAt.
+    index(`${tableName}_delayed_idx`)
+        .on(table.queue, table.runAt)
+        .where(sql `${table.state} = 'delayed'`),
+    // Stalled sweep.
+    index(`${tableName}_active_idx`)
+        .on(table.lockExpiresAt)
+        .where(sql `${table.state} = 'active'`),
+    // 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")),
+    ...options?.extraConfig?.(table) ?? []
+]);
+const attemptsColumns = (jobs) => ({
+    jobId: text("job_id").notNull().references(() => jobs.id, { onDelete: "cascade" }).$type(),
+    attempt: integer("attempt").notNull(),
+    outcome: text("outcome").notNull().$type(),
+    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).
+ *
+ * @since 0.1.0
+ */
+export const mqJobAttempts = (jobs, tableName = "effect_mq_job_attempts", options) => pgTable(tableName, attemptsColumns(jobs), (table) => [
+    primaryKey({ columns: [table.jobId, table.attempt] }),
+    ...options?.extraConfig?.(table) ?? []
+]);
+const schedulesColumns = () => ({
+    key: text("key").primaryKey().$type(),
+    jobName: text("job_name").notNull(),
+    queue: text("queue").notNull().$type(),
+    cron: text("cron"),
+    tz: text("tz"),
+    everyMs: bigint("every_ms", { mode: "number" }),
+    payload: jsonb("payload"),
+    metadata: jsonb("metadata").notNull().default({}).$type(),
+    priority: integer("priority").notNull().default(0),
+    attemptsMax: integer("attempts_max").notNull(),
+    backoff: jsonb("backoff").$type(),
+    keep: jsonb("keep").$type(),
+    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", options) => 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(),
+    /** 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) => pgTable(tableName, dedupeColumns(), (table) => [
+    primaryKey({ columns: [table.name, table.key] }),
+    ...options?.extraConfig?.(table) ?? []
+]);
+const queueControlColumns = () => ({
+    queue: text("queue").primaryKey().$type(),
+    paused: boolean("paused").notNull().default(false)
+});
+/**
+ * Durable queue control flags (pause/resume).
+ *
+ * @since 0.2.0
+ */
+export const mqQueueControl = (tableName = "effect_mq_queue_control", options) => pgTable(tableName, queueControlColumns(), (table) => [
+    ...options?.extraConfig?.(table) ?? []
+]);
+//# sourceMappingURL=schema.js.map

package/dist/drizzle-postgres/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/drizzle-postgres/schema.ts"],"names":[],"mappings":"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"}

package/dist/redis/RedisJobStore.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A Redis-backed `JobStore` built on `effect/unstable/persistence`'s `Redis`
+ * service. Every mutation is a single Lua script (see `scripts.ts`), so all
+ * `JobStore` operations are atomic on the server and safe across processes.
+ *
+ * Provide the `Redis` service from your platform package — `NodeRedis.layer`
+ * (`@effect/platform-node`, node-redis), `BunRedis.layer`
+ * (`@effect/platform-bun`, `Bun.redis`) — or `Redis.make` over any client.
+ *
+ * Wake-ups ride the client's pub/sub channel, so workers in other processes
+ * pick jobs up promptly; the worker's `pollInterval` is the fallback.
+ *
+ * @since 0.2.0
+ */
+import { type Context, Duration, Effect, Layer, type Scope } from "effect";
+import { Redis } from "effect/unstable/persistence";
+import * as JobStore from "../JobStore.ts";
+/**
+ * @since 0.2.0
+ */
+export interface RedisJobStoreOptions {
+    /** Key prefix for everything this store writes (default `effect-mq`). */
+    readonly prefix?: string | undefined;
+    /**
+     * Store-level retention ceiling: terminal records older than this are
+     * 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?: JobStore.HistoryTtlInput | undefined;
+    /** History sweep cadence (default 1 minute). */
+    readonly historySweepInterval?: Duration.Input | undefined;
+    /**
+     * Generator for store-assigned job ids (e.g. `() => \`job_${ulid()}\``).
+     * Default: `j-<n>` from the store's counter. See `JobStore.IdGenerator`.
+     */
+    readonly idGenerator?: JobStore.IdGenerator | undefined;
+}
+/**
+ * Build a `RedisJobStore` service. Needs the `Redis` service and a `Scope`
+ * (the wake-up subscription and the optional history sweeper live in it).
+ *
+ * @since 0.2.0
+ */
+export declare const make: (options?: RedisJobStoreOptions | undefined) => Effect.Effect<JobStore.Service, never, Redis.Redis | Scope.Scope>;
+/**
+ * A Redis-backed layer for the default `JobStore`.
+ *
+ * @since 0.2.0
+ */
+export declare const layer: (options?: RedisJobStoreOptions | undefined) => Layer.Layer<JobStore.JobStore, never, Redis.Redis>;
+/**
+ * A Redis-backed layer for a specific named store key.
+ *
+ * @since 0.2.0
+ */
+export declare const layerFor: <StoreId>(store: Context.Key<StoreId, JobStore.Service>, options?: RedisJobStoreOptions | undefined) => Layer.Layer<StoreId, never, Redis.Redis>;
+//# sourceMappingURL=RedisJobStore.d.ts.map

package/dist/redis/RedisJobStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisJobStore.d.ts","sourceRoot":"","sources":["../../src/redis/RedisJobStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAS,KAAK,OAAO,EAAY,QAAQ,EAAE,MAAM,EAAQ,KAAK,EAA2B,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAA;AAC1H,OAAO,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAA;AACnD,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAA;AAG1C;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,yEAAyE;IACzE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,eAAe,GAAG,SAAS,CAAA;IAC1D,gDAAgD;IAChD,QAAQ,CAAC,oBAAoB,CAAC,EAAE,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAA;IAC1D;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,WAAW,GAAG,SAAS,CAAA;CACxD;AAqFD;;;;;GAKG;AACH,eAAO,MAAM,IAAI,aACL,oBAAoB,GAAG,SAAS,KACzC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAof/D,CAAA;AAEJ;;;;GAIG;AACH,eAAO,MAAM,KAAK,aACN,oBAAoB,GAAG,SAAS,KACzC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAmD,CAAA;AAEvG;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,SACvB,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC,YACnC,oBAAoB,GAAG,SAAS,KACzC,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAuC,CAAA"}

package/dist/redis/RedisJobStore.js

@@ -0,0 +1,424 @@
+/**
+ * A Redis-backed `JobStore` built on `effect/unstable/persistence`'s `Redis`
+ * service. Every mutation is a single Lua script (see `scripts.ts`), so all
+ * `JobStore` operations are atomic on the server and safe across processes.
+ *
+ * Provide the `Redis` service from your platform package — `NodeRedis.layer`
+ * (`@effect/platform-node`, node-redis), `BunRedis.layer`
+ * (`@effect/platform-bun`, `Bun.redis`) — or `Redis.make` over any client.
+ *
+ * Wake-ups ride the client's pub/sub channel, so workers in other processes
+ * pick jobs up promptly; the worker's `pollInterval` is the fallback.
+ *
+ * @since 0.2.0
+ */
+import { Clock, Deferred, Duration, Effect, Exit, Layer, Option, Queue, Schedule } from "effect";
+import { Redis } from "effect/unstable/persistence";
+import * as JobStore from "../JobStore.js";
+import * as scripts from "./scripts.js";
+const storeError = (message) => (cause) => new JobStore.JobStoreError({ message, cause });
+/** Fold a Lua `HGETALL` reply (flat `[field, value, ...]`) into a map. */
+const foldPairs = (flat) => {
+    const out = new Map();
+    for (let i = 0; i + 1 < flat.length; i += 2) {
+        const field = flat[i];
+        const value = flat[i + 1];
+        if (field !== undefined && value !== undefined) {
+            out.set(field, value);
+        }
+    }
+    return out;
+};
+// Hash fields use "" for absent optional values.
+const optionalString = (value) => value === undefined || value === "" ? undefined : value;
+const optionalNumber = (value) => value === undefined || value === "" ? undefined : Number(value);
+const optionalJson = (value) => {
+    if (value === undefined || value === "")
+        return undefined;
+    // SAFETY: the value round-trips JSON this driver itself wrote for the field.
+    return JSON.parse(value);
+};
+const toRecord = (hash) => ({
+    id: JobStore.JobId(hash.get("id") ?? ""),
+    name: hash.get("name") ?? "",
+    queue: JobStore.QueueName(hash.get("queue") ?? ""),
+    payload: optionalJson(hash.get("payload")) ?? null,
+    metadata: optionalJson(hash.get("metadata")) ?? {},
+    // SAFETY: the state field is only ever written with JobState members.
+    state: (hash.get("state") ?? "waiting"),
+    priority: Number(hash.get("priority") ?? 0),
+    attemptsMax: Number(hash.get("attemptsMax") ?? 1),
+    attemptsMade: Number(hash.get("attemptsMade") ?? 0),
+    stalledCount: Number(hash.get("stalledCount") ?? 0),
+    backoff: optionalJson(hash.get("backoff")),
+    keep: optionalJson(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")),
+    finishedAt: optionalNumber(hash.get("finishedAt")),
+    exit: optionalJson(hash.get("exit")),
+    failedReason: optionalString(hash.get("failedReason"))
+});
+const toSchedule = (hash) => ({
+    key: JobStore.ScheduleKey(hash.get("key") ?? ""),
+    jobName: hash.get("jobName") ?? "",
+    queue: JobStore.QueueName(hash.get("queue") ?? ""),
+    cron: optionalString(hash.get("cron")),
+    tz: optionalString(hash.get("tz")),
+    everyMs: optionalNumber(hash.get("everyMs")),
+    payload: optionalJson(hash.get("payload")),
+    metadata: optionalJson(hash.get("metadata")) ?? {},
+    priority: Number(hash.get("priority") ?? 0),
+    attemptsMax: Number(hash.get("attemptsMax") ?? 1),
+    backoff: optionalJson(hash.get("backoff")),
+    keep: optionalJson(hash.get("keep")),
+    timeoutMs: optionalNumber(hash.get("timeoutMs")),
+    nextRunAt: Number(hash.get("nextRunAt") ?? 0)
+});
+// cjson encodes an empty Lua table as {}, not [] — normalize.
+const asArray = (value) => Array.isArray(value) ? value : [];
+const JOB_STATES = [
+    "waiting",
+    "delayed",
+    "active",
+    "completed",
+    "failed",
+    "cancelled"
+];
+/**
+ * Build a `RedisJobStore` service. Needs the `Redis` service and a `Scope`
+ * (the wake-up subscription and the optional history sweeper live in it).
+ *
+ * @since 0.2.0
+ */
+export const make = (options) => Effect.gen(function* () {
+    const redis = yield* Redis.Redis;
+    const prefix = options?.prefix ?? "effect-mq";
+    const wakeChannel = `${prefix}:wake`;
+    const evalEnqueue = redis.eval(scripts.enqueue);
+    const evalClaim = redis.eval(scripts.claim);
+    const evalAck = redis.eval(scripts.ack);
+    const evalRelease = redis.eval(scripts.release);
+    const evalExtendLocks = redis.eval(scripts.extendLocks);
+    const evalRecoverStalled = redis.eval(scripts.recoverStalled);
+    const evalGetJob = redis.eval(scripts.getJob);
+    const evalList = redis.eval(scripts.list);
+    const evalCounts = redis.eval(scripts.counts);
+    const evalRemove = redis.eval(scripts.remove);
+    const evalRetry = redis.eval(scripts.retry);
+    const evalCancel = redis.eval(scripts.cancel);
+    const evalPromote = redis.eval(scripts.promote);
+    const evalUpsertSchedule = redis.eval(scripts.upsertSchedule);
+    const evalRemoveSchedule = redis.eval(scripts.removeSchedule);
+    const evalListSchedules = redis.eval(scripts.listSchedules);
+    const evalDueSchedules = redis.eval(scripts.dueSchedules);
+    const evalAdvanceSchedule = redis.eval(scripts.advanceSchedule);
+    const evalSweepState = redis.eval(scripts.sweepState);
+    const evalSweepDedupes = redis.eval(scripts.sweepDedupes);
+    // 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 — 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 lastBroadcast = 0;
+    const lastWake = new Map();
+    const waiters = new Set();
+    const lastWakeFor = (queue) => Math.max(lastWake.get(queue) ?? 0, lastBroadcast);
+    const signalWakeLocal = (queue) => {
+        wakeVersion += 1;
+        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, Exit.succeed(void 0));
+        }
+    };
+    const wakeUp = (queue) => 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
+    // after a real failure, so TestClock runs are unaffected.
+    yield* Effect.scoped(Effect.gen(function* () {
+        const messages = yield* redis.subscribe(wakeChannel);
+        while (true) {
+            const message = yield* Queue.take(messages);
+            signalWakeLocal(message.message === "*" ? undefined : JobStore.QueueName(message.message));
+        }
+    })).pipe(Effect.retry(Schedule.spaced("1 second")), Effect.catchCause((cause) => Effect.logWarning("effect-mq: redis wake subscription failed", cause)), Effect.forkScoped);
+    if (options?.historyTtl !== undefined) {
+        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;
+            // 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"]) {
+                const ttl = ttlByState[state];
+                let offset = 0;
+                while (true) {
+                    const page = 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)), Effect.forever, Effect.forkScoped);
+    }
+    const generateCandidate = (request, generate) => Effect.suspend(() => {
+        const raw = generate(request);
+        return Effect.isEffect(raw) ? raw : Effect.succeed(raw);
+    });
+    const enqueueOnce = (request, idMode, id, now) => evalEnqueue(prefix, idMode, id, request.name, request.queue, JSON.stringify(request.payload ?? null), JSON.stringify(request.metadata), request.priority, request.attemptsMax, request.backoff === undefined ? "" : JSON.stringify(request.backoff), request.keep === undefined ? "" : JSON.stringify(request.keep), request.timeoutMs === undefined ? "" : String(request.timeoutMs), Math.max(0, request.delayMs), 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 = {
+        enqueue: (request) => Effect.gen(function* () {
+            const now = yield* Clock.currentTimeMillis;
+            const generate = options?.idGenerator;
+            for (let i = 0; i < 5; i++) {
+                const mode = request.id !== undefined
+                    ? "user"
+                    : generate !== undefined
+                        ? "generated"
+                        : "auto";
+                const candidate = mode === "user"
+                    ? request.id ?? ""
+                    : mode === "generated" && generate !== undefined
+                        ? yield* generateCandidate(request, generate)
+                        : "";
+                const reply = JSON.parse(yield* enqueueOnce(request, mode, candidate, now));
+                if (reply.collision === true)
+                    continue;
+                if (reply.error !== undefined || reply.id === undefined) {
+                    return yield* new JobStore.JobStoreError({
+                        message: "enqueue failed: could not generate a unique job id"
+                    });
+                }
+                if (reply.wake === true) {
+                    // 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 };
+            }
+            return yield* new JobStore.JobStoreError({
+                message: "enqueue failed: could not generate a unique job id"
+            });
+        }).pipe(Effect.mapError((error) => error instanceof JobStore.JobStoreError ? error : storeError("enqueue failed")(error))),
+        claim: (claimOptions) => 
+        // Snapshot BEFORE the script runs: a wake that fires while the claim
+        // executes must make awaitWake(token) return immediately.
+        Effect.suspend(() => {
+            const observedWake = wakeVersion;
+            return Effect.gen(function* () {
+                const now = yield* Clock.currentTimeMillis;
+                const reply = JSON.parse(yield* evalClaim(prefix, claimOptions.queue, JSON.stringify(claimOptions.names), claimOptions.token, claimOptions.lockDurationMs, now));
+                if (reply.job !== undefined) {
+                    const claimed = { _tag: "Claimed", job: toRecord(foldPairs(reply.job)) };
+                    return claimed;
+                }
+                const empty = {
+                    _tag: "Empty",
+                    nextRunAt: reply.nextRunAt,
+                    wakeToken: observedWake
+                };
+                return empty;
+            });
+        }).pipe(Effect.mapError(storeError("claim failed"))),
+        ack: (id, token, outcome) => Effect.gen(function* () {
+            const now = yield* Clock.currentTimeMillis;
+            const exitJson = outcome._tag === "Cancelled" || outcome.exit === undefined
+                ? ""
+                : JSON.stringify(outcome.exit);
+            const delayMs = outcome._tag === "Retry" ? Math.max(0, outcome.delayMs) : 0;
+            const reply = JSON.parse(yield* evalAck(prefix, id, token, outcome._tag, exitJson, delayMs, now).pipe(Effect.mapError(storeError("ack 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(reply.queue !== undefined ? JobStore.QueueName(reply.queue) : undefined);
+            }
+        }),
+        release: (id, token) => Effect.gen(function* () {
+            const now = yield* Clock.currentTimeMillis;
+            const reply = 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(reply.queue !== undefined ? JobStore.QueueName(reply.queue) : undefined);
+            }
+        }),
+        extendLocks: (locks, durationMs) => Effect.gen(function* () {
+            if (locks.length === 0) {
+                const empty = { lost: [], cancelRequested: [] };
+                return empty;
+            }
+            const now = yield* Clock.currentTimeMillis;
+            const reply = JSON.parse(yield* evalExtendLocks(prefix, JSON.stringify(locks), durationMs, now));
+            const result = {
+                lost: asArray(reply.lost).map(JobStore.JobId),
+                cancelRequested: asArray(reply.cancel).map(JobStore.JobId)
+            };
+            return result;
+        }).pipe(Effect.mapError(storeError("extendLocks failed"))),
+        recoverStalled: (recoverOptions) => Effect.gen(function* () {
+            const now = yield* Clock.currentTimeMillis;
+            const recovered = JSON.parse(yield* evalRecoverStalled(prefix, recoverOptions.maxStalledCount, now));
+            const result = recovered.map((entry) => ({ id: JobStore.JobId(entry.id), failed: entry.failed }));
+            if (result.some((entry) => !entry.failed)) {
+                yield* wakeUp();
+            }
+            return result;
+        }).pipe(Effect.mapError(storeError("recoverStalled failed"))),
+        awaitWake: (queues, wakeToken) => Effect.suspend(() => {
+            if (queues.some((queue) => lastWakeFor(queue) > wakeToken))
+                return Effect.void;
+            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) => evalGetJob(prefix, id).pipe(Effect.mapError(storeError("getJob failed")), Effect.map((raw) => {
+            const flat = JSON.parse(raw);
+            return flat.length === 0 ? Option.none() : Option.some(toRecord(foldPairs(flat)));
+        })),
+        getAttempts: (id) => redis.send("LRANGE", `${prefix}:attempts:${id}`, "0", "-1").pipe(Effect.mapError(storeError("getAttempts failed")), Effect.map((raw) => {
+            // SAFETY: LRANGE always replies with an array of bulk strings.
+            const entries = raw;
+            return entries.map((entry) => {
+                const parsed = JSON.parse(entry);
+                const record = {
+                    attempt: parsed.attempt,
+                    startedAt: parsed.startedAt ?? undefined,
+                    finishedAt: parsed.finishedAt,
+                    outcome: parsed.outcome,
+                    // The ledger omits the key entirely for absent exits, so a
+                    // legitimate encoded null exit survives the round trip.
+                    exit: Object.hasOwn(parsed, "exit") ? parsed.exit : undefined
+                };
+                return record;
+            });
+        })),
+        list: (listOptions) => Effect.gen(function* () {
+            const limit = Math.max(1, listOptions.limit ?? 50);
+            const filters = {
+                queue: listOptions.queue,
+                name: listOptions.name,
+                states: listOptions.states,
+                metadata: listOptions.metadata
+            };
+            const reply = JSON
+                .parse(yield* evalList(prefix, JSON.stringify(filters), listOptions.cursor ?? "", limit));
+            const items = asArray(reply.items).map((flat) => toRecord(foldPairs(flat)));
+            const last = items[items.length - 1];
+            const result = {
+                items,
+                cursor: reply.more && last !== undefined ? `${last.enqueuedAt}:${last.id}` : undefined
+            };
+            return result;
+        }).pipe(Effect.mapError(storeError("list failed"))),
+        retry: (id) => Effect.gen(function* () {
+            const now = yield* Clock.currentTimeMillis;
+            const reply = 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(reply.queue !== undefined ? JobStore.QueueName(reply.queue) : undefined);
+        }),
+        counts: (queue) => evalCounts(prefix).pipe(Effect.mapError(storeError("counts failed")), Effect.map((raw) => {
+            const flat = JSON.parse(raw);
+            const byField = foldPairs(flat);
+            // SAFETY: fromEntries over the exhaustive JOB_STATES list yields
+            // exactly one zeroed entry per JobState member.
+            const totals = Object.fromEntries(JOB_STATES.map((state) => [state, 0]));
+            for (const [field, count] of byField) {
+                const split = field.lastIndexOf("|");
+                const fieldQueue = field.slice(0, split);
+                // SAFETY: counts fields are written as `<queue>|<JobState>`.
+                const state = field.slice(split + 1);
+                if (queue === undefined || fieldQueue === queue) {
+                    totals[state] += Number(count);
+                }
+            }
+            return totals;
+        })),
+        remove: (id) => evalRemove(prefix, id).pipe(Effect.mapError(storeError("remove failed")), Effect.map((raw) => raw !== "0")),
+        cancel: (id) => Effect.gen(function* () {
+            const now = yield* Clock.currentTimeMillis;
+            const reply = JSON.parse(yield* evalCancel(prefix, id, now).pipe(Effect.mapError(storeError("cancel failed"))));
+            if (reply.error === "notfound")
+                return yield* new JobStore.JobNotFoundError({ jobId: id });
+            if (reply.error === "state") {
+                return yield* new JobStore.JobNotCancellableError({ jobId: id, state: reply.state ?? "completed" });
+            }
+        }),
+        promote: (id) => Effect.gen(function* () {
+            const now = yield* Clock.currentTimeMillis;
+            const reply = 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(reply.queue !== undefined ? JobStore.QueueName(reply.queue) : undefined);
+        }),
+        pause: (queue) => redis.send("SADD", `${prefix}:paused`, queue).pipe(Effect.mapError(storeError("pause failed")), Effect.asVoid),
+        resume: (queue) => redis.send("SREM", `${prefix}:paused`, queue).pipe(Effect.mapError(storeError("resume failed")), Effect.flatMap((removed) => Number(removed) > 0 ? wakeUp(queue) : Effect.void)),
+        pausedQueues: () => redis.send("SMEMBERS", `${prefix}:paused`).pipe(Effect.mapError(storeError("pausedQueues failed")), Effect.map((raw) => {
+            // SAFETY: SMEMBERS always replies with an array of bulk strings.
+            const members = raw;
+            return members.map(JobStore.QueueName);
+        })),
+        upsertSchedule: (schedule) => evalUpsertSchedule(prefix, schedule.key, schedule.jobName, schedule.queue, schedule.cron ?? "", schedule.tz ?? "", schedule.everyMs === undefined ? "" : String(schedule.everyMs), schedule.payload === undefined ? "" : JSON.stringify(schedule.payload), JSON.stringify(schedule.metadata), String(schedule.priority), String(schedule.attemptsMax), schedule.backoff === undefined ? "" : JSON.stringify(schedule.backoff), schedule.keep === undefined ? "" : JSON.stringify(schedule.keep), schedule.timeoutMs === undefined ? "" : String(schedule.timeoutMs), schedule.nextRunAt).pipe(Effect.mapError(storeError("upsertSchedule failed")), Effect.andThen(wakeUp(schedule.queue))),
+        removeSchedule: (key) => evalRemoveSchedule(prefix, key).pipe(Effect.mapError(storeError("removeSchedule failed")), Effect.map((raw) => raw !== "0")),
+        listSchedules: (listOptions) => evalListSchedules(prefix, JSON.stringify(listOptions ?? {})).pipe(Effect.mapError(storeError("listSchedules failed")), Effect.map((raw) => {
+            const flat = JSON.parse(raw);
+            return flat.map((pairs) => toSchedule(foldPairs(pairs)));
+        })),
+        dueSchedules: () => Effect.gen(function* () {
+            const now = yield* Clock.currentTimeMillis;
+            const flat = JSON.parse(yield* evalDueSchedules(prefix, now));
+            return flat.map((pairs) => toSchedule(foldPairs(pairs)));
+        }).pipe(Effect.mapError(storeError("dueSchedules failed"))),
+        advanceSchedule: (key, expectedRunAt, nextRunAt) => evalAdvanceSchedule(prefix, key, expectedRunAt, nextRunAt).pipe(Effect.mapError(storeError("advanceSchedule failed")), Effect.asVoid)
+    };
+    return store;
+});
+/**
+ * A Redis-backed layer for the default `JobStore`.
+ *
+ * @since 0.2.0
+ */
+export const layer = (options) => Layer.effect(JobStore.JobStore, make(options));
+/**
+ * A Redis-backed layer for a specific named store key.
+ *
+ * @since 0.2.0
+ */
+export const layerFor = (store, options) => Layer.effect(store, make(options));
+//# sourceMappingURL=RedisJobStore.js.map