@chidchanun/bcp 0.2.8 → 0.2.10

package/packages/client/src/jobs.mjs

@@ -0,0 +1,2289 @@
+// packages/server/src/jobs.ts
+import {
+  randomUUID
+} from "node:crypto";
+function createMemoryJobQueueAdapter() {
+  const jobs = /* @__PURE__ */ new Map();
+  const deadLetters = /* @__PURE__ */ new Map();
+  const recoverStale = (now, options = {}) => {
+    const limit = normalizePositiveInteger(
+      options.limit ?? 100,
+      "recovery limit"
+    );
+    const stale = Array.from(
+      jobs.values()
+    ).filter(
+      (job) => job.state === "running" && job.leaseUntil !== void 0 && job.leaseUntil <= now
+    ).sort(
+      (left, right) => (left.leaseUntil ?? 0) - (right.leaseUntil ?? 0) || left.id.localeCompare(
+        right.id
+      )
+    ).slice(
+      0,
+      limit
+    );
+    for (const job of stale) {
+      job.state = "queued";
+      job.availableAt = now;
+      job.startedAt = void 0;
+      clearLease(job);
+      job.recoveredAt = now;
+    }
+    return stale.length;
+  };
+  return {
+    async enqueue(job) {
+      if (jobs.has(job.id)) {
+        throw new Error(
+          `BCP Jobs: job id "${job.id}" already exists.`
+        );
+      }
+      jobs.set(
+        job.id,
+        cloneJob(job)
+      );
+    },
+    async reserve(now, options) {
+      recoverStale(
+        now,
+        {
+          limit: 100
+        }
+      );
+      const candidate = Array.from(
+        jobs.values()
+      ).filter(
+        (job) => job.state === "queued" && job.availableAt <= now
+      ).sort(
+        (left, right) => left.availableAt - right.availableAt || left.createdAt - right.createdAt || left.id.localeCompare(right.id)
+      )[0];
+      if (!candidate) {
+        return null;
+      }
+      candidate.state = "running";
+      candidate.attempts += 1;
+      candidate.startedAt = now;
+      candidate.error = void 0;
+      candidate.recoveredAt = void 0;
+      if (options) {
+        candidate.leaseOwner = normalizeWorkerId(
+          options.ownerId
+        );
+        candidate.leaseUntil = now + normalizePositiveInteger(
+          options.visibilityTimeoutMs,
+          "visibilityTimeoutMs"
+        );
+        candidate.heartbeatAt = now;
+      }
+      return cloneJob(candidate);
+    },
+    async complete(id, completedAt, ownerId) {
+      const job = jobs.get(id);
+      if (!job || job.state === "cancelled" || !leaseOwnerMatches(
+        job,
+        ownerId
+      )) {
+        return;
+      }
+      job.state = "succeeded";
+      job.completedAt = completedAt;
+      job.error = void 0;
+      clearLease(job);
+      deadLetters.delete(id);
+    },
+    async fail(id, options) {
+      const job = jobs.get(id);
+      if (!job || job.state === "cancelled" || !leaseOwnerMatches(
+        job,
+        options.ownerId
+      )) {
+        return;
+      }
+      job.error = options.error;
+      clearLease(job);
+      if (options.retryAt !== void 0 && job.attempts < job.maxAttempts) {
+        job.state = "queued";
+        job.availableAt = options.retryAt;
+        job.startedAt = void 0;
+        return;
+      }
+      job.state = "failed";
+      job.completedAt = options.failedAt;
+      deadLetters.set(
+        id,
+        {
+          ...cloneJob(job),
+          state: "failed",
+          deadLetteredAt: options.failedAt
+        }
+      );
+    },
+    async cancel(id, cancelledAt) {
+      const job = jobs.get(id);
+      if (!job || job.state === "succeeded" || job.state === "failed" || job.state === "cancelled") {
+        return false;
+      }
+      job.state = "cancelled";
+      job.completedAt = cancelledAt;
+      clearLease(job);
+      return true;
+    },
+    async get(id) {
+      const job = jobs.get(id);
+      return job ? cloneJob(job) : null;
+    },
+    async list() {
+      return Array.from(
+        jobs.values()
+      ).map(cloneJob).sort(
+        (left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id)
+      );
+    },
+    async heartbeat(id, options) {
+      const job = jobs.get(id);
+      if (!job || job.state !== "running" || job.leaseOwner !== options.ownerId) {
+        return false;
+      }
+      const visibilityTimeoutMs = normalizePositiveInteger(
+        options.visibilityTimeoutMs,
+        "visibilityTimeoutMs"
+      );
+      job.heartbeatAt = options.heartbeatAt;
+      job.leaseUntil = options.heartbeatAt + visibilityTimeoutMs;
+      return true;
+    },
+    async recoverStale(now, options) {
+      return recoverStale(
+        now,
+        options
+      );
+    },
+    async listDeadLetters() {
+      return Array.from(
+        deadLetters.values()
+      ).map(cloneDeadLetter).sort(
+        (left, right) => left.deadLetteredAt - right.deadLetteredAt || left.id.localeCompare(
+          right.id
+        )
+      );
+    },
+    async requeueDeadLetter(id, now, options = {}) {
+      const job = jobs.get(id);
+      if (!job || job.state !== "failed" || !deadLetters.has(id)) {
+        return false;
+      }
+      const delayMs = normalizeNonNegativeNumber(
+        options.delayMs ?? 0,
+        "delayMs"
+      );
+      job.state = "queued";
+      job.availableAt = now + delayMs;
+      job.startedAt = void 0;
+      job.completedAt = void 0;
+      job.error = void 0;
+      job.recoveredAt = void 0;
+      clearLease(job);
+      if (options.resetAttempts !== false) {
+        job.attempts = 0;
+      }
+      deadLetters.delete(id);
+      return true;
+    },
+    async cleanup(options) {
+      const states = new Set(
+        options.states ?? [
+          "succeeded",
+          "failed",
+          "cancelled"
+        ]
+      );
+      let removed = 0;
+      for (const [
+        id,
+        job
+      ] of jobs) {
+        if (!states.has(
+          job.state
+        ) || job.completedAt === void 0 || job.completedAt >= options.before) {
+          continue;
+        }
+        jobs.delete(id);
+        deadLetters.delete(id);
+        removed += 1;
+      }
+      return removed;
+    },
+    async stats() {
+      return calculateJobStats(
+        Array.from(
+          jobs.values()
+        ),
+        deadLetters.size
+      );
+    },
+    clear() {
+      jobs.clear();
+      deadLetters.clear();
+    }
+  };
+}
+function createJobQueue(options = {}) {
+  const adapter = options.adapter ?? createMemoryJobQueueAdapter();
+  const handlers = /* @__PURE__ */ new Map();
+  const workers = /* @__PURE__ */ new Set();
+  const now = options.now ?? Date.now;
+  const idFactory = options.idFactory ?? randomUUID;
+  const defaultMaxAttempts = normalizePositiveInteger(
+    options.defaultMaxAttempts ?? 3,
+    "defaultMaxAttempts"
+  );
+  const retryDelay = options.retryDelayMs ?? ((attempt) => Math.min(
+    3e4,
+    1e3 * 2 ** Math.max(
+      0,
+      attempt - 1
+    )
+  ));
+  const queue = {
+    adapter,
+    register(name, handler) {
+      const normalizedName = normalizeJobName(name);
+      if (typeof handler !== "function") {
+        throw new TypeError(
+          "BCP Jobs: handler must be a function."
+        );
+      }
+      if (handlers.has(
+        normalizedName
+      )) {
+        throw new Error(
+          `BCP Jobs: handler "${normalizedName}" is already registered.`
+        );
+      }
+      const registeredHandler = handler;
+      handlers.set(
+        normalizedName,
+        registeredHandler
+      );
+      return () => {
+        if (handlers.get(
+          normalizedName
+        ) === registeredHandler) {
+          handlers.delete(
+            normalizedName
+          );
+        }
+      };
+    },
+    async enqueue(name, payload, enqueueOptions = {}) {
+      const createdAt = now();
+      const delayMs = normalizeNonNegativeNumber(
+        enqueueOptions.delayMs ?? 0,
+        "delayMs"
+      );
+      const maxAttempts = normalizePositiveInteger(
+        enqueueOptions.maxAttempts ?? defaultMaxAttempts,
+        "maxAttempts"
+      );
+      const id = normalizeJobId(
+        enqueueOptions.id ?? idFactory()
+      );
+      const job = {
+        id,
+        name: normalizeJobName(name),
+        payload,
+        state: "queued",
+        attempts: 0,
+        maxAttempts,
+        createdAt,
+        availableAt: createdAt + delayMs
+      };
+      await adapter.enqueue(job);
+      return cloneJob(job);
+    },
+    get(id) {
+      return adapter.get(
+        normalizeJobId(id)
+      );
+    },
+    list() {
+      return adapter.list();
+    },
+    cancel(id) {
+      return adapter.cancel(
+        normalizeJobId(id),
+        now()
+      );
+    },
+    async processNext(signal = new AbortController().signal, processOptions = {}) {
+      if (signal.aborted) {
+        return false;
+      }
+      const visibilityTimeoutMs = normalizePositiveInteger(
+        processOptions.visibilityTimeoutMs ?? 3e4,
+        "visibilityTimeoutMs"
+      );
+      const heartbeatIntervalMs = normalizePositiveInteger(
+        processOptions.heartbeatIntervalMs ?? Math.max(
+          1,
+          Math.floor(
+            visibilityTimeoutMs / 3
+          )
+        ),
+        "heartbeatIntervalMs"
+      );
+      const ownerId = normalizeWorkerId(
+        processOptions.ownerId ?? `process-${randomUUID()}`
+      );
+      if (adapter.recoverStale) {
+        await adapter.recoverStale(
+          now(),
+          {
+            limit: normalizePositiveInteger(
+              processOptions.recoveryLimit ?? 100,
+              "recoveryLimit"
+            )
+          }
+        );
+      }
+      const job = await adapter.reserve(
+        now(),
+        {
+          ownerId,
+          visibilityTimeoutMs
+        }
+      );
+      if (!job) {
+        return false;
+      }
+      const stopHeartbeat = startJobHeartbeat(
+        adapter,
+        job.id,
+        ownerId,
+        visibilityTimeoutMs,
+        heartbeatIntervalMs,
+        now,
+        signal
+      );
+      const handler = handlers.get(job.name);
+      try {
+        if (!handler) {
+          await adapter.fail(
+            job.id,
+            {
+              error: `No handler registered for job "${job.name}".`,
+              failedAt: now(),
+              ownerId
+            }
+          );
+          return true;
+        }
+        try {
+          await handler({
+            job: cloneJob(job),
+            payload: job.payload,
+            signal
+          });
+          await adapter.complete(
+            job.id,
+            now(),
+            ownerId
+          );
+        } catch (error) {
+          const failedAt = now();
+          const shouldRetry = job.attempts < job.maxAttempts;
+          const retryAt = shouldRetry ? failedAt + resolveRetryDelay(
+            retryDelay,
+            job.attempts
+          ) : void 0;
+          await adapter.fail(
+            job.id,
+            {
+              error: formatJobError(
+                error
+              ),
+              failedAt,
+              retryAt,
+              ownerId
+            }
+          );
+        }
+        return true;
+      } finally {
+        stopHeartbeat();
+      }
+    },
+    startWorker(workerOptions = {}) {
+      const worker = createWorker(
+        queue,
+        workerOptions,
+        () => workers.delete(
+          worker
+        )
+      );
+      workers.add(worker);
+      return worker;
+    },
+    async recoverStale(recoverOptions = {}) {
+      if (!adapter.recoverStale) {
+        return 0;
+      }
+      return adapter.recoverStale(
+        now(),
+        recoverOptions
+      );
+    },
+    async deadLetters() {
+      return adapter.listDeadLetters ? adapter.listDeadLetters() : [];
+    },
+    async requeueDeadLetter(id, requeueOptions = {}) {
+      if (!adapter.requeueDeadLetter) {
+        return false;
+      }
+      return adapter.requeueDeadLetter(
+        normalizeJobId(id),
+        now(),
+        requeueOptions
+      );
+    },
+    async cleanup(cleanupOptions) {
+      if (!adapter.cleanup) {
+        return 0;
+      }
+      const before = normalizeNonNegativeNumber(
+        cleanupOptions.before,
+        "cleanup before"
+      );
+      return adapter.cleanup({
+        ...cleanupOptions,
+        before
+      });
+    },
+    async stats() {
+      if (adapter.stats) {
+        return adapter.stats();
+      }
+      const jobs = await adapter.list();
+      return calculateJobStats(
+        jobs,
+        adapter.listDeadLetters ? (await adapter.listDeadLetters()).length : 0
+      );
+    },
+    async close() {
+      await Promise.all(
+        Array.from(
+          workers,
+          (worker) => worker.stop()
+        )
+      );
+      if (adapter.close) {
+        await adapter.close();
+      }
+    }
+  };
+  return queue;
+}
+function createWorker(queue, options, onStop) {
+  const concurrency = normalizePositiveInteger(
+    options.concurrency ?? 1,
+    "concurrency"
+  );
+  const pollIntervalMs = normalizeNonNegativeNumber(
+    options.pollIntervalMs ?? 250,
+    "pollIntervalMs"
+  );
+  const visibilityTimeoutMs = normalizePositiveInteger(
+    options.visibilityTimeoutMs ?? 3e4,
+    "visibilityTimeoutMs"
+  );
+  const heartbeatIntervalMs = normalizePositiveInteger(
+    options.heartbeatIntervalMs ?? Math.max(
+      1,
+      Math.floor(
+        visibilityTimeoutMs / 3
+      )
+    ),
+    "heartbeatIntervalMs"
+  );
+  const recoveryLimit = normalizePositiveInteger(
+    options.recoveryLimit ?? 100,
+    "recoveryLimit"
+  );
+  const workerId = normalizeWorkerId(
+    options.workerId ?? `worker-${randomUUID()}`
+  );
+  const controller = new AbortController();
+  let running = true;
+  let stopPromise = null;
+  const loops = Array.from(
+    {
+      length: concurrency
+    },
+    (_, index) => runWorkerLoop(
+      queue,
+      controller.signal,
+      pollIntervalMs,
+      {
+        ownerId: `${workerId}:${index + 1}`,
+        visibilityTimeoutMs,
+        heartbeatIntervalMs,
+        recoveryLimit
+      },
+      options.onError
+    )
+  );
+  return {
+    get running() {
+      return running;
+    },
+    workerId,
+    stop() {
+      if (stopPromise) {
+        return stopPromise;
+      }
+      running = false;
+      controller.abort();
+      stopPromise = Promise.allSettled(
+        loops
+      ).then(
+        () => {
+          onStop();
+        }
+      );
+      return stopPromise;
+    }
+  };
+}
+async function runWorkerLoop(queue, signal, pollIntervalMs, options, onError) {
+  while (!signal.aborted) {
+    let processed = false;
+    try {
+      processed = await queue.processNext(
+        signal,
+        options
+      );
+    } catch (error) {
+      if (signal.aborted) {
+        break;
+      }
+      if (onError) {
+        await onError(error);
+      } else {
+        throw error;
+      }
+    }
+    if (!processed && !signal.aborted) {
+      await sleep(
+        pollIntervalMs,
+        signal
+      );
+    }
+  }
+}
+function startJobHeartbeat(adapter, jobId, ownerId, visibilityTimeoutMs, heartbeatIntervalMs, now, signal) {
+  if (!adapter.heartbeat) {
+    return () => void 0;
+  }
+  let stopped = false;
+  let timeout;
+  const schedule = () => {
+    if (stopped || signal.aborted) {
+      return;
+    }
+    timeout = setTimeout(
+      async () => {
+        if (stopped || signal.aborted) {
+          return;
+        }
+        try {
+          const active = await adapter.heartbeat?.(
+            jobId,
+            {
+              ownerId,
+              heartbeatAt: now(),
+              visibilityTimeoutMs
+            }
+          );
+          if (active !== false) {
+            schedule();
+          }
+        } catch {
+          schedule();
+        }
+      },
+      heartbeatIntervalMs
+    );
+  };
+  schedule();
+  return () => {
+    stopped = true;
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  };
+}
+function sleep(durationMs, signal) {
+  if (signal.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise(
+    (resolve) => {
+      const timeout = setTimeout(
+        finish,
+        durationMs
+      );
+      const onAbort = () => finish();
+      signal.addEventListener(
+        "abort",
+        onAbort,
+        {
+          once: true
+        }
+      );
+      function finish() {
+        clearTimeout(timeout);
+        signal.removeEventListener(
+          "abort",
+          onAbort
+        );
+        resolve();
+      }
+    }
+  );
+}
+function calculateJobStats(jobs, deadLetters) {
+  const stats = {
+    total: jobs.length,
+    queued: 0,
+    running: 0,
+    succeeded: 0,
+    failed: 0,
+    cancelled: 0,
+    deadLetters
+  };
+  for (const job of jobs) {
+    stats[job.state] += 1;
+  }
+  return stats;
+}
+function resolveRetryDelay(value, attempt) {
+  const delay = typeof value === "function" ? value(attempt) : value;
+  return normalizeNonNegativeNumber(
+    delay,
+    "retryDelayMs"
+  );
+}
+function normalizeJobName(value) {
+  const name = String(value).trim();
+  if (!name) {
+    throw new TypeError(
+      "BCP Jobs: job name must be a non-empty string."
+    );
+  }
+  if (name.length > 200) {
+    throw new TypeError(
+      "BCP Jobs: job name must not exceed 200 characters."
+    );
+  }
+  return name;
+}
+function normalizeJobId(value) {
+  const id = String(value).trim();
+  if (!id) {
+    throw new TypeError(
+      "BCP Jobs: job id must be a non-empty string."
+    );
+  }
+  if (id.length > 200) {
+    throw new TypeError(
+      "BCP Jobs: job id must not exceed 200 characters."
+    );
+  }
+  return id;
+}
+function normalizeWorkerId(value) {
+  const id = String(value).trim();
+  if (!id) {
+    throw new TypeError(
+      "BCP Jobs: worker id must be a non-empty string."
+    );
+  }
+  return id;
+}
+function normalizePositiveInteger(value, field) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new TypeError(
+      `BCP Jobs: ${field} must be a positive integer.`
+    );
+  }
+  return value;
+}
+function normalizeNonNegativeNumber(value, field) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new TypeError(
+      `BCP Jobs: ${field} must be a non-negative finite number.`
+    );
+  }
+  return Math.floor(value);
+}
+function formatJobError(error) {
+  if (error instanceof Error) {
+    return error.message || error.name;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    const serialized = JSON.stringify(error);
+    return serialized ?? String(error);
+  } catch {
+    return String(error);
+  }
+}
+function leaseOwnerMatches(job, ownerId) {
+  if (ownerId === void 0) {
+    return true;
+  }
+  return job.leaseOwner === ownerId;
+}
+function clearLease(job) {
+  job.leaseOwner = void 0;
+  job.leaseUntil = void 0;
+  job.heartbeatAt = void 0;
+}
+function cloneJob(job) {
+  return {
+    ...job
+  };
+}
+function cloneDeadLetter(job) {
+  return {
+    ...job
+  };
+}
+
+// packages/server/src/job-scheduler.ts
+import {
+  randomUUID as randomUUID2
+} from "node:crypto";
+function createMemoryJobScheduleStore() {
+  const schedules = /* @__PURE__ */ new Map();
+  return {
+    async upsert(schedule) {
+      schedules.set(
+        schedule.id,
+        cloneSchedule(
+          schedule
+        )
+      );
+    },
+    async get(id) {
+      const schedule = schedules.get(id);
+      return schedule ? cloneSchedule(
+        schedule
+      ) : null;
+    },
+    async list() {
+      return Array.from(
+        schedules.values()
+      ).map(
+        cloneSchedule
+      ).sort(
+        (left, right) => left.nextRunAt - right.nextRunAt || left.id.localeCompare(
+          right.id
+        )
+      );
+    },
+    async remove(id) {
+      return schedules.delete(id);
+    },
+    async acquireDue(now, options) {
+      const due = Array.from(
+        schedules.values()
+      ).filter(
+        (schedule) => schedule.nextRunAt <= now && (schedule.leaseUntil === void 0 || schedule.leaseUntil <= now)
+      ).sort(
+        (left, right) => left.nextRunAt - right.nextRunAt || left.id.localeCompare(
+          right.id
+        )
+      ).slice(
+        0,
+        options.limit
+      );
+      for (const schedule of due) {
+        schedule.leaseOwner = options.ownerId;
+        schedule.leaseUntil = now + options.leaseMs;
+      }
+      return due.map(
+        cloneSchedule
+      );
+    },
+    async complete(id, options) {
+      const schedule = schedules.get(id);
+      if (!schedule || schedule.leaseOwner !== options.ownerId) {
+        return;
+      }
+      schedule.lastRunAt = options.lastRunAt;
+      schedule.nextRunAt = options.nextRunAt;
+      schedule.updatedAt = options.updatedAt;
+      schedule.leaseOwner = void 0;
+      schedule.leaseUntil = void 0;
+    },
+    async release(id, ownerId) {
+      const schedule = schedules.get(id);
+      if (!schedule || schedule.leaseOwner !== ownerId) {
+        return;
+      }
+      schedule.leaseOwner = void 0;
+      schedule.leaseUntil = void 0;
+    },
+    clear() {
+      schedules.clear();
+    }
+  };
+}
+function createJobScheduler(options) {
+  if (!options || !options.queue) {
+    throw new TypeError(
+      "BCP Jobs: createJobScheduler requires a queue."
+    );
+  }
+  const queue = options.queue;
+  const store = options.store ?? createMemoryJobScheduleStore();
+  const now = options.now ?? Date.now;
+  const idFactory = options.idFactory ?? randomUUID2;
+  const ownerId = normalizeIdentifier(
+    options.ownerId ?? `scheduler-${randomUUID2()}`,
+    "scheduler owner id"
+  );
+  const runners = /* @__PURE__ */ new Set();
+  const scheduler = {
+    queue,
+    store,
+    ownerId,
+    async schedule(jobName, payload, scheduleOptions) {
+      const currentTime = normalizeTimestamp(
+        now(),
+        "current time"
+      );
+      const schedule = normalizeSchedule(
+        scheduleOptions
+      );
+      const id = normalizeIdentifier(
+        scheduleOptions.id ?? idFactory(),
+        "schedule id"
+      );
+      const startAt = scheduleOptions.startAt === void 0 ? void 0 : normalizeTimestamp(
+        scheduleOptions.startAt instanceof Date ? scheduleOptions.startAt.getTime() : scheduleOptions.startAt,
+        "startAt"
+      );
+      const maxAttempts = scheduleOptions.maxAttempts === void 0 ? void 0 : normalizePositiveInteger2(
+        scheduleOptions.maxAttempts,
+        "maxAttempts"
+      );
+      const nextRunAt = startAt ?? nextScheduleTime(
+        schedule,
+        currentTime
+      );
+      const record = {
+        id,
+        jobName: normalizeIdentifier(
+          jobName,
+          "job name"
+        ),
+        payload,
+        schedule,
+        createdAt: currentTime,
+        updatedAt: currentTime,
+        nextRunAt,
+        maxAttempts
+      };
+      await store.upsert(
+        record
+      );
+      return cloneSchedule(
+        record
+      );
+    },
+    get(id) {
+      return store.get(
+        normalizeIdentifier(
+          id,
+          "schedule id"
+        )
+      );
+    },
+    list() {
+      return store.list();
+    },
+    remove(id) {
+      return store.remove(
+        normalizeIdentifier(
+          id,
+          "schedule id"
+        )
+      );
+    },
+    async runDue(runOptions = {}) {
+      const currentTime = normalizeTimestamp(
+        now(),
+        "current time"
+      );
+      const limit = normalizePositiveInteger2(
+        runOptions.limit ?? 100,
+        "limit"
+      );
+      const leaseMs = normalizePositiveInteger2(
+        runOptions.leaseMs ?? 3e4,
+        "leaseMs"
+      );
+      const schedules = await store.acquireDue(
+        currentTime,
+        {
+          ownerId,
+          leaseMs,
+          limit
+        }
+      );
+      let enqueued = 0;
+      for (const scheduleRecord of schedules) {
+        const scheduledFor = scheduleRecord.nextRunAt;
+        const runId = createScheduledRunId(
+          scheduleRecord.id,
+          scheduledFor
+        );
+        try {
+          await queue.enqueue(
+            scheduleRecord.jobName,
+            scheduleRecord.payload,
+            {
+              id: runId,
+              maxAttempts: scheduleRecord.maxAttempts
+            }
+          );
+          enqueued += 1;
+        } catch (error) {
+          if (!isDuplicateJobIdError(
+            error
+          )) {
+            await store.release(
+              scheduleRecord.id,
+              ownerId
+            );
+            throw error;
+          }
+        }
+        const nextRunAt = nextScheduleTime(
+          scheduleRecord.schedule,
+          scheduledFor
+        );
+        await store.complete(
+          scheduleRecord.id,
+          {
+            ownerId,
+            lastRunAt: scheduledFor,
+            nextRunAt,
+            updatedAt: currentTime
+          }
+        );
+      }
+      return enqueued;
+    },
+    start(startOptions = {}) {
+      const runner = createSchedulerRunner(
+        scheduler,
+        startOptions,
+        () => runners.delete(
+          runner
+        )
+      );
+      runners.add(runner);
+      return runner;
+    },
+    async close() {
+      await Promise.all(
+        Array.from(
+          runners,
+          (runner) => runner.stop()
+        )
+      );
+      if (store.close) {
+        await store.close();
+      }
+    }
+  };
+  return scheduler;
+}
+function nextScheduleTime(schedule, after) {
+  const timestamp = normalizeTimestamp(
+    after,
+    "schedule reference time"
+  );
+  if (schedule.kind === "interval") {
+    return timestamp + normalizePositiveInteger2(
+      schedule.everyMs,
+      "everyMs"
+    );
+  }
+  return nextCronTime(
+    schedule.expression,
+    timestamp
+  );
+}
+function nextCronTime(expression, after) {
+  const cron = parseCronExpression(
+    expression
+  );
+  const afterTimestamp = normalizeTimestamp(
+    after,
+    "cron reference time"
+  );
+  const minute = 6e4;
+  let candidate = Math.floor(
+    afterTimestamp / minute
+  ) * minute + minute;
+  const maxIterations = 366 * 24 * 60 * 8;
+  for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+    const date = new Date(candidate);
+    if (cron.month.has(
+      date.getUTCMonth() + 1
+    ) && cron.hour.has(
+      date.getUTCHours()
+    ) && cron.minute.has(
+      date.getUTCMinutes()
+    ) && matchesCronDay(
+      cron,
+      date
+    )) {
+      return candidate;
+    }
+    candidate += minute;
+  }
+  throw new RangeError(
+    `BCP Jobs: cron expression "${expression}" did not produce a run time within 8 years.`
+  );
+}
+function createSchedulerRunner(scheduler, options, onStop) {
+  const pollIntervalMs = normalizePositiveInteger2(
+    options.pollIntervalMs ?? 1e3,
+    "pollIntervalMs"
+  );
+  const runOptions = {
+    limit: options.limit,
+    leaseMs: options.leaseMs
+  };
+  const controller = new AbortController();
+  let running = true;
+  let stopPromise = null;
+  const loop = runSchedulerLoop(
+    scheduler,
+    controller.signal,
+    pollIntervalMs,
+    runOptions,
+    options.onError
+  );
+  return {
+    get running() {
+      return running;
+    },
+    stop() {
+      if (stopPromise) {
+        return stopPromise;
+      }
+      running = false;
+      controller.abort();
+      stopPromise = loop.finally(
+        onStop
+      );
+      return stopPromise;
+    }
+  };
+}
+async function runSchedulerLoop(scheduler, signal, pollIntervalMs, runOptions, onError) {
+  while (!signal.aborted) {
+    try {
+      await scheduler.runDue(
+        runOptions
+      );
+    } catch (error) {
+      if (onError) {
+        await onError(error);
+      }
+    }
+    if (!signal.aborted) {
+      await sleep2(
+        pollIntervalMs,
+        signal
+      );
+    }
+  }
+}
+function normalizeSchedule(options) {
+  if (!options) {
+    throw new TypeError(
+      "BCP Jobs: schedule options are required."
+    );
+  }
+  const hasInterval = options.everyMs !== void 0;
+  const hasCron = options.cron !== void 0;
+  if (hasInterval === hasCron) {
+    throw new TypeError(
+      "BCP Jobs: schedule requires exactly one of everyMs or cron."
+    );
+  }
+  if (hasInterval) {
+    return {
+      kind: "interval",
+      everyMs: normalizePositiveInteger2(
+        options.everyMs,
+        "everyMs"
+      )
+    };
+  }
+  const expression = String(options.cron).trim();
+  parseCronExpression(
+    expression
+  );
+  return {
+    kind: "cron",
+    expression
+  };
+}
+function parseCronExpression(expression) {
+  const parts = String(expression).trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new TypeError(
+      "BCP Jobs: cron must contain 5 fields: minute hour day-of-month month day-of-week."
+    );
+  }
+  return {
+    minute: parseCronField(
+      parts[0],
+      0,
+      59,
+      "minute"
+    ).values,
+    hour: parseCronField(
+      parts[1],
+      0,
+      23,
+      "hour"
+    ).values,
+    dayOfMonth: parseCronField(
+      parts[2],
+      1,
+      31,
+      "day-of-month"
+    ).values,
+    month: parseCronField(
+      parts[3],
+      1,
+      12,
+      "month"
+    ).values,
+    dayOfWeek: parseCronField(
+      parts[4],
+      0,
+      7,
+      "day-of-week",
+      true
+    ).values,
+    dayOfMonthWildcard: parts[2] === "*",
+    dayOfWeekWildcard: parts[4] === "*"
+  };
+}
+function parseCronField(source, minimum, maximum, field, normalizeSunday = false) {
+  const values = /* @__PURE__ */ new Set();
+  for (const segment of source.split(",")) {
+    const [base, stepSource] = segment.split("/");
+    if (segment.split("/").length > 2) {
+      throwCronField(
+        field,
+        source
+      );
+    }
+    const step = stepSource === void 0 ? 1 : parseCronInteger(
+      stepSource,
+      1,
+      maximum - minimum + 1,
+      field,
+      source
+    );
+    let rangeStart;
+    let rangeEnd;
+    if (base === "*") {
+      rangeStart = minimum;
+      rangeEnd = maximum;
+    } else if (base.includes("-")) {
+      const bounds = base.split("-");
+      if (bounds.length !== 2) {
+        throwCronField(
+          field,
+          source
+        );
+      }
+      rangeStart = parseCronInteger(
+        bounds[0],
+        minimum,
+        maximum,
+        field,
+        source
+      );
+      rangeEnd = parseCronInteger(
+        bounds[1],
+        minimum,
+        maximum,
+        field,
+        source
+      );
+      if (rangeEnd < rangeStart) {
+        throwCronField(
+          field,
+          source
+        );
+      }
+    } else {
+      rangeStart = parseCronInteger(
+        base,
+        minimum,
+        maximum,
+        field,
+        source
+      );
+      rangeEnd = rangeStart;
+    }
+    for (let value = rangeStart; value <= rangeEnd; value += step) {
+      values.add(
+        normalizeSunday && value === 7 ? 0 : value
+      );
+    }
+  }
+  if (values.size === 0) {
+    throwCronField(
+      field,
+      source
+    );
+  }
+  return {
+    values
+  };
+}
+function parseCronInteger(source, minimum, maximum, field, fullSource) {
+  if (!/^\d+$/.test(source)) {
+    throwCronField(
+      field,
+      fullSource
+    );
+  }
+  const value = Number(source);
+  if (!Number.isInteger(value) || value < minimum || value > maximum) {
+    throwCronField(
+      field,
+      fullSource
+    );
+  }
+  return value;
+}
+function throwCronField(field, source) {
+  throw new TypeError(
+    `BCP Jobs: invalid cron ${field} field "${source}".`
+  );
+}
+function matchesCronDay(cron, date) {
+  const dayOfMonthMatches = cron.dayOfMonth.has(
+    date.getUTCDate()
+  );
+  const dayOfWeekMatches = cron.dayOfWeek.has(
+    date.getUTCDay()
+  );
+  if (cron.dayOfMonthWildcard && cron.dayOfWeekWildcard) {
+    return true;
+  }
+  if (cron.dayOfMonthWildcard) {
+    return dayOfWeekMatches;
+  }
+  if (cron.dayOfWeekWildcard) {
+    return dayOfMonthMatches;
+  }
+  return dayOfMonthMatches || dayOfWeekMatches;
+}
+function createScheduledRunId(scheduleId, scheduledFor) {
+  return `schedule:${scheduleId}:${scheduledFor}`;
+}
+function isDuplicateJobIdError(error) {
+  return error instanceof Error && /job id .* already exists/i.test(
+    error.message
+  );
+}
+function normalizeIdentifier(value, field) {
+  const normalized = String(value).trim();
+  if (!normalized) {
+    throw new TypeError(
+      `BCP Jobs: ${field} must be a non-empty string.`
+    );
+  }
+  if (normalized.length > 200) {
+    throw new TypeError(
+      `BCP Jobs: ${field} must not exceed 200 characters.`
+    );
+  }
+  return normalized;
+}
+function normalizeTimestamp(value, field) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new TypeError(
+      `BCP Jobs: ${field} must be a non-negative finite timestamp.`
+    );
+  }
+  return Math.floor(value);
+}
+function normalizePositiveInteger2(value, field) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new TypeError(
+      `BCP Jobs: ${field} must be a positive integer.`
+    );
+  }
+  return value;
+}
+function sleep2(durationMs, signal) {
+  if (signal.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise(
+    (resolve) => {
+      const timeout = setTimeout(
+        finish,
+        durationMs
+      );
+      const onAbort = () => finish();
+      signal.addEventListener(
+        "abort",
+        onAbort,
+        {
+          once: true
+        }
+      );
+      function finish() {
+        clearTimeout(timeout);
+        signal.removeEventListener(
+          "abort",
+          onAbort
+        );
+        resolve();
+      }
+    }
+  );
+}
+function cloneSchedule(schedule) {
+  return {
+    ...schedule,
+    schedule: {
+      ...schedule.schedule
+    }
+  };
+}
+
+// packages/server/src/jobs-redis.ts
+function createRedisJobQueueAdapter(options) {
+  const client = requireRedisClient(
+    options.client
+  );
+  const namespace = normalizeNamespace(
+    options.namespace
+  );
+  const keys = createQueueKeys(
+    namespace
+  );
+  return {
+    namespace,
+    async enqueue(job) {
+      const result = await evalRedis(
+        client,
+        ENQUEUE_SCRIPT,
+        [
+          jobKey(
+            keys.jobPrefix,
+            job.id
+          ),
+          keys.all,
+          keys.available
+        ],
+        [
+          job.id,
+          JSON.stringify(job),
+          String(
+            job.availableAt
+          )
+        ]
+      );
+      if (Number(result) !== 1) {
+        throw new Error(
+          `BCP Jobs Redis: job id "${job.id}" already exists.`
+        );
+      }
+    },
+    async reserve(now, reserveOptions) {
+      const options2 = reserveOptions ?? {
+        ownerId: "legacy-worker",
+        visibilityTimeoutMs: 3e4
+      };
+      const raw = await evalRedis(
+        client,
+        RESERVE_SCRIPT,
+        [
+          keys.available,
+          keys.running
+        ],
+        [
+          keys.jobPrefix,
+          String(now),
+          options2.ownerId,
+          String(
+            normalizePositiveInteger3(
+              options2.visibilityTimeoutMs,
+              "visibilityTimeoutMs"
+            )
+          )
+        ]
+      );
+      return parseJsonReply(raw);
+    },
+    async complete(id, completedAt, ownerId) {
+      await evalRedis(
+        client,
+        COMPLETE_SCRIPT,
+        [
+          jobKey(
+            keys.jobPrefix,
+            id
+          ),
+          keys.available,
+          keys.running,
+          keys.terminal,
+          keys.deadLetters
+        ],
+        [
+          id,
+          String(completedAt),
+          ownerId ?? ""
+        ]
+      );
+    },
+    async fail(id, failOptions) {
+      await evalRedis(
+        client,
+        FAIL_SCRIPT,
+        [
+          jobKey(
+            keys.jobPrefix,
+            id
+          ),
+          keys.available,
+          keys.running,
+          keys.terminal,
+          keys.deadLetters
+        ],
+        [
+          id,
+          failOptions.error,
+          String(
+            failOptions.failedAt
+          ),
+          failOptions.retryAt === void 0 ? "" : String(
+            failOptions.retryAt
+          ),
+          failOptions.ownerId ?? ""
+        ]
+      );
+    },
+    async cancel(id, cancelledAt) {
+      const result = await evalRedis(
+        client,
+        CANCEL_SCRIPT,
+        [
+          jobKey(
+            keys.jobPrefix,
+            id
+          ),
+          keys.available,
+          keys.running,
+          keys.terminal
+        ],
+        [
+          id,
+          String(cancelledAt)
+        ]
+      );
+      return Number(result) === 1;
+    },
+    async get(id) {
+      const raw = await client.sendCommand([
+        "GET",
+        jobKey(
+          keys.jobPrefix,
+          id
+        )
+      ]);
+      return parseJsonReply(raw);
+    },
+    async list() {
+      return readJobsByIds(
+        client,
+        keys.jobPrefix,
+        await readStringList(
+          client,
+          [
+            "SMEMBERS",
+            keys.all
+          ]
+        )
+      );
+    },
+    async heartbeat(id, heartbeatOptions) {
+      const result = await evalRedis(
+        client,
+        HEARTBEAT_SCRIPT,
+        [
+          jobKey(
+            keys.jobPrefix,
+            id
+          ),
+          keys.running
+        ],
+        [
+          id,
+          heartbeatOptions.ownerId,
+          String(
+            heartbeatOptions.heartbeatAt
+          ),
+          String(
+            normalizePositiveInteger3(
+              heartbeatOptions.visibilityTimeoutMs,
+              "visibilityTimeoutMs"
+            )
+          )
+        ]
+      );
+      return Number(result) === 1;
+    },
+    async recoverStale(now, recoverOptions = {}) {
+      const result = await evalRedis(
+        client,
+        RECOVER_STALE_SCRIPT,
+        [
+          keys.running,
+          keys.available
+        ],
+        [
+          keys.jobPrefix,
+          String(now),
+          String(
+            normalizePositiveInteger3(
+              recoverOptions.limit ?? 100,
+              "recovery limit"
+            )
+          )
+        ]
+      );
+      return Number(result) || 0;
+    },
+    async listDeadLetters() {
+      const ids = await readStringList(
+        client,
+        [
+          "ZRANGE",
+          keys.deadLetters,
+          "0",
+          "-1"
+        ]
+      );
+      const jobs = await readJobsByIds(
+        client,
+        keys.jobPrefix,
+        ids
+      );
+      return jobs.filter(
+        (job) => job.state === "failed" && job.completedAt !== void 0
+      ).map(
+        (job) => ({
+          ...job,
+          state: "failed",
+          deadLetteredAt: job.completedAt
+        })
+      );
+    },
+    async requeueDeadLetter(id, now, requeueOptions = {}) {
+      const result = await evalRedis(
+        client,
+        REQUEUE_DEAD_LETTER_SCRIPT,
+        [
+          jobKey(
+            keys.jobPrefix,
+            id
+          ),
+          keys.available,
+          keys.running,
+          keys.terminal,
+          keys.deadLetters
+        ],
+        [
+          id,
+          String(now),
+          String(
+            normalizeNonNegativeNumber2(
+              requeueOptions.delayMs ?? 0,
+              "delayMs"
+            )
+          ),
+          requeueOptions.resetAttempts === false ? "0" : "1"
+        ]
+      );
+      return Number(result) === 1;
+    },
+    async cleanup(cleanupOptions) {
+      const states = cleanupOptions.states ?? [
+        "succeeded",
+        "failed",
+        "cancelled"
+      ];
+      const result = await evalRedis(
+        client,
+        CLEANUP_SCRIPT,
+        [
+          keys.terminal,
+          keys.all,
+          keys.available,
+          keys.running,
+          keys.deadLetters
+        ],
+        [
+          keys.jobPrefix,
+          String(
+            cleanupOptions.before
+          ),
+          JSON.stringify(states)
+        ]
+      );
+      return Number(result) || 0;
+    },
+    async stats() {
+      const jobs = await readJobsByIds(
+        client,
+        keys.jobPrefix,
+        await readStringList(
+          client,
+          [
+            "SMEMBERS",
+            keys.all
+          ]
+        )
+      );
+      const deadLetters = Number(
+        await client.sendCommand([
+          "ZCARD",
+          keys.deadLetters
+        ])
+      ) || 0;
+      return calculateStats(
+        jobs,
+        deadLetters
+      );
+    },
+    async close() {
+      if (options.close) {
+        await options.close();
+      }
+    }
+  };
+}
+function createRedisJobScheduleStore(options) {
+  const client = requireRedisClient(
+    options.client
+  );
+  const namespace = normalizeNamespace(
+    options.namespace
+  );
+  const keys = createScheduleKeys(
+    namespace
+  );
+  return {
+    namespace,
+    async upsert(schedule) {
+      await evalRedis(
+        client,
+        UPSERT_SCHEDULE_SCRIPT,
+        [
+          scheduleKey(
+            keys.schedulePrefix,
+            schedule.id
+          ),
+          keys.all,
+          keys.due
+        ],
+        [
+          schedule.id,
+          JSON.stringify(schedule),
+          String(
+            schedule.nextRunAt
+          )
+        ]
+      );
+    },
+    async get(id) {
+      return parseJsonReply(
+        await client.sendCommand([
+          "GET",
+          scheduleKey(
+            keys.schedulePrefix,
+            id
+          )
+        ])
+      );
+    },
+    async list() {
+      const ids = await readStringList(
+        client,
+        [
+          "SMEMBERS",
+          keys.all
+        ]
+      );
+      const schedules = await readSchedulesByIds(
+        client,
+        keys.schedulePrefix,
+        ids
+      );
+      return schedules.sort(
+        (left, right) => left.nextRunAt - right.nextRunAt || left.id.localeCompare(
+          right.id
+        )
+      );
+    },
+    async remove(id) {
+      const result = await evalRedis(
+        client,
+        REMOVE_SCHEDULE_SCRIPT,
+        [
+          scheduleKey(
+            keys.schedulePrefix,
+            id
+          ),
+          keys.all,
+          keys.due
+        ],
+        [
+          id
+        ]
+      );
+      return Number(result) === 1;
+    },
+    async acquireDue(now, acquireOptions) {
+      const raw = await evalRedis(
+        client,
+        ACQUIRE_DUE_SCHEDULES_SCRIPT,
+        [
+          keys.due
+        ],
+        [
+          keys.schedulePrefix,
+          String(now),
+          acquireOptions.ownerId,
+          String(
+            normalizePositiveInteger3(
+              acquireOptions.leaseMs,
+              "schedule leaseMs"
+            )
+          ),
+          String(
+            normalizePositiveInteger3(
+              acquireOptions.limit,
+              "schedule limit"
+            )
+          )
+        ]
+      );
+      if (!Array.isArray(raw)) {
+        return [];
+      }
+      return raw.map(
+        (value) => parseJsonReply(value)
+      ).filter(
+        (value) => value !== null
+      );
+    },
+    async complete(id, completeOptions) {
+      await evalRedis(
+        client,
+        COMPLETE_SCHEDULE_SCRIPT,
+        [
+          scheduleKey(
+            keys.schedulePrefix,
+            id
+          ),
+          keys.due
+        ],
+        [
+          id,
+          completeOptions.ownerId,
+          String(
+            completeOptions.lastRunAt
+          ),
+          String(
+            completeOptions.nextRunAt
+          ),
+          String(
+            completeOptions.updatedAt
+          )
+        ]
+      );
+    },
+    async release(id, ownerId) {
+      await evalRedis(
+        client,
+        RELEASE_SCHEDULE_SCRIPT,
+        [
+          scheduleKey(
+            keys.schedulePrefix,
+            id
+          )
+        ],
+        [
+          ownerId
+        ]
+      );
+    },
+    async close() {
+      if (options.close) {
+        await options.close();
+      }
+    }
+  };
+}
+function createQueueKeys(namespace) {
+  return {
+    all: `${namespace}:jobs:all`,
+    available: `${namespace}:jobs:available`,
+    running: `${namespace}:jobs:running`,
+    terminal: `${namespace}:jobs:terminal`,
+    deadLetters: `${namespace}:jobs:dlq`,
+    jobPrefix: `${namespace}:job:`
+  };
+}
+function createScheduleKeys(namespace) {
+  return {
+    all: `${namespace}:schedules:all`,
+    due: `${namespace}:schedules:due`,
+    schedulePrefix: `${namespace}:schedule:`
+  };
+}
+function jobKey(prefix, id) {
+  return `${prefix}${id}`;
+}
+function scheduleKey(prefix, id) {
+  return `${prefix}${id}`;
+}
+async function evalRedis(client, script, keys, args) {
+  return client.sendCommand([
+    "EVAL",
+    script,
+    String(keys.length),
+    ...keys,
+    ...args
+  ]);
+}
+async function readStringList(client, command) {
+  const result = await client.sendCommand(
+    command
+  );
+  if (!Array.isArray(result)) {
+    return [];
+  }
+  return result.map(
+    (value) => redisString(value)
+  ).filter(
+    (value) => value !== null
+  );
+}
+async function readJobsByIds(client, prefix, ids) {
+  if (ids.length === 0) {
+    return [];
+  }
+  const raw = await client.sendCommand([
+    "MGET",
+    ...ids.map(
+      (id) => jobKey(
+        prefix,
+        id
+      )
+    )
+  ]);
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw.map(
+    (value) => parseJsonReply(value)
+  ).filter(
+    (value) => value !== null
+  ).sort(
+    (left, right) => left.createdAt - right.createdAt || left.id.localeCompare(
+      right.id
+    )
+  );
+}
+async function readSchedulesByIds(client, prefix, ids) {
+  if (ids.length === 0) {
+    return [];
+  }
+  const raw = await client.sendCommand([
+    "MGET",
+    ...ids.map(
+      (id) => scheduleKey(
+        prefix,
+        id
+      )
+    )
+  ]);
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw.map(
+    (value) => parseJsonReply(value)
+  ).filter(
+    (value) => value !== null
+  );
+}
+function parseJsonReply(value) {
+  const text = redisString(value);
+  if (text === null) {
+    return null;
+  }
+  return JSON.parse(text);
+}
+function redisString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    return Buffer.from(
+      value
+    ).toString("utf8");
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  return null;
+}
+function calculateStats(jobs, deadLetters) {
+  const stats = {
+    total: jobs.length,
+    queued: 0,
+    running: 0,
+    succeeded: 0,
+    failed: 0,
+    cancelled: 0,
+    deadLetters
+  };
+  for (const job of jobs) {
+    stats[job.state] += 1;
+  }
+  return stats;
+}
+function requireRedisClient(client) {
+  if (!client || typeof client.sendCommand !== "function") {
+    throw new TypeError(
+      "BCP Jobs Redis: client.sendCommand(command) is required."
+    );
+  }
+  return client;
+}
+function normalizeNamespace(value = "bcp:{jobs}") {
+  const namespace = String(value).trim();
+  if (!namespace) {
+    throw new TypeError(
+      "BCP Jobs Redis: namespace must be non-empty."
+    );
+  }
+  return namespace.replace(
+    /:+$/,
+    ""
+  );
+}
+function normalizePositiveInteger3(value, field) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new TypeError(
+      `BCP Jobs Redis: ${field} must be a positive integer.`
+    );
+  }
+  return value;
+}
+function normalizeNonNegativeNumber2(value, field) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new TypeError(
+      `BCP Jobs Redis: ${field} must be a non-negative finite number.`
+    );
+  }
+  return Math.floor(value);
+}
+var ENQUEUE_SCRIPT = `
+if redis.call('EXISTS', KEYS[1]) == 1 then
+    return 0
+end
+redis.call('SET', KEYS[1], ARGV[2])
+redis.call('SADD', KEYS[2], ARGV[1])
+redis.call('ZADD', KEYS[3], ARGV[3], ARGV[1])
+return 1
+`;
+var RESERVE_SCRIPT = `
+local ids = redis.call('ZRANGEBYSCORE', KEYS[1], '-inf', ARGV[2], 'LIMIT', 0, 20)
+for _, id in ipairs(ids) do
+    local key = ARGV[1] .. id
+    local raw = redis.call('GET', key)
+    if not raw then
+        redis.call('ZREM', KEYS[1], id)
+    else
+        local job = cjson.decode(raw)
+        if job.state == 'queued' then
+            job.state = 'running'
+            job.attempts = (job.attempts or 0) + 1
+            job.startedAt = tonumber(ARGV[2])
+            job.error = nil
+            job.recoveredAt = nil
+            job.leaseOwner = ARGV[3]
+            job.leaseUntil = tonumber(ARGV[2]) + tonumber(ARGV[4])
+            job.heartbeatAt = tonumber(ARGV[2])
+            local encoded = cjson.encode(job)
+            redis.call('SET', key, encoded)
+            redis.call('ZREM', KEYS[1], id)
+            redis.call('ZADD', KEYS[2], job.leaseUntil, id)
+            return encoded
+        end
+        redis.call('ZREM', KEYS[1], id)
+    end
+end
+return nil
+`;
+var COMPLETE_SCRIPT = `
+local raw = redis.call('GET', KEYS[1])
+if not raw then return 0 end
+local job = cjson.decode(raw)
+if job.state == 'cancelled' then return 0 end
+if ARGV[3] ~= '' and job.leaseOwner ~= ARGV[3] then return 0 end
+job.state = 'succeeded'
+job.completedAt = tonumber(ARGV[2])
+job.error = nil
+job.leaseOwner = nil
+job.leaseUntil = nil
+job.heartbeatAt = nil
+redis.call('SET', KEYS[1], cjson.encode(job))
+redis.call('ZREM', KEYS[2], ARGV[1])
+redis.call('ZREM', KEYS[3], ARGV[1])
+redis.call('ZADD', KEYS[4], ARGV[2], ARGV[1])
+redis.call('ZREM', KEYS[5], ARGV[1])
+return 1
+`;
+var FAIL_SCRIPT = `
+local raw = redis.call('GET', KEYS[1])
+if not raw then return 0 end
+local job = cjson.decode(raw)
+if job.state == 'cancelled' then return 0 end
+if ARGV[5] ~= '' and job.leaseOwner ~= ARGV[5] then return 0 end
+job.error = ARGV[2]
+job.leaseOwner = nil
+job.leaseUntil = nil
+job.heartbeatAt = nil
+local retryAt = nil
+if ARGV[4] ~= '' then retryAt = tonumber(ARGV[4]) end
+if retryAt and (job.attempts or 0) < (job.maxAttempts or 1) then
+    job.state = 'queued'
+    job.availableAt = retryAt
+    job.startedAt = nil
+    redis.call('SET', KEYS[1], cjson.encode(job))
+    redis.call('ZREM', KEYS[3], ARGV[1])
+    redis.call('ZADD', KEYS[2], retryAt, ARGV[1])
+    return 2
+end
+job.state = 'failed'
+job.completedAt = tonumber(ARGV[3])
+redis.call('SET', KEYS[1], cjson.encode(job))
+redis.call('ZREM', KEYS[2], ARGV[1])
+redis.call('ZREM', KEYS[3], ARGV[1])
+redis.call('ZADD', KEYS[4], ARGV[3], ARGV[1])
+redis.call('ZADD', KEYS[5], ARGV[3], ARGV[1])
+return 1
+`;
+var CANCEL_SCRIPT = `
+local raw = redis.call('GET', KEYS[1])
+if not raw then return 0 end
+local job = cjson.decode(raw)
+if job.state == 'succeeded' or job.state == 'failed' or job.state == 'cancelled' then
+    return 0
+end
+job.state = 'cancelled'
+job.completedAt = tonumber(ARGV[2])
+job.leaseOwner = nil
+job.leaseUntil = nil
+job.heartbeatAt = nil
+redis.call('SET', KEYS[1], cjson.encode(job))
+redis.call('ZREM', KEYS[2], ARGV[1])
+redis.call('ZREM', KEYS[3], ARGV[1])
+redis.call('ZADD', KEYS[4], ARGV[2], ARGV[1])
+return 1
+`;
+var HEARTBEAT_SCRIPT = `
+local raw = redis.call('GET', KEYS[1])
+if not raw then return 0 end
+local job = cjson.decode(raw)
+if job.state ~= 'running' or job.leaseOwner ~= ARGV[2] then
+    return 0
+end
+job.heartbeatAt = tonumber(ARGV[3])
+job.leaseUntil = tonumber(ARGV[3]) + tonumber(ARGV[4])
+redis.call('SET', KEYS[1], cjson.encode(job))
+redis.call('ZADD', KEYS[2], job.leaseUntil, ARGV[1])
+return 1
+`;
+var RECOVER_STALE_SCRIPT = `
+local ids = redis.call('ZRANGEBYSCORE', KEYS[1], '-inf', ARGV[2], 'LIMIT', 0, tonumber(ARGV[3]))
+local recovered = 0
+for _, id in ipairs(ids) do
+    local key = ARGV[1] .. id
+    local raw = redis.call('GET', key)
+    if not raw then
+        redis.call('ZREM', KEYS[1], id)
+    else
+        local job = cjson.decode(raw)
+        if job.state == 'running' and job.leaseUntil and tonumber(job.leaseUntil) <= tonumber(ARGV[2]) then
+            job.state = 'queued'
+            job.availableAt = tonumber(ARGV[2])
+            job.startedAt = nil
+            job.leaseOwner = nil
+            job.leaseUntil = nil
+            job.heartbeatAt = nil
+            job.recoveredAt = tonumber(ARGV[2])
+            redis.call('SET', key, cjson.encode(job))
+            redis.call('ZREM', KEYS[1], id)
+            redis.call('ZADD', KEYS[2], ARGV[2], id)
+            recovered = recovered + 1
+        end
+    end
+end
+return recovered
+`;
+var REQUEUE_DEAD_LETTER_SCRIPT = `
+local raw = redis.call('GET', KEYS[1])
+if not raw then return 0 end
+if not redis.call('ZSCORE', KEYS[5], ARGV[1]) then return 0 end
+local job = cjson.decode(raw)
+if job.state ~= 'failed' then return 0 end
+job.state = 'queued'
+job.availableAt = tonumber(ARGV[2]) + tonumber(ARGV[3])
+job.startedAt = nil
+job.completedAt = nil
+job.error = nil
+job.leaseOwner = nil
+job.leaseUntil = nil
+job.heartbeatAt = nil
+job.recoveredAt = nil
+if ARGV[4] == '1' then job.attempts = 0 end
+redis.call('SET', KEYS[1], cjson.encode(job))
+redis.call('ZADD', KEYS[2], job.availableAt, ARGV[1])
+redis.call('ZREM', KEYS[3], ARGV[1])
+redis.call('ZREM', KEYS[4], ARGV[1])
+redis.call('ZREM', KEYS[5], ARGV[1])
+return 1
+`;
+var CLEANUP_SCRIPT = `
+local allowed = {}
+for _, state in ipairs(cjson.decode(ARGV[3])) do allowed[state] = true end
+local ids = redis.call('ZRANGEBYSCORE', KEYS[1], '-inf', ARGV[2], 'LIMIT', 0, 1000)
+local removed = 0
+for _, id in ipairs(ids) do
+    local key = ARGV[1] .. id
+    local raw = redis.call('GET', key)
+    if not raw then
+        redis.call('ZREM', KEYS[1], id)
+        redis.call('SREM', KEYS[2], id)
+    else
+        local job = cjson.decode(raw)
+        if allowed[job.state] then
+            redis.call('DEL', key)
+            redis.call('SREM', KEYS[2], id)
+            redis.call('ZREM', KEYS[1], id)
+            redis.call('ZREM', KEYS[3], id)
+            redis.call('ZREM', KEYS[4], id)
+            redis.call('ZREM', KEYS[5], id)
+            removed = removed + 1
+        end
+    end
+end
+return removed
+`;
+var UPSERT_SCHEDULE_SCRIPT = `
+redis.call('SET', KEYS[1], ARGV[2])
+redis.call('SADD', KEYS[2], ARGV[1])
+redis.call('ZADD', KEYS[3], ARGV[3], ARGV[1])
+return 1
+`;
+var REMOVE_SCHEDULE_SCRIPT = `
+local existed = redis.call('DEL', KEYS[1])
+redis.call('SREM', KEYS[2], ARGV[1])
+redis.call('ZREM', KEYS[3], ARGV[1])
+return existed
+`;
+var ACQUIRE_DUE_SCHEDULES_SCRIPT = `
+local ids = redis.call('ZRANGEBYSCORE', KEYS[1], '-inf', ARGV[2], 'LIMIT', 0, tonumber(ARGV[5]) * 4)
+local result = {}
+for _, id in ipairs(ids) do
+    if #result >= tonumber(ARGV[5]) then break end
+    local key = ARGV[1] .. id
+    local raw = redis.call('GET', key)
+    if not raw then
+        redis.call('ZREM', KEYS[1], id)
+    else
+        local schedule = cjson.decode(raw)
+        local leaseUntil = schedule.leaseUntil
+        if schedule.nextRunAt <= tonumber(ARGV[2]) and (not leaseUntil or tonumber(leaseUntil) <= tonumber(ARGV[2])) then
+            schedule.leaseOwner = ARGV[3]
+            schedule.leaseUntil = tonumber(ARGV[2]) + tonumber(ARGV[4])
+            local encoded = cjson.encode(schedule)
+            redis.call('SET', key, encoded)
+            table.insert(result, encoded)
+        end
+    end
+end
+return result
+`;
+var COMPLETE_SCHEDULE_SCRIPT = `
+local raw = redis.call('GET', KEYS[1])
+if not raw then return 0 end
+local schedule = cjson.decode(raw)
+if schedule.leaseOwner ~= ARGV[2] then return 0 end
+schedule.lastRunAt = tonumber(ARGV[3])
+schedule.nextRunAt = tonumber(ARGV[4])
+schedule.updatedAt = tonumber(ARGV[5])
+schedule.leaseOwner = nil
+schedule.leaseUntil = nil
+redis.call('SET', KEYS[1], cjson.encode(schedule))
+redis.call('ZADD', KEYS[2], ARGV[4], ARGV[1])
+return 1
+`;
+var RELEASE_SCHEDULE_SCRIPT = `
+local raw = redis.call('GET', KEYS[1])
+if not raw then return 0 end
+local schedule = cjson.decode(raw)
+if schedule.leaseOwner ~= ARGV[1] then return 0 end
+schedule.leaseOwner = nil
+schedule.leaseUntil = nil
+redis.call('SET', KEYS[1], cjson.encode(schedule))
+return 1
+`;
+export {
+  createJobQueue,
+  createJobScheduler,
+  createMemoryJobQueueAdapter,
+  createMemoryJobScheduleStore,
+  createRedisJobQueueAdapter,
+  createRedisJobScheduleStore,
+  nextCronTime,
+  nextScheduleTime
+};