@10x-media/jobs 0.1.0-beta.0 → 0.1.0-beta.2

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @10x-media/jobs
 
+## 0.1.0-beta.2
+
+### Minor Changes
+
+- Fix a batch of functional and security issues found in the jobs plugin review:
+
+  - Sweeper processes jobs oldest-first via `sort: 'updatedAt'` (item 5)
+  - `acquireOrSteal` treats `leaseExpiresAt: null` as stealable, preventing dead-lock on first-boot rows (item 6)
+  - `start()` is a no-op when a drain is already in progress, preventing loop restart during shutdown (item 7)
+  - Signal handler exits with code 1 on drain timeout, 0 on clean drain (item 8)
+  - `runControlEndpoint` returns 400 for non-finite `?limit=` values (item 9)
+  - Drain loop checks the deadline after each poll sleep to avoid overrunning the budget (item 10)
+  - Leadership is released immediately after stopping loops, before the poll-wait phase (item 11)
+  - Cron secret comparison uses `crypto.timingSafeEqual` to prevent timing attacks (item 12)
+  - `applyResume` / `PauseStore.resume` accept `{ all: true }` to reset both global and per-queue pause state (item 13)
+  - `stop()` removed from the public `Worker` type; accessible via `WorkerTestHandle` cast for tests (item 14)
+  - KV-stored pause state is validated on read; corrupt or missing values fall back to empty state (item 16)
+  - `config.jobs.access.run` is composed with the plugin's built-in checker (both must pass) instead of replacing it; the same composed checker also guards the plugin's own `/queue-run` and `/queue-sweep` endpoints, so a stricter `jobs.access.run` cannot be bypassed through them (item 17)
+  - `LeaseStore.release` returns `{ ok: boolean }`; `leaderController` drops local leading state after any `release()`, since an unconfirmed release means the node no longer owns the lease (item 18)
+  - `renew` filter includes `leaseExpiresAt >= now`; on failed renew while leading, the controller falls through to `acquireOrSteal` with a fence bump (item 19)
+  - `createWorker` throws when signal handlers are already installed, enforcing the one-worker-per-process constraint (item 21)
+  - `createWorker` defaults `pauseStore` to `createPauseStore(payload)`, eliminating the footgun where preset-enabled queue control was silently ignored (item 22)
+  - `sweepCycle` re-ticks the sweeper leadership before acting so the check is always fresh (item 23)
+  - `stampClaim` guards against double-claiming: a second owner cannot claim a job already held by a different node (item 24)
+  - `/queue-status` reports the seven canonical job states (`queued`, `scheduled`, `retrying`, `processing`, `succeeded`, `failed`, `cancelled`) plus an orthogonal `recovered` count (`recoveryAttempts > 0`, when reliability is enabled) (item 25, breaking change)
+  - In-flight job count is now process-local (incremented/decremented in `withHeartbeat`) instead of a DB query; on drain, `requeueStragglers` runs only when the wall-clock budget is exceeded, so a just-completed job is never spuriously requeued (genuinely orphaned claims are recovered by the sweeper) (item 26)
+
+## 0.1.0-beta.1
+
+### Minor Changes
+
+- Opt-in layers accept `true`: pass `reliability: true` or `queueControl: true` to enable a layer with its defaults, matching Payload's `false`/`true`/object option form. Empty objects and tuned objects still work.
+
 ## 0.1.0-beta.0
 
 ### Minor Changes

package/README.md

