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

package/dist/index-CYsbNe4q.d.ts

@@ -0,0 +1,530 @@
+import { JobsConfig, Payload, PayloadComponent, PayloadRequest } from "payload";
+
+//#region src/plugin/resolve.d.ts
+/**
+ * A customization point: pass a value to replace our default, or a function to
+ * transform it. The function form receives the default so callers can compose
+ * (extend, filter, reorder) instead of rewriting from scratch.
+ */
+type Override<T> = ((defaults: T) => T) | T;
+//#endregion
+//#region src/queueControl/access.d.ts
+/** A jobs access checker (matches Payload's `jobs.access.run` shape). */
+type JobAccess = (args: {
+  req: PayloadRequest;
+}) => boolean | Promise<boolean>;
+type CronSecretAccessOptions = {
+  /** Env var holding the shared secret. Default `CRON_SECRET`. */envVar?: string;
+};
+/** The default endpoint guard: logged-in users only (safer than Payload's open default). */
+declare const loggedInAccess: JobAccess;
+/**
+ * An access checker for serverless cron triggers: a logged-in user passes, otherwise
+ * the request must carry `Authorization: Bearer ${process.env[envVar]}`. Payload ships
+ * no built-in secret check, so this implements the canonical Vercel-cron pattern.
+ */
+declare const cronSecretAccess: (options?: CronSecretAccessOptions) => JobAccess;
+//#endregion
+//#region src/queueControl/options.d.ts
+type QueueControlOptions = {
+  /** Gate the queue-control endpoints (and the native run endpoint). Default: logged-in users only. */access?: JobAccess; /** Queues to report per-queue health for. Default ['default']. */
+  queues?: string[];
+};
+//#endregion
+//#region src/reliability/options.d.ts
+/** Tuning for the jobs reliability layer. All durations are milliseconds. */
+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. */
+  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;
+  /**
+   * Serverless mode: when set, job staleness derives from this platform hard-kill
+   * duration instead of a heartbeat (heartbeats are meaningless when the function
+   * is killed at maxDuration with no SIGTERM).
+   */
+  serverless?: {
+    maxDurationMs: number;
+  };
+  /**
+   * Recommend (true) Payload's `enableConcurrencyControl` for app-level mutual
+   * exclusion under multi-node. Documentation-facing; consumed in a later plan.
+   */
+  requireConcurrencyControl?: boolean;
+};
+/** Reliability options with every value resolved. `null` means reliability is off. */
+type ResolvedReliabilityOptions = {
+  jobLeaseTtlMs: number;
+  heartbeatIntervalMs: number;
+  sweepIntervalMs: number;
+  maxRecoveries: number;
+  leaderLeaseTtlMs: number;
+  leaderId: string | null;
+  serverlessMaxDurationMs: number | null;
+  requireConcurrencyControl: boolean;
+};
+/** Resolve user reliability options to a fully-defaulted object, or `null` when disabled. */
+declare const resolveReliabilityOptions: (options: ReliabilityOptions | false | undefined) => ResolvedReliabilityOptions | null;
+//#endregion
+//#region src/options.d.ts
+/** Improvements applied to Payload's built-in `payload-jobs` collection. */
+type JobsOptions = {
+  /** Show the jobs collection in the admin. Defaults to visible (un-hidden). */hidden?: boolean; /** List columns for the jobs collection; replace or transform our defaults. */
+  defaultColumns?: Override<string[]>;
+  /**
+   * Treat an existing job as a read-only record (default `true`): execution-state
+   * fields are surfaced in the header and locked, inputs are editable only on
+   * Create. Set `false` to leave every field editable. Never disables Create.
+   */
+  readOnlyRecord?: boolean;
+  /**
+   * Per-field list-cell overrides, keyed by job field name. `false` keeps
+   * Payload's default cell; a component replaces it.
+   */
+  cells?: Record<string, PayloadComponent | false>; /** The derived Status column. `false` removes it; a component replaces our status cell. */
+  status?: PayloadComponent | false;
+  /**
+   * Components rendered between the search bar and the table. `false` removes our
+   * queue-health bar; an array replaces it.
+   */
+  beforeListTable?: PayloadComponent[] | false;
+  /**
+   * Per-status cap for the queue-health bar: counts above it render as `${cap}+`.
+   * Defaults to 100; `false` shows the exact count.
+   */
+  healthBarCap?: false | number;
+};
+/**
+ * Options for the jobs plugin. Improves the built-in `payload-jobs` collection;
+ * set `disabled` to leave the incoming config untouched.
+ */
+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`.
+   */
+  reliability?: false | ReliabilityOptions; /** Queue-control: pause/resume, a status endpoint, and a hardened run endpoint. Default off. */
+  queueControl?: false | QueueControlOptions;
+};
+//#endregion
+//#region src/execution/autoRunConfig.d.ts
+/**
+ * Payload's per-cron autoRun config. Payload 3.85.0 does not re-export the
+ * `AutorunCronConfig` type from its package root, so derive it from the array branch of
+ * the publicly exported `JobsConfig['autoRun']` (which Payload types as that element).
+ */
+type AutorunCronConfig = Extract<NonNullable<JobsConfig['autoRun']>, unknown[]>[number];
+/** One logical queue's autoRun cadence. */
+type AutoRunQueueConfig = {
+  queue: string; /** Cron cadence for this queue. Default every minute. */
+  cron?: string; /** Max jobs claimed per tick. Default 10. */
+  limit?: number;
+};
+type AutoRunConfigOptions = {
+  /** One entry per logical queue. Default a single `default` queue. */queues?: AutoRunQueueConfig[]; /** Suppress per-run info logging. Default true. */
+  silent?: boolean;
+  /**
+   * Disable native auto-scheduling on these crons. Default false. Set true when a
+   * `createWorker` owns scheduling (multi-node), so the cron only runs jobs.
+   */
+  disableScheduling?: boolean;
+};
+/**
+ * Build a production `jobs.autoRun` array: one Croner config per queue, silent by
+ * default, with Payload's own `protect: true` preventing overlap. This is the simple
+ * single-node and serverless-adjacent path where native autoRun safely handles both
+ * scheduling and running in one process. Multi-node deployments use `createWorker`
+ * instead, because native autoRun cannot gate scheduling to one elected leader (its
+ * only dynamic lever, `shouldAutoRun`, permanently stops the cron rather than pausing).
+ */
+declare const autoRunConfig: (options?: AutoRunConfigOptions) => AutorunCronConfig[];
+//#endregion
+//#region src/execution/drain.d.ts
+type DrainDeps = {
+  /** Stop the worker's interval loops (stop claiming new jobs). */stopLoops: () => void; /** Count this node's in-flight jobs (processing and claimed by it). */
+  countInFlight: () => Promise<number>; /** Requeue this node's remaining in-flight jobs. Returns how many were released. */
+  requeueStragglers: () => Promise<number>; /** Release the held scheduler and sweeper leadership leases. */
+  releaseLeadership: () => Promise<void>; /** Destroy the Payload instance (stops crons, closes the DB). */
+  destroy: () => Promise<void>; /** Wall-clock milliseconds (real in production, virtual in tests). */
+  now: () => number; /** Wait `ms` (real in production, virtual in tests). */
+  sleep: (ms: number) => Promise<void>;
+  logger?: {
+    info?: (m: string) => void;
+  };
+};
+type DrainOptions = {
+  /** Max wall-clock time to await in-flight jobs before requeuing stragglers. */drainTimeoutMs: number; /** How often to re-count in-flight jobs while draining. */
+  pollIntervalMs: number;
+};
+type DrainResult = {
+  inFlightAtStart: number;
+  remaining: number;
+  requeued: number;
+  timedOut: boolean;
+};
+/**
+ * Run the graceful-drain sequence: stop claiming, await this node's in-flight jobs up
+ * to a wall-clock budget, requeue any stragglers, release leadership, and destroy. The
+ * clock (`now`/`sleep`) is injected so tests drive it deterministically without real
+ * waiting. Always releases leadership and destroys, even when nothing was in flight.
+ */
+declare const drainWorker: (deps: DrainDeps, options: DrainOptions) => Promise<DrainResult>;
+//#endregion
+//#region src/queueControl/pauseState.d.ts
+/** Cluster-wide pause state: a global pause plus a set of paused queue names. */
+type PauseState = {
+  global: boolean;
+  queues: string[];
+};
+//#endregion
+//#region src/queueControl/pauseStore.d.ts
+/** A durable, cluster-wide pause store backed by `payload.kv`. */
+type PauseStore = {
+  pause: (queue?: string) => Promise<void>;
+  resume: (queue?: string) => 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
+/** Slug of the plugin-owned leases collection. Table name: payload_jobs_locks. */
+declare const JOBS_LOCKS_SLUG = "payload-jobs-locks";
+/** The two singleton leadership roles. */
+declare const LEADER_ROLES: readonly ["scheduler", "sweeper"];
+type LeaderRole = (typeof LEADER_ROLES)[number];
+//#endregion
+//#region src/execution/worker.d.ts
+type CreateWorkerArgs = {
+  payload: Payload;
+  reliability: ResolvedReliabilityOptions; /** Queues to run. Omit (or empty) to run all queues. */
+  queues?: string[]; /** When provided, the run loop honors cluster-wide pause/resume. */
+  pauseStore?: PauseStore; /** How often this node claims and runs jobs. Default 2000. */
+  runIntervalMs?: number; /** How often leadership is advanced and scheduling runs (leader only). Default leaderLeaseTtlMs / 3. */
+  maintenanceIntervalMs?: number; /** Max jobs per run tick. Default 10. */
+  runLimit?: number; /** Wall-clock budget to await in-flight jobs on drain. Default 30000. */
+  drainTimeoutMs?: number; /** How often the drain re-counts in-flight jobs. Default 500. */
+  pollIntervalMs?: number; /** Register SIGTERM/SIGINT handlers that drain then exit. Default true. */
+  installSignals?: boolean; /** Which signals to drain on. Default ['SIGTERM', 'SIGINT']. */
+  signals?: NodeJS.Signals[]; /** Injectable for tests: destroy (default payload.destroy), exit, wall clock. */
+  destroy?: () => Promise<void>;
+  exit?: (code: number) => void;
+  now?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+};
+type Worker = {
+  /** Start the run, maintenance, and sweep loops. */start: () => void;
+  /**
+   * 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. */
+  isLeader: (role: LeaderRole) => boolean;
+};
+/**
+ * A plugin-driven worker: runs jobs on every node, schedules and sweeps only while
+ * holding the corresponding leadership lease, and drains gracefully on SIGTERM/SIGINT.
+ * It owns its own timers (never Payload's autoRun cron), because Payload's
+ * `shouldAutoRun` gate permanently stops a cron and cannot follow dynamic leadership.
+ * Leadership timestamps use Payload's swappable `getCurrentDate()`; the drain budget
+ * uses the injected wall clock.
+ */
+declare const createWorker: (args: CreateWorkerArgs) => Worker;
+//#endregion
+//#region src/jobs/deriveJobStatus.d.ts
+/** The seven derived job states, by precedence (see `deriveJobStatus`). */
+type JobStatus = 'cancelled' | 'failed' | 'queued' | 'retrying' | 'running' | 'scheduled' | 'succeeded';
+/** The subset of `payload-jobs` fields a status is derived from. */
+interface JobStatusInput {
+  completedAt?: null | string;
+  error?: unknown;
+  hasError?: boolean | null;
+  processing?: boolean | null;
+  totalTried?: null | number;
+  waitUntil?: null | string;
+}
+/**
+ * Collapse a job's raw fields into one status. Payload has no status field; the
+ * state lives across `processing`, `hasError`, `error.cancelled`, `completedAt`,
+ * `waitUntil`, and `totalTried`. Order matters: the first matching rule wins.
+ */
+declare const deriveJobStatus: (job: JobStatusInput, now?: number) => JobStatus;
+//#endregion
+//#region src/presets/presets.d.ts
+/** The option groups a topology preset configures. */
+type TopologyPreset = {
+  reliability: ReliabilityOptions;
+  queueControl: QueueControlOptions;
+};
+/**
+ * Single-node Docker: one serial claimer, so claim races are moot. Reliability and
+ * queue control on with defaults; the sweeper runs from the in-process worker.
+ */
+declare const singleNodePreset: () => TopologyPreset;
+/**
+ * Multi-node Docker: leader-elected scheduling and sweeping (the default). Pass a
+ * stable `leaderId` per node if you do not want the generated hostname:pid identity.
+ */
+declare const multiNodePreset: (options?: {
+  leaderId?: string;
+}) => TopologyPreset;
+/**
+ * Serverless (Vercel): no long-running worker, so staleness derives from the platform
+ * hard-kill duration (the function maxDuration) rather than a heartbeat, and the run
+ * and sweep endpoints are guarded by the cron secret. Drive them with Vercel Cron
+ * (see `vercelCrons`).
+ */
+declare const serverlessPreset: (options: {
+  maxDurationMs: number;
+  cronSecretEnvVar?: string;
+}) => TopologyPreset;
+/** A `vercel.json` `crons` entry. */
+type VercelCron = {
+  path: string;
+  schedule: string;
+};
+/**
+ * Build the `vercel.json` `crons` array: one entry hitting the hardened run endpoint
+ * (all queues) and one hitting the sweep endpoint. Defaults to every minute (Vercel
+ * Pro). Vercel sends the `CRON_SECRET` as a Bearer token, which `cronSecretAccess`
+ * checks.
+ */
+declare const vercelCrons: (options?: {
+  runPath?: string;
+  sweepPath?: string;
+  runSchedule?: string;
+  sweepSchedule?: string;
+}) => VercelCron[];
+//#endregion
+//#region src/queueControl/queueHealth.d.ts
+/** Per-queue health counts plus the last scheduled run. */
+type QueueHealth = {
+  queue: string;
+  pending: number;
+  processing: number;
+  failed: number;
+  recovered: number;
+  lastScheduledRun: string | null;
+};
+type QueueHealthReport = {
+  totals: {
+    pending: number;
+    processing: number;
+    failed: number;
+    recovered: number;
+  };
+  oldestPendingAgeMs: 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. */
+  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).
+ */
+declare const getQueueHealth: (payload: Payload, options?: GetQueueHealthOptions) => Promise<QueueHealthReport>;
+//#endregion
+//#region src/reliability/concurrencyContract.d.ts
+/** A minimal store for at-most-once side-effect guarding, keyed by a stable idempotency key. */
+interface IdempotencyStore {
+  /** True if `key` was already marked done. */
+  has: (key: string) => Promise<boolean>;
+  /** Mark `key` done. Ideally written in the same transaction as the side effect. */
+  mark: (key: string) => Promise<void>;
+}
+/**
+ * Wrap a job handler so its side effect runs at most once per idempotency key, even
+ * when at-least-once delivery re-runs the job. The race this guards is not only
+ * redelivery: when the sweeper requeues a job whose lease expired while it was still
+ * running, the original execution cannot be aborted (Payload exposes no AbortSignal),
+ * so a second worker can run the handler concurrently with the first. Key on the
+ * stable unit of work, never the job id, so both executions resolve to the same key.
+ * The check and the mark are the caller's to make transactional (Payload's queue and
+ * the app data share one database, which makes that natural); this helper only
+ * sequences them around the handler. A skipped run returns `{ output: {} }`.
+ */
+declare const withIdempotencyKey: <A>(handler: (args: A) => Promise<unknown>, idem: {
+  keyFor: (args: A) => string;
+  store: IdempotencyStore;
+}) => ((args: A) => Promise<unknown>);
+//#endregion
+//#region src/reliability/jobLeaseStore.d.ts
+/** A Payload job id: a string on Mongo (ObjectId), a number on Postgres (serial). */
+type JobId = number | string;
+/** The result of a stamp (returns the new claim-generation fence token). */
+type StampResult = {
+  ok: boolean;
+  fenceToken: number;
+};
+/** The result of a renew/requeue/dead-letter attempt. */
+type JobLeaseResult = {
+  ok: boolean;
+};
+/** The lease-relevant columns of one `payload-jobs` row (diagnostics and tests). */
+type JobLeaseRow = {
+  processing: boolean;
+  leaseExpiresAt: Date | null;
+  claimedBy: string | null;
+  fenceToken: number;
+  recoveryAttempts: number;
+  updatedAt: Date;
+};
+/** Arguments for dead-lettering, grouped to stay within the 3-parameter lint cap. */
+type DeadLetterArgs = {
+  jobId: JobId;
+  now: Date;
+  fallbackMs: number;
+  error: Record<string, unknown>;
+};
+/**
+ * A fenced lease over a single `payload-jobs` row. Every write is one atomic
+ * conditional update at the database (Mongo single-document `findOneAndUpdate`, or
+ * Postgres `UPDATE ... WHERE <guard> RETURNING`), so two contenders never both win.
+ * Sibling to the Plan 1 locks `LeaseStore`; implemented per adapter because Payload's
+ * `db.updateOne` drops the `where` predicate when an `id` is given.
+ */
+interface JobLeaseStore {
+  /** Stamp a freshly-claimed job (guarded on `processing = true`); bumps the fence token. */
+  stampClaim: (jobId: JobId, owner: string, ttlMs: number, now: Date) => Promise<StampResult>;
+  /** Extend the lease iff this owner's fence token still matches. */
+  renew: (jobId: JobId, fenceToken: number, ttlMs: number, now: Date) => Promise<JobLeaseResult>;
+  /** Requeue a stale orphan (guarded on `processing = true` AND stale); increments recoveryAttempts. */
+  requeue: (jobId: JobId, now: Date, fallbackMs: number) => Promise<JobLeaseResult>;
+  /** Dead-letter a stale orphan at the recovery cap (same guard). */
+  deadLetter: (args: DeadLetterArgs) => Promise<JobLeaseResult>;
+  /**
+   * Requeue every in-flight job currently claimed by `owner`, in one bulk write, for
+   * graceful drain. Sets `processing: false`, clears the lease, increments
+   * recoveryAttempts, and bumps the fence token so a revived worker's renew fails.
+   * Returns how many rows were released. Unlike `requeue`, it does not require the
+   * lease to be stale (the node owns these claims and is shutting down).
+   */
+  releaseAllClaims: (owner: string) => Promise<{
+    released: number;
+  }>;
+  /** Read the lease columns of a job row. */
+  read: (jobId: JobId) => Promise<JobLeaseRow | null>;
+}
+/** Build the job-lease store for the running adapter. Throws for an unsupported adapter. */
+declare const createJobLeaseStore: (payload: Payload) => JobLeaseStore;
+//#endregion
+//#region src/reliability/leaseStore.d.ts
+/** The current state of one leadership lease row. */
+type LeaseRecord = {
+  role: LeaderRole;
+  owner: string | null;
+  leaseExpiresAt: Date | null;
+  fenceToken: number;
+};
+/** The outcome of an acquire/renew attempt. */
+type LeaseResult = {
+  /** Whether this caller now holds (or still holds) the lease. */ok: boolean; /** The fence token after the attempt (monotonic; only meaningful when ok). */
+  fenceToken: number;
+};
+/**
+ * A distributed lease over the `payload-jobs-locks` rows. Every method is a single
+ * atomic conditional write at the database, so two contenders never both win.
+ * Implemented per adapter because Payload's `db.updateOne` drops the `where`
+ * predicate when an `id` is given (validated), so it cannot express a compare-and-set.
+ */
+interface LeaseStore {
+  /** Acquire `role` if free or expired at `now`. Bumps the fence token on success. */
+  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>;
+  /** Read the current lease row (diagnostics and tests). */
+  read: (role: LeaderRole) => Promise<LeaseRecord | null>;
+}
+/** Build the lease store for the running adapter. Throws for an unsupported adapter. */
+declare const createLeaseStore: (payload: Payload) => LeaseStore;
+//#endregion
+//#region src/reliability/leaderController.d.ts
+type LeaderController = {
+  /** Drive one acquire/renew cycle at `now`. Safe to call repeatedly. */tick: (now: Date) => Promise<void>; /** Whether this controller currently holds leadership. */
+  isLeader: () => boolean; /** The fence token of the held lease, or 0 when not leading. */
+  fenceToken: () => number; /** Relinquish leadership now (graceful handoff). */
+  release: () => Promise<void>;
+};
+type LeaderControllerArgs = {
+  store: LeaseStore;
+  role: LeaderRole;
+  ownerId: string;
+  ttlMs: number;
+};
+/**
+ * Turns a lease into leadership. On each `tick`: if not leading, try to acquire/steal;
+ * if leading, renew. A failed renew (the lease was stolen while this node was paused
+ * past expiry) drops leadership immediately, so a zombie never keeps acting. No timer
+ * lives here; a caller schedules `tick` at `ttlMs / 3`.
+ */
+declare const createLeaderController: (args: LeaderControllerArgs) => LeaderController;
+//#endregion
+//#region src/reliability/recoveryDecision.d.ts
+/** What the sweeper does with a reclaimed orphan. */
+type RecoveryDecision = 'deadLetter' | 'requeue';
+/**
+ * Requeue an orphaned job while it is below the recovery cap; dead-letter once it
+ * reaches the cap, to stop a poison job from thrashing the queue. `recoveryAttempts`
+ * is the count before this pass (a requeue increments it). `maxRecoveries` of 0
+ * dead-letters on the first orphan.
+ */
+declare const decideRecovery: (recoveryAttempts: number, maxRecoveries: number) => RecoveryDecision;
+//#endregion
+//#region src/reliability/sweeper.d.ts
+/** What one sweep pass did. */
+type SweepResult = {
+  scanned: number;
+  requeued: number;
+  deadLettered: number;
+};
+type RunSweepArgs = {
+  payload: Payload;
+  options: ResolvedReliabilityOptions; /** Reuse a store (tests); built from `payload` otherwise. */
+  store?: JobLeaseStore; /** The instant the pass runs at; defaults to the swappable clock. */
+  now?: Date; /** Max candidates per pass. Default 100. */
+  limit?: number; /** Leadership gate. When false the pass is a no-op. Default true. */
+  isLeader?: boolean;
+};
+/**
+ * One sweep pass: find stale `processing: true` orphans and either requeue them
+ * (below the recovery cap) or dead-letter them (at the cap), each through a fenced
+ * conditional write that re-checks staleness, so a job that renewed between the find
+ * and the write is skipped and two overlapping sweepers never both reclaim the same
+ * orphan. Gated by leadership: callers pass `isLeader` from the Plan 1 sweeper lease.
+ */
+declare const runSweep: (args: RunSweepArgs) => Promise<SweepResult>;
+//#endregion
+//#region src/index.d.ts
+declare module 'payload' {
+  interface RegisteredPlugins {
+    '@10x-media/jobs': JobsPluginOptions;
+  }
+}
+/**
+ * Jobs plugin for Payload v3. Enhances the built-in `payload-jobs` collection
+ * with an ops dashboard (status, queue health, error and log panels) and the
+ * supporting i18n. Authored with `definePlugin` so the automations and webhooks
+ * plugins can detect it by slug. Runs first (`order: 0`).
+ */
+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

package/dist/index.d.ts

@@ -0,0 +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";
+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 };