silent-cronx 1.0.0

package/dist/index.js

@@ -0,0 +1,1138 @@
+// src/core/eventBus.ts
+import { EventEmitter } from "events";
+var EventBus = class {
+  emitter = new EventEmitter();
+  on(eventName, handler) {
+    this.emitter.on(eventName, handler);
+  }
+  off(eventName, handler) {
+    this.emitter.off(eventName, handler);
+  }
+  emit(eventName, event) {
+    this.emitter.emit(eventName, event);
+  }
+};
+
+// src/core/retryManager.ts
+function getMaxAttempts(retry) {
+  return Math.max(1, retry?.attempts ?? 1);
+}
+function shouldRetry(error, attempt, retry) {
+  if (!retry || attempt >= getMaxAttempts(retry)) return false;
+  return retry.shouldRetry ? retry.shouldRetry(error) : true;
+}
+function getRetryDelayMs(attempt, retry) {
+  if (!retry) return 0;
+  const base = retry.delayMs ?? 1e3;
+  switch (retry.backoff ?? "fixed") {
+    case "linear":
+      return base * attempt;
+    case "exponential":
+      return base * 2 ** Math.max(0, attempt - 1);
+    case "fixed":
+    default:
+      return base;
+  }
+}
+
+// src/utils/errors.ts
+var SilentCronXError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SilentCronXError";
+  }
+};
+var JobTimeoutError = class extends SilentCronXError {
+  constructor(message = "Job timed out") {
+    super(message);
+    this.name = "JobTimeoutError";
+  }
+};
+var JobCancelledError = class extends SilentCronXError {
+  constructor(message = "Job cancelled") {
+    super(message);
+    this.name = "JobCancelledError";
+  }
+};
+function serializeError(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    };
+  }
+  return {
+    name: "Error",
+    message: typeof error === "string" ? error : JSON.stringify(error)
+  };
+}
+
+// src/core/timeoutManager.ts
+async function withTimeout(work, timeoutMs, externalSignal) {
+  const controller = new AbortController();
+  const abort = (reason) => controller.abort(reason);
+  if (externalSignal?.aborted) abort(externalSignal.reason);
+  externalSignal?.addEventListener("abort", () => abort(externalSignal.reason), { once: true });
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      const error = new JobTimeoutError(`Job timed out after ${timeoutMs}ms`);
+      abort(error);
+      reject(error);
+    }, timeoutMs);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([work(controller.signal), timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+// src/utils/time.ts
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function delay(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new Error("Operation aborted"));
+      return;
+    }
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(signal.reason ?? new Error("Operation aborted"));
+      },
+      { once: true }
+    );
+  });
+}
+
+// src/core/jobRunner.ts
+var JobRunner = class {
+  activeCount = 0;
+  getActiveCount() {
+    return this.activeCount;
+  }
+  async run(options) {
+    const { record, storage, eventBus } = options;
+    const lockKey = options.lockKey;
+    let locked = false;
+    if (lockKey && options.acquireLock) {
+      locked = await options.acquireLock(lockKey, options.lockTtlMs ?? options.timeoutMs);
+      if (!locked) {
+        const skipped = {
+          jobId: record.id,
+          name: record.name,
+          status: "scheduled",
+          attempt: record.attempts,
+          durationMs: 0
+        };
+        return skipped;
+      }
+    }
+    this.activeCount += 1;
+    try {
+      let attempt = record.attempts;
+      while (true) {
+        attempt += 1;
+        const startedAt = /* @__PURE__ */ new Date();
+        await storage.updateJob(record.id, {
+          status: "running",
+          attempts: attempt,
+          startedAt: startedAt.toISOString(),
+          lastRunAt: startedAt.toISOString()
+        });
+        eventBus.emit("job:started", { jobId: record.id, name: record.name, attempt });
+        try {
+          const result = await withTimeout(
+            async (timeoutSignal) => {
+              const signal = mergeSignals(options.signal, timeoutSignal);
+              if (signal.aborted) throw signal.reason ?? new JobCancelledError();
+              return options.task({
+                jobId: record.id,
+                name: record.name,
+                payload: record.payload,
+                attempt,
+                signal,
+                createdAt: new Date(record.createdAt),
+                startedAt
+              });
+            },
+            options.timeoutMs,
+            options.signal
+          );
+          const finishedAt = nowIso();
+          const durationMs = Date.now() - startedAt.getTime();
+          const finalResult = {
+            jobId: record.id,
+            name: record.name,
+            status: "success",
+            result,
+            attempt,
+            durationMs,
+            startedAt: startedAt.toISOString(),
+            finishedAt
+          };
+          const latest = await storage.getJob(record.id);
+          await storage.updateJob(record.id, {
+            status: "success",
+            result,
+            finishedAt,
+            successCount: (latest?.successCount ?? record.successCount) + 1
+          });
+          eventBus.emit("job:success", finalResult);
+          return finalResult;
+        } catch (error) {
+          const finishedAt = nowIso();
+          const durationMs = Date.now() - startedAt.getTime();
+          const status = error instanceof JobTimeoutError ? "timeout" : isAbortError(error) ? "cancelled" : "failed";
+          const finalResult = {
+            jobId: record.id,
+            name: record.name,
+            status,
+            error: serializeError(error),
+            attempt,
+            durationMs,
+            startedAt: startedAt.toISOString(),
+            finishedAt
+          };
+          if (status === "cancelled" || status === "timeout" || !shouldRetry(error, attempt, options.retry)) {
+            const latest = await storage.getJob(record.id);
+            await storage.updateJob(record.id, {
+              status,
+              error: finalResult.error,
+              finishedAt,
+              failureCount: (latest?.failureCount ?? record.failureCount) + 1
+            });
+            if (status === "timeout") {
+              eventBus.emit("job:timeout", finalResult);
+            } else if (status === "cancelled") {
+              eventBus.emit("job:cancelled", { jobId: record.id, name: record.name });
+            } else {
+              eventBus.emit("job:failed", finalResult);
+            }
+            return finalResult;
+          }
+          const retryDelayMs = getRetryDelayMs(attempt, options.retry);
+          eventBus.emit("job:retry", { jobId: record.id, name: record.name, attempt, delayMs: retryDelayMs });
+          await delay(retryDelayMs, options.signal);
+        }
+      }
+    } finally {
+      this.activeCount -= 1;
+      if (locked && lockKey && options.releaseLock) await options.releaseLock(lockKey);
+    }
+  }
+};
+function mergeSignals(a, b) {
+  const controller = new AbortController();
+  const abort = (signal) => controller.abort(signal.reason);
+  if (a?.aborted) abort(a);
+  if (b?.aborted) abort(b);
+  a?.addEventListener("abort", () => abort(a), { once: true });
+  b?.addEventListener("abort", () => abort(b), { once: true });
+  return controller.signal;
+}
+function isAbortError(error) {
+  return error instanceof JobCancelledError || error instanceof Error && error.name === "AbortError";
+}
+
+// src/core/lockManager.ts
+var LockManager = class {
+  constructor(storage, defaultTtlMs) {
+    this.storage = storage;
+    this.defaultTtlMs = defaultTtlMs;
+  }
+  storage;
+  defaultTtlMs;
+  acquire(lockKey, ttlMs = this.defaultTtlMs) {
+    return this.storage.acquireLock(lockKey, ttlMs);
+  }
+  release(lockKey) {
+    return this.storage.releaseLock(lockKey);
+  }
+};
+
+// src/utils/id.ts
+import { randomUUID } from "crypto";
+function createJobId(prefix = "job") {
+  return `${prefix}_${randomUUID()}`;
+}
+
+// src/utils/safeSerialize.ts
+function assertSerializablePayload(payload, maxBytes) {
+  if (payload === void 0) return;
+  try {
+    const json = JSON.stringify(payload);
+    if (maxBytes && Buffer.byteLength(json, "utf8") > maxBytes) {
+      throw new SilentCronXError(`Payload exceeds configured maxPayloadBytes (${maxBytes})`);
+    }
+  } catch (error) {
+    if (error instanceof SilentCronXError) throw error;
+    throw new SilentCronXError("Payload must be JSON-serializable");
+  }
+}
+
+// src/utils/validation.ts
+var JOB_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,127}$/;
+function validateJobName(name) {
+  if (!JOB_NAME_RE.test(name)) {
+    throw new SilentCronXError(
+      "Job name must start with a letter or number and contain only letters, numbers, underscore, dash, dot, or colon"
+    );
+  }
+}
+function assertPositiveNumber(value, label) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new SilentCronXError(`${label} must be a positive number`);
+  }
+}
+function assertTask(task, label = "task") {
+  if (typeof task !== "function") {
+    throw new SilentCronXError(`${label} must be a function`);
+  }
+}
+
+// src/core/queueManager.ts
+var QueueManager = class {
+  constructor(storage, eventBus, maxPayloadBytes, runJob) {
+    this.storage = storage;
+    this.eventBus = eventBus;
+    this.maxPayloadBytes = maxPayloadBytes;
+    this.runJob = runJob;
+  }
+  storage;
+  eventBus;
+  maxPayloadBytes;
+  runJob;
+  queues = /* @__PURE__ */ new Map();
+  createQueue(name, options = {}) {
+    validateJobName(name);
+    const concurrency = options.concurrency ?? 1;
+    assertPositiveNumber(concurrency, "queue concurrency");
+    const runtime = {
+      name,
+      options: {
+        ...options,
+        concurrency,
+        maxSize: options.maxSize ?? 1e3
+      },
+      pending: [],
+      running: 0,
+      rateWindowStartedAt: Date.now(),
+      rateCount: 0
+    };
+    this.queues.set(name, runtime);
+    this.eventBus.emit("queue:created", { queueName: name, concurrency });
+  }
+  async addJob(queueName, job) {
+    const queue = this.getQueue(queueName);
+    validateJobName(job.name);
+    assertSerializablePayload(job.payload, this.maxPayloadBytes);
+    if (!job.task && !queue.options.processor) {
+      throw new Error(`Queue "${queueName}" requires either a queue processor or a task on addJob`);
+    }
+    if (queue.pending.length >= queue.options.maxSize) {
+      throw new Error(`Queue "${queueName}" is full`);
+    }
+    const id = job.id ?? createJobId("queue");
+    const createdAt = nowIso();
+    const record = {
+      id,
+      name: job.name,
+      kind: "queue",
+      status: "pending",
+      payload: job.payload,
+      priority: job.priority ?? 0,
+      attempts: 0,
+      maxAttempts: getMaxAttempts(job.retry ?? queue.options.retry),
+      createdAt,
+      updatedAt: createdAt,
+      successCount: 0,
+      failureCount: 0,
+      queueName
+    };
+    await this.storage.saveJob(record);
+    await this.insertByPriority(queue, id, record.priority);
+    void this.drain(queueName, job.task ?? queue.options.processor);
+    return id;
+  }
+  getQueuedCount() {
+    return [...this.queues.values()].reduce((total, queue) => total + queue.pending.length, 0);
+  }
+  async drain(queueName, task) {
+    const queue = this.getQueue(queueName);
+    while (queue.running < queue.options.concurrency && queue.pending.length > 0 && this.canRunByRateLimit(queue)) {
+      const jobId = queue.pending.shift();
+      if (!jobId) break;
+      queue.running += 1;
+      void this.runJob(jobId, task, queueName).finally(() => {
+        queue.running = Math.max(0, queue.running - 1);
+        if (queue.pending.length === 0 && queue.running === 0) this.eventBus.emit("queue:drain", { queueName });
+        void this.drain(queueName, task);
+      });
+    }
+  }
+  getQueue(name) {
+    const queue = this.queues.get(name);
+    if (!queue) throw new Error(`Queue not found: ${name}`);
+    return queue;
+  }
+  async insertByPriority(queue, jobId, priority) {
+    let index = queue.pending.length;
+    for (let i = 0; i < queue.pending.length; i += 1) {
+      const existing = await this.storage.getJob(queue.pending[i]);
+      if ((existing?.priority ?? 0) < priority) {
+        index = i;
+        break;
+      }
+    }
+    queue.pending.splice(index, 0, jobId);
+  }
+  canRunByRateLimit(queue) {
+    const rateLimit = queue.options.rateLimit;
+    if (!rateLimit) return true;
+    const now = Date.now();
+    if (now - queue.rateWindowStartedAt >= rateLimit.intervalMs) {
+      queue.rateWindowStartedAt = now;
+      queue.rateCount = 0;
+    }
+    if (queue.rateCount >= rateLimit.limit) {
+      const waitMs = rateLimit.intervalMs - (now - queue.rateWindowStartedAt);
+      setTimeout(() => void this.drain(queue.name), Math.max(1, waitMs)).unref?.();
+      return false;
+    }
+    queue.rateCount += 1;
+    return true;
+  }
+};
+
+// src/core/cronParser.ts
+var MONTHS = {
+  jan: 1,
+  feb: 2,
+  mar: 3,
+  apr: 4,
+  may: 5,
+  jun: 6,
+  jul: 7,
+  aug: 8,
+  sep: 9,
+  oct: 10,
+  nov: 11,
+  dec: 12
+};
+var DOW = {
+  sun: 0,
+  mon: 1,
+  tue: 2,
+  wed: 3,
+  thu: 4,
+  fri: 5,
+  sat: 6
+};
+function parseCronExpression(expression) {
+  const parts = expression.trim().replace(/\s+/g, " ").split(" ");
+  if (parts.length !== 5 && parts.length !== 6) {
+    throw new SilentCronXError("Invalid cron expression. Expected 5 fields, or 6 fields with seconds.");
+  }
+  const hasSeconds = parts.length === 6;
+  const [secondsRaw, minutesRaw, hoursRaw, domRaw, monthsRaw, dowRaw] = hasSeconds ? parts : ["0", ...parts];
+  return {
+    hasSeconds,
+    seconds: parseField(secondsRaw, 0, 59),
+    minutes: parseField(minutesRaw, 0, 59),
+    hours: parseField(hoursRaw, 0, 23),
+    daysOfMonth: parseField(domRaw, 1, 31),
+    months: parseField(monthsRaw, 1, 12, MONTHS),
+    daysOfWeek: normalizeDow(parseField(dowRaw, 0, 7, DOW)),
+    expression
+  };
+}
+function getNextCronDate(expression, from = /* @__PURE__ */ new Date(), timezone = "UTC") {
+  const parsed = typeof expression === "string" ? parseCronExpression(expression) : expression;
+  const stepMs = parsed.hasSeconds ? 1e3 : 6e4;
+  let candidate = new Date(Math.ceil((from.getTime() + stepMs) / stepMs) * stepMs);
+  const limit = candidate.getTime() + 366 * 24 * 60 * 60 * 1e3;
+  while (candidate.getTime() <= limit) {
+    const parts = getZonedParts(candidate, timezone);
+    if (parsed.seconds.has(parts.second) && parsed.minutes.has(parts.minute) && parsed.hours.has(parts.hour) && parsed.daysOfMonth.has(parts.day) && parsed.months.has(parts.month) && parsed.daysOfWeek.has(parts.weekday)) {
+      return candidate;
+    }
+    candidate = new Date(candidate.getTime() + stepMs);
+  }
+  throw new SilentCronXError(`Unable to find next run for cron expression: ${parsed.expression}`);
+}
+function parseField(raw, min, max, aliases = {}) {
+  if (!raw) throw new SilentCronXError("Cron field is missing");
+  const values = /* @__PURE__ */ new Set();
+  for (const token of raw.toLowerCase().split(",")) {
+    const [rangeRaw, stepRaw] = token.split("/");
+    const step = stepRaw ? Number(stepRaw) : 1;
+    if (!Number.isInteger(step) || step <= 0) {
+      throw new SilentCronXError(`Invalid cron step: ${token}`);
+    }
+    let start;
+    let end;
+    if (rangeRaw === "*") {
+      start = min;
+      end = max;
+    } else if (rangeRaw?.includes("-")) {
+      const [a, b] = rangeRaw.split("-");
+      start = parseValue(a, aliases);
+      end = parseValue(b, aliases);
+    } else {
+      start = parseValue(rangeRaw, aliases);
+      end = start;
+    }
+    if (start < min || end > max || start > end) {
+      throw new SilentCronXError(`Cron value out of range: ${token}`);
+    }
+    for (let value = start; value <= end; value += step) values.add(value);
+  }
+  return values;
+}
+function parseValue(raw, aliases) {
+  if (!raw) throw new SilentCronXError("Invalid empty cron value");
+  const aliased = aliases[raw] ?? Number(raw);
+  if (!Number.isInteger(aliased)) throw new SilentCronXError(`Invalid cron value: ${raw}`);
+  return aliased;
+}
+function normalizeDow(values) {
+  const normalized = /* @__PURE__ */ new Set();
+  for (const value of values) normalized.add(value === 7 ? 0 : value);
+  return normalized;
+}
+function getZonedParts(date, timezone) {
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    second: "numeric",
+    minute: "numeric",
+    hour: "numeric",
+    hourCycle: "h23",
+    day: "numeric",
+    month: "numeric",
+    weekday: "short"
+  });
+  const map = new Map(formatter.formatToParts(date).map((part) => [part.type, part.value]));
+  return {
+    second: Number(map.get("second")),
+    minute: Number(map.get("minute")),
+    hour: Number(map.get("hour")),
+    day: Number(map.get("day")),
+    month: Number(map.get("month")),
+    weekday: DOW[(map.get("weekday") ?? "sun").toLowerCase()] ?? 0
+  };
+}
+
+// src/storage/MemoryStorageAdapter.ts
+var MemoryStorageAdapter = class {
+  jobs = /* @__PURE__ */ new Map();
+  locks = /* @__PURE__ */ new Map();
+  async saveJob(job) {
+    if (this.jobs.has(job.id)) {
+      throw new SilentCronXError(`Duplicate job id rejected: ${job.id}`);
+    }
+    this.jobs.set(job.id, { ...job });
+  }
+  async updateJob(jobId, patch) {
+    const existing = this.jobs.get(jobId);
+    if (!existing) throw new SilentCronXError(`Job not found: ${jobId}`);
+    this.jobs.set(jobId, { ...existing, ...patch, updatedAt: nowIso() });
+  }
+  async getJob(jobId) {
+    const job = this.jobs.get(jobId);
+    return job ? { ...job } : null;
+  }
+  async listJobs(filter = {}) {
+    return [...this.jobs.values()].filter((job) => !filter.status || job.status === filter.status).filter((job) => !filter.name || job.name === filter.name).filter((job) => !filter.kind || job.kind === filter.kind).filter((job) => !filter.queueName || job.queueName === filter.queueName).map((job) => ({ ...job }));
+  }
+  async deleteJob(jobId) {
+    this.jobs.delete(jobId);
+  }
+  async acquireLock(lockKey, ttlMs) {
+    this.cleanupExpiredLocks();
+    const existing = this.locks.get(lockKey);
+    if (existing && existing.expiresAt > Date.now()) return false;
+    this.locks.set(lockKey, { expiresAt: Date.now() + ttlMs });
+    return true;
+  }
+  async releaseLock(lockKey) {
+    this.locks.delete(lockKey);
+  }
+  cleanupExpiredLocks() {
+    const now = Date.now();
+    for (const [key, lock] of this.locks) {
+      if (lock.expiresAt <= now) this.locks.delete(key);
+    }
+  }
+};
+
+// src/workers/workerPool.ts
+import { Worker } from "worker_threads";
+
+// src/workers/workerBridge.ts
+function normalizeWorkerReference(worker) {
+  return {
+    modulePath: worker.path instanceof URL ? worker.path.href : worker.path,
+    exportName: worker.exportName ?? "default"
+  };
+}
+
+// src/workers/workerPool.ts
+var WorkerPool = class {
+  constructor(maxWorkers) {
+    this.maxWorkers = maxWorkers;
+  }
+  maxWorkers;
+  busy = 0;
+  pending = [];
+  liveWorkers = /* @__PURE__ */ new Set();
+  getStats() {
+    return {
+      max: this.maxWorkers,
+      busy: this.busy,
+      idle: Math.max(0, this.maxWorkers - this.busy)
+    };
+  }
+  run(options) {
+    return new Promise((resolve, reject) => {
+      const execute = () => {
+        this.busy += 1;
+        const normalized = normalizeWorkerReference(options.worker);
+        const worker = new Worker(getWorkerBridgeUrl(), {
+          workerData: {
+            modulePath: normalized.modulePath,
+            exportName: normalized.exportName,
+            payload: options.payload,
+            jobId: options.jobId,
+            name: options.name,
+            attempt: options.attempt,
+            createdAt: options.createdAt,
+            startedAt: options.startedAt
+          }
+        });
+        this.liveWorkers.add(worker);
+        let settled = false;
+        const timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          void worker.terminate();
+          reject(new Error(`Worker timed out after ${options.timeoutMs}ms`));
+          this.finish(worker);
+        }, options.timeoutMs);
+        timer.unref?.();
+        worker.once("message", (message) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          if (message.ok) resolve(message.result);
+          else reject(serializeError(message.error));
+          void worker.terminate();
+          this.finish(worker);
+        });
+        worker.once("error", (error) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          reject(error);
+          this.finish(worker);
+        });
+        worker.once("exit", (code) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          if (code === 0) resolve(void 0);
+          else reject(new Error(`Worker exited with code ${code}`));
+          this.finish(worker);
+        });
+      };
+      if (this.busy < this.maxWorkers) execute();
+      else this.pending.push({ run: execute });
+    });
+  }
+  async shutdown() {
+    this.pending.length = 0;
+    await Promise.all([...this.liveWorkers].map((worker) => worker.terminate()));
+    this.liveWorkers.clear();
+    this.busy = 0;
+  }
+  finish(worker) {
+    this.liveWorkers.delete(worker);
+    this.busy = Math.max(0, this.busy - 1);
+    const next = this.pending.shift();
+    if (next) queueMicrotask(next.run);
+  }
+};
+var workerBridgeUrl;
+function getWorkerBridgeUrl() {
+  workerBridgeUrl ??= new URL(
+    `data:text/javascript;charset=utf-8,${encodeURIComponent(`
+      import { parentPort, workerData } from "node:worker_threads";
+
+      async function run() {
+        const mod = await import(workerData.modulePath);
+        const worker = mod[workerData.exportName];
+        if (typeof worker !== "function") {
+          throw new Error(\`Worker export "\${workerData.exportName}" was not found or is not a function\`);
+        }
+        const result = await worker({
+          jobId: workerData.jobId,
+          name: workerData.name,
+          payload: workerData.payload,
+          attempt: workerData.attempt,
+          signal: new AbortController().signal,
+          createdAt: new Date(workerData.createdAt),
+          startedAt: new Date(workerData.startedAt)
+        });
+        parentPort?.postMessage({ ok: true, result });
+      }
+
+      run().catch((error) => {
+        parentPort?.postMessage({
+          ok: false,
+          error: error instanceof Error
+            ? { name: error.name, message: error.message, stack: error.stack }
+            : error
+        });
+      });
+    `)}`
+  );
+  return workerBridgeUrl;
+}
+
+// src/utils/logger.ts
+var noop = () => void 0;
+function createLogger(config) {
+  const base = config.logger ?? {};
+  return {
+    info: base.info ?? noop,
+    warn: base.warn ?? noop,
+    error: base.error ?? noop,
+    debug: config.debug ? base.debug ?? noop : noop
+  };
+}
+
+// src/core/SilentCronX.ts
+var SilentCronX = class {
+  config;
+  storage;
+  eventBus = new EventBus();
+  runner = new JobRunner();
+  workerPool;
+  lockManager;
+  queueManager;
+  logger;
+  entries = /* @__PURE__ */ new Map();
+  controllers = /* @__PURE__ */ new Map();
+  running = false;
+  constructor(config = {}) {
+    this.config = {
+      timezone: config.timezone ?? "UTC",
+      maxWorkers: config.maxWorkers ?? 2,
+      maxConcurrency: config.maxConcurrency ?? 50,
+      defaultTimeout: config.defaultTimeout ?? 3e4,
+      preventOverlapping: config.preventOverlapping ?? true,
+      lockTimeout: config.lockTimeout ?? config.defaultTimeout ?? 3e4,
+      ...config
+    };
+    this.storage = config.storage && config.storage !== "memory" ? config.storage : new MemoryStorageAdapter();
+    this.logger = createLogger(config);
+    this.workerPool = new WorkerPool(this.config.maxWorkers);
+    this.lockManager = new LockManager(this.storage, this.config.lockTimeout);
+    this.queueManager = new QueueManager(
+      this.storage,
+      this.eventBus,
+      this.config.maxPayloadBytes,
+      (jobId, task) => this.executeJob(jobId, task)
+    );
+  }
+  async schedule(name, options) {
+    validateJobName(name);
+    assertTask(options.task);
+    assertSerializablePayload(options.payload, this.config.maxPayloadBytes);
+    parseCronExpression(options.cron);
+    const id = createJobId("cron");
+    const nextRunAt = getNextCronDate(options.cron, /* @__PURE__ */ new Date(), options.timezone ?? this.config.timezone).toISOString();
+    await this.createRecord(id, name, "cron", options.payload, options.priority, getMaxAttempts(options.retry), {
+      nextRunAt,
+      metadata: { cron: options.cron, timezone: options.timezone ?? this.config.timezone },
+      status: options.enabled === false ? "paused" : "scheduled"
+    });
+    this.entries.set(id, {
+      id,
+      name,
+      kind: "cron",
+      task: options.task,
+      cron: options.cron,
+      retry: options.retry,
+      timeoutMs: options.timeout ?? this.config.defaultTimeout,
+      preventOverlap: options.preventOverlap ?? this.config.preventOverlapping
+    });
+    this.eventBus.emit("job:scheduled", { jobId: id, name, nextRunAt });
+    if (this.running && options.enabled !== false) this.armCron(id);
+    return id;
+  }
+  async delay(name, options) {
+    validateJobName(name);
+    assertPositiveNumber(options.delayMs, "delayMs");
+    assertTask(options.task);
+    assertSerializablePayload(options.payload, this.config.maxPayloadBytes);
+    const id = createJobId("delay");
+    const nextRunAt = new Date(Date.now() + options.delayMs).toISOString();
+    await this.createRecord(id, name, "delay", options.payload, options.priority, getMaxAttempts(options.retry), {
+      nextRunAt,
+      status: "scheduled"
+    });
+    this.entries.set(id, {
+      id,
+      name,
+      kind: "delay",
+      task: options.task,
+      delayMs: options.delayMs,
+      retry: options.retry,
+      timeoutMs: options.timeout ?? this.config.defaultTimeout,
+      preventOverlap: false
+    });
+    if (this.running) this.armDelay(id, options.delayMs);
+    return id;
+  }
+  async every(name, options) {
+    validateJobName(name);
+    assertPositiveNumber(options.intervalMs, "intervalMs");
+    assertTask(options.task);
+    assertSerializablePayload(options.payload, this.config.maxPayloadBytes);
+    const id = createJobId("every");
+    const nextRunAt = new Date(Date.now() + options.intervalMs).toISOString();
+    await this.createRecord(id, name, "every", options.payload, options.priority, getMaxAttempts(options.retry), {
+      nextRunAt,
+      status: options.enabled === false ? "paused" : "scheduled"
+    });
+    this.entries.set(id, {
+      id,
+      name,
+      kind: "every",
+      task: options.task,
+      intervalMs: options.intervalMs,
+      retry: options.retry,
+      timeoutMs: options.timeout ?? this.config.defaultTimeout,
+      preventOverlap: options.preventOverlap ?? this.config.preventOverlapping
+    });
+    if (this.running && options.enabled !== false) this.armEvery(id);
+    return id;
+  }
+  async runNow(name, options) {
+    validateJobName(name);
+    assertTask(options.task);
+    assertSerializablePayload(options.payload, this.config.maxPayloadBytes);
+    const id = createJobId("now");
+    await this.createRecord(id, name, "runNow", options.payload, options.priority, getMaxAttempts(options.retry), {
+      status: "pending"
+    });
+    this.entries.set(id, {
+      id,
+      name,
+      kind: "runNow",
+      task: options.task,
+      retry: options.retry,
+      timeoutMs: options.timeout ?? this.config.defaultTimeout,
+      preventOverlap: false
+    });
+    return this.executeJob(id);
+  }
+  async runWorker(name, options) {
+    validateJobName(name);
+    assertSerializablePayload(options.payload, this.config.maxPayloadBytes);
+    const id = createJobId("worker");
+    await this.createRecord(id, name, "worker", options.payload, options.priority, getMaxAttempts(options.retry), {
+      status: "pending"
+    });
+    const timeoutMs = options.timeout ?? this.config.defaultTimeout;
+    const workerTask = typeof options.worker === "function" ? options.worker : async (context) => this.workerPool.run({
+      worker: options.worker,
+      payload: context.payload,
+      jobId: context.jobId,
+      name: context.name,
+      attempt: context.attempt,
+      timeoutMs,
+      createdAt: context.createdAt.toISOString(),
+      startedAt: context.startedAt.toISOString()
+    });
+    if (typeof options.worker === "function") {
+      this.logger.warn(
+        "runWorker received an inline function. For security, SilentCronX does not eval code strings; the function will run through the async runner. Pass { path, exportName } to use worker_threads."
+      );
+    }
+    this.entries.set(id, {
+      id,
+      name,
+      kind: "worker",
+      task: workerTask,
+      retry: options.retry,
+      timeoutMs,
+      preventOverlap: false
+    });
+    return this.executeJob(id);
+  }
+  queue(name, options = {}) {
+    this.queueManager.createQueue(name, options);
+  }
+  addJob(queueName, job) {
+    return this.queueManager.addJob(queueName, job);
+  }
+  async cancel(jobId) {
+    this.controllers.get(jobId)?.abort(new JobCancelledError());
+    const job = await this.storage.getJob(jobId);
+    if (!job) return;
+    this.clearTimer(jobId);
+    await this.storage.updateJob(jobId, { status: "cancelled", finishedAt: nowIso() });
+    this.eventBus.emit("job:cancelled", { jobId, name: job.name });
+  }
+  async pause(jobId) {
+    const job = await this.storage.getJob(jobId);
+    if (!job) return;
+    this.clearTimer(jobId);
+    await this.storage.updateJob(jobId, { status: "paused" });
+    this.eventBus.emit("job:paused", { jobId, name: job.name });
+  }
+  async resume(jobId) {
+    const job = await this.storage.getJob(jobId);
+    const entry = this.entries.get(jobId);
+    if (!job || !entry) return;
+    await this.storage.updateJob(jobId, { status: entry.kind === "runNow" ? "pending" : "scheduled" });
+    this.eventBus.emit("job:resumed", { jobId, name: job.name });
+    if (this.running) this.armEntry(jobId);
+  }
+  async getStatus(jobId) {
+    const job = await this.storage.getJob(jobId);
+    if (!job) return null;
+    return {
+      jobId,
+      name: job.name,
+      status: job.status,
+      attempt: job.attempts,
+      nextRunAt: job.nextRunAt,
+      lastRunAt: job.lastRunAt
+    };
+  }
+  getJobs() {
+    return this.storage.listJobs();
+  }
+  start() {
+    if (this.running) return;
+    this.running = true;
+    for (const jobId of this.entries.keys()) this.armEntry(jobId);
+    this.eventBus.emit("scheduler:started", { running: true, at: nowIso() });
+  }
+  stop() {
+    if (!this.running) return;
+    this.running = false;
+    for (const jobId of this.entries.keys()) this.clearTimer(jobId);
+    this.eventBus.emit("scheduler:stopped", { running: false, at: nowIso() });
+  }
+  async shutdown() {
+    this.stop();
+    for (const controller of this.controllers.values()) controller.abort(new JobCancelledError("Scheduler shutdown"));
+    this.controllers.clear();
+    await this.workerPool.shutdown();
+    this.eventBus.emit("scheduler:shutdown", { at: nowIso() });
+  }
+  on(eventName, handler) {
+    this.eventBus.on(eventName, handler);
+  }
+  off(eventName, handler) {
+    this.eventBus.off(eventName, handler);
+  }
+  async getHealth() {
+    const jobs = await this.storage.listJobs();
+    return {
+      running: this.running,
+      scheduledJobs: jobs.filter((job) => job.status === "scheduled").length,
+      runningJobs: jobs.filter((job) => job.status === "running").length,
+      queuedJobs: this.queueManager.getQueuedCount(),
+      workers: this.workerPool.getStats(),
+      memory: {
+        storage: this.storage instanceof MemoryStorageAdapter ? "memory" : "custom"
+      }
+    };
+  }
+  async executeJob(jobId, taskOverride) {
+    while (this.runner.getActiveCount() >= this.config.maxConcurrency) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    const record = await this.storage.getJob(jobId);
+    const entry = this.entries.get(jobId);
+    const task = taskOverride ?? entry?.task;
+    if (!record || !entry || !task) throw new SilentCronXError(`Job cannot be executed: ${jobId}`);
+    if (record.status === "cancelled" || record.status === "paused") {
+      return { jobId, name: record.name, status: record.status, attempt: record.attempts, durationMs: 0 };
+    }
+    const controller = new AbortController();
+    this.controllers.set(jobId, controller);
+    try {
+      return await this.runner.run({
+        record,
+        task,
+        retry: entry.retry,
+        timeoutMs: entry.timeoutMs,
+        signal: controller.signal,
+        lockKey: entry.preventOverlap ? `job:${record.name}` : void 0,
+        lockTtlMs: this.config.lockTimeout,
+        storage: this.storage,
+        eventBus: this.eventBus,
+        acquireLock: (key, ttl) => this.lockManager.acquire(key, ttl),
+        releaseLock: (key) => this.lockManager.release(key)
+      });
+    } finally {
+      this.controllers.delete(jobId);
+    }
+  }
+  armEntry(jobId) {
+    const entry = this.entries.get(jobId);
+    if (!entry) return;
+    if (entry.kind === "cron") this.armCron(jobId);
+    else if (entry.kind === "delay") this.armDelay(jobId, entry.delayMs ?? 0);
+    else if (entry.kind === "every") this.armEvery(jobId);
+  }
+  async armCron(jobId) {
+    const entry = this.entries.get(jobId);
+    const record = await this.storage.getJob(jobId);
+    if (!entry?.cron || !record || record.status === "paused" || record.status === "cancelled") return;
+    const next = getNextCronDate(entry.cron, /* @__PURE__ */ new Date(), this.config.timezone);
+    await this.storage.updateJob(jobId, { status: "scheduled", nextRunAt: next.toISOString() });
+    this.clearTimer(jobId);
+    const timer = setTimeout(() => {
+      void this.executeJob(jobId).finally(() => {
+        if (this.running) void this.armCron(jobId);
+      });
+    }, Math.max(1, next.getTime() - Date.now()));
+    timer.unref?.();
+    entry.timer = timer;
+  }
+  armDelay(jobId, delayMs) {
+    const entry = this.entries.get(jobId);
+    if (!entry) return;
+    this.clearTimer(jobId);
+    const timer = setTimeout(() => void this.executeJob(jobId), delayMs);
+    timer.unref?.();
+    entry.timer = timer;
+  }
+  async armEvery(jobId) {
+    const entry = this.entries.get(jobId);
+    const record = await this.storage.getJob(jobId);
+    if (!entry?.intervalMs || !record || record.status === "paused" || record.status === "cancelled") return;
+    const next = new Date(Date.now() + entry.intervalMs);
+    await this.storage.updateJob(jobId, { status: "scheduled", nextRunAt: next.toISOString() });
+    this.clearTimer(jobId);
+    const timer = setTimeout(() => {
+      void this.executeJob(jobId).finally(() => {
+        if (this.running) void this.armEvery(jobId);
+      });
+    }, entry.intervalMs);
+    timer.unref?.();
+    entry.timer = timer;
+  }
+  clearTimer(jobId) {
+    const entry = this.entries.get(jobId);
+    if (entry?.timer) clearTimeout(entry.timer);
+    if (entry) entry.timer = void 0;
+  }
+  async createRecord(id, name, kind, payload, priority = 0, maxAttempts = 1, extra = {}) {
+    const createdAt = nowIso();
+    await this.storage.saveJob({
+      id,
+      name,
+      kind,
+      status: extra.status ?? "pending",
+      payload,
+      priority,
+      attempts: 0,
+      maxAttempts,
+      createdAt,
+      updatedAt: createdAt,
+      successCount: 0,
+      failureCount: 0,
+      ...extra
+    });
+  }
+};
+
+// src/core/createSilentCronX.ts
+function createSilentCronX(config = {}) {
+  return new SilentCronX(config);
+}
+
+// src/storage/RedisStorageAdapter.placeholder.ts
+var RedisStorageAdapter = class {
+  constructor() {
+    throw new Error(
+      "RedisStorageAdapter is a design placeholder. Implement StorageAdapter with SET NX PX locks, JSON job records, and atomic updates for multi-instance production use."
+    );
+  }
+  saveJob(_job) {
+    throw new Error("Not implemented");
+  }
+  updateJob(_jobId, _patch) {
+    throw new Error("Not implemented");
+  }
+  getJob(_jobId) {
+    throw new Error("Not implemented");
+  }
+  listJobs(_filter) {
+    throw new Error("Not implemented");
+  }
+  deleteJob(_jobId) {
+    throw new Error("Not implemented");
+  }
+  acquireLock(_lockKey, _ttlMs) {
+    throw new Error("Not implemented");
+  }
+  releaseLock(_lockKey) {
+    throw new Error("Not implemented");
+  }
+};
+
+// src/storage/PostgresStorageAdapter.placeholder.ts
+var PostgresStorageAdapter = class {
+  constructor() {
+    throw new Error(
+      "PostgresStorageAdapter is a design placeholder. Implement StorageAdapter using transactions, row-level locks, indexed status columns, and advisory locks for production use."
+    );
+  }
+  saveJob(_job) {
+    throw new Error("Not implemented");
+  }
+  updateJob(_jobId, _patch) {
+    throw new Error("Not implemented");
+  }
+  getJob(_jobId) {
+    throw new Error("Not implemented");
+  }
+  listJobs(_filter) {
+    throw new Error("Not implemented");
+  }
+  deleteJob(_jobId) {
+    throw new Error("Not implemented");
+  }
+  acquireLock(_lockKey, _ttlMs) {
+    throw new Error("Not implemented");
+  }
+  releaseLock(_lockKey) {
+    throw new Error("Not implemented");
+  }
+};
+export {
+  MemoryStorageAdapter,
+  PostgresStorageAdapter,
+  RedisStorageAdapter,
+  SilentCronX,
+  createSilentCronX
+};
+//# sourceMappingURL=index.js.map