@@ -38,8 +38,8 @@ export default buildConfig({
 | Option | Type | Default | Description |
 |---|---|---|---|
 | `disabled` | `boolean` | `false` | When `true`, returns the incoming config unchanged. Useful for toggling the plugin per environment. |
-| `reliability` | `ReliabilityOptions \| false` | off | Job leases, the orphan sweeper, leader election, and serverless staleness. Opt in with `{}` (defaults) or a tuned object. |
-| `queueControl` | `QueueControlOptions \| false` | off | Cluster-wide pause/resume, hardened run/sweep/status endpoints, and access guards. Opt in with `{}` (defaults) or a tuned object. |
+| `reliability` | `ReliabilityOptions \| boolean` | off | Job leases, the orphan sweeper, leader election, and serverless staleness. Opt in with `true` (defaults) or a tuned object. |
+| `queueControl` | `QueueControlOptions \| boolean` | off | Cluster-wide pause/resume, hardened run/sweep/status endpoints, and access guards. Opt in with `true` (defaults) or a tuned object. |
 
 <!-- Add new options to this table as you build them. -->
 
@@ -52,9 +52,9 @@ The plugin ships four opt-in layers. You add only the ones your deployment needs
 | Layer | What it adds | How to enable |
 |---|---|---|
 | Observability | The jobs ops dashboard (status, queue health, error and log panels) and i18n. | Always on (just adding `jobs()`). |
-| Reliability | Job leases, an orphan sweeper, leader election, serverless staleness. | `reliability: {}` (or a tuned `ReliabilityOptions`). |
+| Reliability | Job leases, an orphan sweeper, leader election, serverless staleness. | `reliability: true` (or a tuned `ReliabilityOptions`). |
 | Execution | A standalone worker (`createWorker`) that runs jobs everywhere and schedules/sweeps only while holding the leader lease, with a graceful SIGTERM drain. | Run the worker entrypoint as its own process. |
-| Queue control | Cluster-wide pause/resume plus hardened `/api/payload-jobs/queue-run`, `/queue-sweep`, and `/queue-status` endpoints with access guards. | `queueControl: {}` (or a tuned `QueueControlOptions`). |
+| Queue control | Cluster-wide pause/resume plus hardened `/api/payload-jobs/queue-run`, `/queue-sweep`, and `/queue-status` endpoints with access guards. | `queueControl: true` (or a tuned `QueueControlOptions`). |
 
 Every layer is opt-in. The observability dashboard is always present once the plugin is installed. The other three you turn on as your topology demands.
 
@@ -64,7 +64,7 @@ Three facts shape every topology below.
 
 2. **The worker is a separate process, not your web server.** The execution layer (`createWorker`) is meant to run as its own long-lived process (a worker container, a separate Vercel-incompatible service). Your Next.js / Payload web server handles HTTP. The worker boots its own Payload instance against the same database and owns the run/schedule/sweep loops. The only topology that does not run a worker process is serverless, which drives everything from cron-hit endpoints instead.
 
-3. **Completed jobs are deleted, not kept.** Payload's `jobs.deleteJobOnComplete` defaults to `true` in v3.85, so a job that finishes successfully is removed from the queue. The dashboard and the `/queue-status` counts therefore reflect pending, processing, failed, and scheduled jobs, never completed ones. Set `jobs.deleteJobOnComplete: false` in `buildConfig` if you want completed jobs to persist for auditing.
+3. **Completed jobs are deleted, not kept.** Payload's `jobs.deleteJobOnComplete` defaults to `true` in v3.85, so a job that finishes successfully is removed from the queue. With the default, the dashboard and `/queue-status` counts reflect the live states (`queued`, `scheduled`, `retrying`, `processing`, `failed`, `cancelled`), since succeeded jobs are gone. Set `jobs.deleteJobOnComplete: false` in `buildConfig` to keep completed jobs for auditing; the `succeeded` count then reflects them.
 
 Pick a preset:
 
@@ -132,6 +132,8 @@ console.log(JSON.stringify({ crons: vercelCrons() }, null, 2))
 - `/api/payload-jobs/queue-run` runs due jobs (pause-aware, mirrors the native run params). `?allQueues=true` runs every queue, `?queue=<name>` runs one, `?limit=<n>` caps jobs per invocation, `?disableScheduling=true` skips schedule handling.
 - `/api/payload-jobs/queue-sweep` runs one orphan sweep (a single cron invocation, so no leader election). Requires reliability to be enabled.
 
+**CSRF note.** Both `queue-run` and `queue-sweep` are state-mutating operations served over GET. A crafted `<img>` or link in a document opened by a logged-in admin can trigger them silently (CSRF). The serverless preset uses Vercel Cron, which sends GET requests only, so switching to POST is not feasible without breaking the Vercel cron flow. For deployments where browser sessions are involved, override `access` to require an `Authorization: Bearer` token (`cronSecretAccess`) rather than relying on the session cookie (`loggedInAccess`).
+
 **Vercel limits.** Match your plan to a cron cadence and a function duration:
 
 - **Hobby**: crons run at most **once per day** and functions cap at **300s**. That is unusable for real job processing. Use Hobby only for a toy or a demo.
@@ -234,7 +236,7 @@ Set `JOBS_SCHEDULER=1` on exactly one replica (or run a single dedicated schedul
 
 **Graceful shutdown is a hard requirement under multi-node.** When an orchestrator rolls or scales down a replica, it sends SIGTERM, then SIGKILLs after a grace period. The worker's drain requeues its in-flight job (so another replica picks it up) and releases its leases, but only if it is given time to finish.
 
-- The orchestrator grace period **must exceed** the worker's `drainTimeoutMs`. In Docker Compose set `stop_grace_period`; in Kubernetes set `terminationGracePeriodSeconds`. If the grace period is shorter, the orchestrator SIGKILLs a still-draining worker and you lose the clean requeue.
+- The orchestrator grace period must be set to `drainTimeoutMs + pollIntervalMs + 5s` to be safe. In Docker Compose set `stop_grace_period`; in Kubernetes set `terminationGracePeriodSeconds`. The actual shutdown time is `drainTimeoutMs` plus up to one `pollIntervalMs` (drain loop overrun) plus the `releaseLeadership` DB roundtrip plus `payload.destroy()` latency, which can be significant if the DB connection pool is busy. If the grace period is shorter, the orchestrator SIGKILLs a still-draining worker and you lose the clean requeue.
 - The container `CMD` must be **exec form** (`CMD ["node", "dist/worker.js"]`, not `CMD node dist/worker.js`). Shell form runs Node as a child of `/bin/sh`, which does not forward SIGTERM, so the worker never drains and is hard-killed every time.
 
 ```yaml
@@ -242,8 +244,8 @@ services:
   worker:
     build: .
     command: ['node', 'dist/worker.js'] # exec form: Node receives SIGTERM
-    # Must be greater than the worker's drainTimeoutMs (default 30s here, so 45s of headroom).
-    stop_grace_period: 45s
+    # drainTimeoutMs (30s) + pollIntervalMs (0.5s) + 5s buffer = 36s; round up to 40s.
+    stop_grace_period: 40s
     deploy:
       replicas: 3
     environment:
@@ -252,7 +254,7 @@ services:
     depends_on: [db]
 ```
 
-The Kubernetes equivalent: an exec-form `command` in the pod spec and `terminationGracePeriodSeconds: 45` (greater than `drainTimeoutMs`).
+The Kubernetes equivalent: an exec-form `command` in the pod spec and `terminationGracePeriodSeconds: 40` (`drainTimeoutMs + pollIntervalMs + 5s` buffer).
 
 ### The worker entrypoint
 
@@ -296,7 +298,8 @@ Notes:
 
 - `resolveReliabilityOptions` fully defaults your `ReliabilityOptions`. It returns `null` when reliability is off (passed `false` or `undefined`), which the worker cannot run with, hence the guard.
 - Pass the same reliability tuning you give the plugin (share a constant between `payload.config.ts` and `worker.ts`) so the lease TTLs match across the cluster.
-- `createWorker` registers SIGTERM and SIGINT handlers automatically (`installSignals` defaults to `true`). On signal it drains in-flight jobs (within `drainTimeoutMs`), requeues any straggler, releases leases, destroys the Payload instance, and exits 0. Keep your orchestrator grace period above `drainTimeoutMs` (see Multi-node above).
+- `createWorker` registers SIGTERM and SIGINT handlers automatically (`installSignals` defaults to `true`). On signal it drains in-flight jobs (within `drainTimeoutMs`), requeues any straggler, releases leases, destroys the Payload instance, and exits **0** on clean drain or **1** if the drain timed out (jobs were requeued). Keep your orchestrator grace period at `drainTimeoutMs + pollIntervalMs + 5s` (see Multi-node above).
+- Only one worker with `installSignals: true` may exist per process. Creating a second one throws. Use `installSignals: false` for additional workers in the same process (e.g. test helpers).
 - Run it with `node --import tsx worker.ts` in development, or compile it and run `node dist/worker.js` in production.
 
 ### CI-optional e2e recipes

package/dist/exports/types.d.ts

@@ -1,2 +1,2 @@
-import { Q as JobsPluginOptions, Z as JobsOptions } from "../index-CYsbNe4q.js";
+import { Q as JobsPluginOptions, Z as JobsOptions } from "../index-LgqeiXr2.js";
 export type { JobsOptions, JobsPluginOptions, JobsPluginOptions as PluginOptions };

package/dist/{index-CYsbNe4q.d.ts → index-LgqeiXr2.d.ts}

@@ -36,7 +36,11 @@ type QueueControlOptions = {
 type ReliabilityOptions = {
   /** How long a worker's claim is valid before the sweeper may reclaim it. Default 300000 (5 min). */jobLeaseTtlMs?: number; /** How often a running worker renews its job lease. Default jobLeaseTtlMs / 3. */
   heartbeatIntervalMs?: number; /** How often the sweeper scans for orphaned jobs. Default 60000. */
-  sweepIntervalMs?: number; /** How many times the sweeper requeues a job before dead-lettering it. Default 3. */
+  sweepIntervalMs?: number;
+  /**
+   * How many times the sweeper requeues a job before dead-lettering it. Default 3.
+   * Number of sweeper requeues after the original attempt; total executions = maxRecoveries + 1.
+   */
   maxRecoveries?: number; /** How long a leadership lease (scheduler/sweeper) is valid. Default 30000. */
   leaderLeaseTtlMs?: number; /** A stable id for this node/process. Defaults to a generated value at runtime. */
   leaderId?: string;
@@ -49,8 +53,8 @@ type ReliabilityOptions = {
     maxDurationMs: number;
   };
   /**
-   * Recommend (true) Payload's `enableConcurrencyControl` for app-level mutual
-   * exclusion under multi-node. Documentation-facing; consumed in a later plan.
+   * Throws at plugin registration when set without `jobs.enableConcurrencyControl: true`.
+   * Requires Payload's `enableConcurrencyControl` for app-level mutual exclusion under multi-node.
    */
   requireConcurrencyControl?: boolean;
 };
@@ -66,7 +70,7 @@ type ResolvedReliabilityOptions = {
   requireConcurrencyControl: boolean;
 };
 /** Resolve user reliability options to a fully-defaulted object, or `null` when disabled. */
-declare const resolveReliabilityOptions: (options: ReliabilityOptions | false | undefined) => ResolvedReliabilityOptions | null;
+declare const resolveReliabilityOptions: (options: ReliabilityOptions | boolean | undefined) => ResolvedReliabilityOptions | null;
 //#endregion
 //#region src/options.d.ts
 /** Improvements applied to Payload's built-in `payload-jobs` collection. */
@@ -104,11 +108,16 @@ type JobsPluginOptions = JobsOptions & {
   /** Disable the plugin entirely (incoming config returned untouched). */disabled?: boolean;
   /**
    * Reliability layer: stuck-job recovery, a heartbeat lease, and multi-node
-   * leader election. Opt-in (default off) because it adds fields to `payload-jobs`
-   * and a `payload-jobs-locks` collection, so adopters run one `migrate:create`.
+   * leader election. Off by default; pass `true` for defaults or an object to
+   * tune it. It adds fields to `payload-jobs` and a `payload-jobs-locks`
+   * collection, so adopters run one `migrate:create`.
+   */
+  reliability?: boolean | ReliabilityOptions;
+  /**
+   * Queue control: pause/resume, a status endpoint, and a hardened run endpoint.
+   * Off by default; pass `true` for defaults or an object to tune it.
    */
-  reliability?: false | ReliabilityOptions; /** Queue-control: pause/resume, a status endpoint, and a hardened run endpoint. Default off. */
-  queueControl?: false | QueueControlOptions;
+  queueControl?: boolean | QueueControlOptions;
 };
 //#endregion
 //#region src/execution/autoRunConfig.d.ts
@@ -185,15 +194,16 @@ type PauseState = {
 /** A durable, cluster-wide pause store backed by `payload.kv`. */
 type PauseStore = {
   pause: (queue?: string) => Promise<void>;
-  resume: (queue?: string) => Promise<void>;
+  /**
+   * Resume a named queue, clear the global flag, or reset everything.
+   * Pass `{ all: true }` to reset both layers at once (equivalent to `emptyPauseState()`).
+   */
+  resume: (queueOrOpts?: string | {
+    all: true;
+  }) => Promise<void>;
   getState: () => Promise<PauseState>;
   isPaused: (queue: string) => Promise<boolean>;
 };
-/**
- * Build the pause store over `payload.kv` (always available, durable, cluster-wide).
- * Pause and resume read-modify-write the single state value; this is last-writer-wins
- * (kv has no atomic compare-and-set), which is acceptable for rare admin actions.
- */
 declare const createPauseStore: (payload: Payload) => PauseStore;
 //#endregion
 //#region src/reliability/locksCollection.d.ts
@@ -227,8 +237,7 @@ type Worker = {
    * Gracefully drain and shut down (removes signal handlers, stops loops, requeues,
    * releases, destroys). Idempotent: repeated calls return the same in-flight drain.
    */
-  drain: () => Promise<DrainResult>; /** Stop the loops and remove signal handlers WITHOUT draining (test teardown). */
-  stop: () => void; /** Whether this node currently holds the given leadership role. */
+  drain: () => Promise<DrainResult>; /** Whether this node currently holds the given leadership role. */
   isLeader: (role: LeaderRole) => boolean;
 };
 /**
@@ -307,36 +316,51 @@ declare const vercelCrons: (options?: {
 }) => VercelCron[];
 //#endregion
 //#region src/queueControl/queueHealth.d.ts
-/** Per-queue health counts plus the last scheduled run. */
+/** Per-queue health: the seven canonical job states plus the orthogonal recovered count. */
 type QueueHealth = {
-  queue: string;
-  pending: number;
-  processing: number;
-  failed: number;
+  queue: string; /** Jobs waiting to run (no prior attempts, no future schedule). */
+  queued: number; /** Jobs scheduled in the future (`waitUntil > now`). */
+  scheduled: number; /** Jobs being retried after at least one failure. */
+  retrying: number; /** Jobs currently executing. */
+  processing: number; /** Jobs that completed successfully. */
+  succeeded: number; /** Jobs that completed with an unrecoverable error. */
+  failed: number; /** Jobs cancelled by the application. */
+  cancelled: number;
+  /**
+   * Jobs recovered at least once (`recoveryAttempts > 0`). Orthogonal to the seven states
+   * above: a recovered job may currently be retrying, succeeded, or failed. 0 unless
+   * reliability is enabled and `includeRecovered` is set.
+   */
   recovered: number;
   lastScheduledRun: string | null;
 };
 type QueueHealthReport = {
   totals: {
-    pending: number;
+    queued: number;
+    scheduled: number;
+    retrying: number;
     processing: number;
+    succeeded: number;
     failed: number;
+    cancelled: number;
     recovered: number;
   };
-  oldestPendingAgeMs: number | null;
+  oldestQueuedAgeMs: number | null;
   queues: QueueHealth[];
 };
 type GetQueueHealthOptions = {
   /** Queues to break out per-queue. Default ['default']. */queues?: string[]; /** Include the recovered count (requires the reliability `recoveryAttempts` field). */
-  includeRecovered?: boolean; /** Reference time for the oldest-pending age. Default now. */
+  includeRecovered?: boolean; /** Reference time for age and scheduled comparisons. Default now. */
   now?: Date;
 };
 /**
- * Aggregate queue health via `payload.count` per state (pending, processing, failed,
- * and, when reliability is on, recovered), plus the oldest-pending age and the last
- * scheduled run per queue. Reuses Payload's own run-selector predicates. The stats
- * global is read through `payload.db.findGlobal` inside a try/catch because that call
- * throws when the global does not exist (no schedule has run).
+ * Aggregate queue health via `payload.count`: the seven canonical states
+ * (queued, scheduled, retrying, processing, succeeded, failed, cancelled) plus an
+ * orthogonal `recovered` count (recoveryAttempts > 0) when `includeRecovered` is set.
+ * Reuses `statusWhere` from `deriveJobStatus` so the predicates are consistent
+ * with what the UI and individual job reads report. The stats global is read
+ * through `payload.db.findGlobal` inside a try/catch because that call throws
+ * when the global does not exist (no schedule has run yet).
  */
 declare const getQueueHealth: (payload: Payload, options?: GetQueueHealthOptions) => Promise<QueueHealthReport>;
 //#endregion
@@ -448,8 +472,10 @@ interface LeaseStore {
   acquireOrSteal: (role: LeaderRole, owner: string, ttlMs: number, now: Date) => Promise<LeaseResult>;
   /** Renew `role` if `owner` still holds it at `now`. Does not bump the fence token. */
   renew: (role: LeaderRole, owner: string, ttlMs: number, now: Date) => Promise<LeaseResult>;
-  /** Release `role` if `owner` holds it (graceful handoff: clears owner and expiry). */
-  release: (role: LeaderRole, owner: string) => Promise<void>;
+  /** Release `role` if `owner` holds it (graceful handoff: clears owner and expiry). Returns ok:false if the row did not match. */
+  release: (role: LeaderRole, owner: string) => Promise<{
+    ok: boolean;
+  }>;
   /** Read the current lease row (diagnostics and tests). */
   read: (role: LeaderRole) => Promise<LeaseRecord | null>;
 }
@@ -527,4 +553,4 @@ declare module 'payload' {
 declare const jobs: (options: JobsPluginOptions) => import("payload").Plugin;
 //#endregion
 export { ReliabilityOptions as $, singleNodePreset as A, LeaderRole as B, QueueHealth as C, VercelCron as D, TopologyPreset as E, CreateWorkerArgs as F, DrainOptions as G, createPauseStore as H, Worker as I, AutoRunConfigOptions as J, DrainResult as K, createWorker as L, JobStatus as M, JobStatusInput as N, multiNodePreset as O, deriveJobStatus as P, JobsPluginOptions as Q, JOBS_LOCKS_SLUG as R, GetQueueHealthOptions as S, getQueueHealth as T, PauseState as U, PauseStore as V, DrainDeps as W, autoRunConfig as X, AutoRunQueueConfig as Y, JobsOptions as Z, JobLeaseStore as _, RecoveryDecision as a, loggedInAccess as at, IdempotencyStore as b, createLeaderController as c, LeaseStore as d, ResolvedReliabilityOptions as et, createLeaseStore as f, JobLeaseRow as g, JobLeaseResult as h, runSweep as i, cronSecretAccess as it, vercelCrons as j, serverlessPreset as k, LeaseRecord as l, JobId as m, RunSweepArgs as n, QueueControlOptions as nt, decideRecovery as o, DeadLetterArgs as p, drainWorker as q, SweepResult as r, JobAccess as rt, LeaderController as s, jobs as t, resolveReliabilityOptions as tt, LeaseResult as u, StampResult as v, QueueHealthReport as w, withIdempotencyKey as x, createJobLeaseStore as y, LEADER_ROLES as z };
-//# sourceMappingURL=index-CYsbNe4q.d.ts.map
+//# sourceMappingURL=index-LgqeiXr2.d.ts.map

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { $ as ReliabilityOptions, A as singleNodePreset, B as LeaderRole, C as QueueHealth, D as VercelCron, E as TopologyPreset, F as CreateWorkerArgs, G as DrainOptions, H as createPauseStore, I as Worker, J as AutoRunConfigOptions, K as DrainResult, L as createWorker, M as JobStatus, N as JobStatusInput, O as multiNodePreset, P as deriveJobStatus, Q as JobsPluginOptions, R as JOBS_LOCKS_SLUG, S as GetQueueHealthOptions, T as getQueueHealth, U as PauseState, V as PauseStore, W as DrainDeps, X as autoRunConfig, Y as AutoRunQueueConfig, Z as JobsOptions, _ as JobLeaseStore, a as RecoveryDecision, at as loggedInAccess, b as IdempotencyStore, c as createLeaderController, d as LeaseStore, et as ResolvedReliabilityOptions, f as createLeaseStore, g as JobLeaseRow, h as JobLeaseResult, i as runSweep, it as cronSecretAccess, j as vercelCrons, k as serverlessPreset, l as LeaseRecord, m as JobId, n as RunSweepArgs, nt as QueueControlOptions, o as decideRecovery, p as DeadLetterArgs, q as drainWorker, r as SweepResult, rt as JobAccess, s as LeaderController, t as jobs, tt as resolveReliabilityOptions, u as LeaseResult, v as StampResult, w as QueueHealthReport, x as withIdempotencyKey, y as createJobLeaseStore, z as LEADER_ROLES } from "./index-CYsbNe4q.js";
+import { $ as ReliabilityOptions, A as singleNodePreset, B as LeaderRole, C as QueueHealth, D as VercelCron, E as TopologyPreset, F as CreateWorkerArgs, G as DrainOptions, H as createPauseStore, I as Worker, J as AutoRunConfigOptions, K as DrainResult, L as createWorker, M as JobStatus, N as JobStatusInput, O as multiNodePreset, P as deriveJobStatus, Q as JobsPluginOptions, R as JOBS_LOCKS_SLUG, S as GetQueueHealthOptions, T as getQueueHealth, U as PauseState, V as PauseStore, W as DrainDeps, X as autoRunConfig, Y as AutoRunQueueConfig, Z as JobsOptions, _ as JobLeaseStore, a as RecoveryDecision, at as loggedInAccess, b as IdempotencyStore, c as createLeaderController, d as LeaseStore, et as ResolvedReliabilityOptions, f as createLeaseStore, g as JobLeaseRow, h as JobLeaseResult, i as runSweep, it as cronSecretAccess, j as vercelCrons, k as serverlessPreset, l as LeaseRecord, m as JobId, n as RunSweepArgs, nt as QueueControlOptions, o as decideRecovery, p as DeadLetterArgs, q as drainWorker, r as SweepResult, rt as JobAccess, s as LeaderController, t as jobs, tt as resolveReliabilityOptions, u as LeaseResult, v as StampResult, w as QueueHealthReport, x as withIdempotencyKey, y as createJobLeaseStore, z as LEADER_ROLES } from "./index-LgqeiXr2.js";
 export { type AutoRunConfigOptions, type AutoRunQueueConfig, type CreateWorkerArgs, type DeadLetterArgs, type DrainDeps, type DrainOptions, type DrainResult, type GetQueueHealthOptions, type IdempotencyStore, JOBS_LOCKS_SLUG, type JobAccess, type JobId, type JobLeaseResult, type JobLeaseRow, type JobLeaseStore, type JobStatus, type JobStatusInput, type JobsOptions, type JobsPluginOptions, type JobsPluginOptions as PluginOptions, LEADER_ROLES, type LeaderController, type LeaderRole, type LeaseRecord, type LeaseResult, type LeaseStore, type PauseState, type PauseStore, type QueueControlOptions, type QueueHealth, type QueueHealthReport, type RecoveryDecision, type ReliabilityOptions, type ResolvedReliabilityOptions, type RunSweepArgs, type StampResult, type SweepResult, type TopologyPreset, type VercelCron, type Worker, autoRunConfig, createJobLeaseStore, createLeaderController, createLeaseStore, createPauseStore, createWorker, cronSecretAccess, decideRecovery, deriveJobStatus, drainWorker, getQueueHealth, jobs, loggedInAccess, multiNodePreset, resolveReliabilityOptions, runSweep, serverlessPreset, singleNodePreset, vercelCrons, withIdempotencyKey };