@happyvertical/smrt-jobs 0.30.0

package/dist/index.js

@@ -0,0 +1,926 @@
+import { D as DEFAULT_TENANT_JOB_CAP, c as clampRetries, S as SmrtJobCollection, a as DEFAULT_TASK_HEARTBEAT_INTERVAL_MS, b as SmrtWorkerCollection, r as redactErrorMessage, d as redactErrorForPersistence } from "./chunks/runner-DV8FBO0y.js";
+import { J, M, e, f, g, h, T, i, j, k, l, m, n, o } from "./chunks/runner-DV8FBO0y.js";
+import { exponential } from "@happyvertical/jobs";
+import { ObjectRegistry } from "@happyvertical/smrt-core";
+import { EventEmitter } from "node:events";
+import { createLogger } from "@happyvertical/logger";
+import { createId } from "@happyvertical/utils";
+import { i as isWorkerAlive } from "./chunks/worker-liveness-DOTjoIjr.js";
+import { c, r, u } from "./chunks/worker-liveness-DOTjoIjr.js";
+class JobHandle {
+  constructor(id, collection) {
+    this.id = id;
+    this.collection = collection;
+  }
+  id;
+  collection;
+  /**
+   * Get the current job status
+   */
+  async status() {
+    const job = await this.getJob();
+    return job.status;
+  }
+  /**
+   * Get the full job object
+   */
+  async getJob() {
+    const job = await this.collection.get({ id: this.id });
+    if (!job) {
+      throw new Error(`Job not found: ${this.id}`);
+    }
+    return job;
+  }
+  /**
+   * Wait for the job to complete
+   *
+   * @param options - Wait configuration
+   * @returns The job result
+   * @throws Error if the job fails or times out
+   */
+  async wait(options = {}) {
+    const { timeout = 6e4, pollInterval = 100 } = options;
+    const startTime = Date.now();
+    while (true) {
+      const job = await this.getJob();
+      if (job.status === "completed") {
+        return {
+          success: true,
+          resultPointer: job.resultPointer
+        };
+      }
+      if (job.status === "failed") {
+        return {
+          success: false,
+          error: job.lastError ?? "Job failed"
+        };
+      }
+      if (job.status === "cancelled") {
+        return {
+          success: false,
+          error: "Job was cancelled"
+        };
+      }
+      if (Date.now() - startTime >= timeout) {
+        throw new Error(`Timeout waiting for job ${this.id}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+  }
+  /**
+   * Cancel the job
+   */
+  async cancel() {
+    const job = await this.getJob();
+    await job.cancel();
+  }
+  /**
+   * Retry a failed job
+   */
+  async retry() {
+    const job = await this.getJob();
+    await job.retry();
+  }
+  /**
+   * Check if the job is still running
+   */
+  async isRunning() {
+    const status = await this.status();
+    return status === "pending" || status === "running";
+  }
+  /**
+   * Check if the job has completed (successfully or not)
+   */
+  async isDone() {
+    const status = await this.status();
+    return status === "completed" || status === "failed" || status === "cancelled";
+  }
+}
+function priorityToNumber(priority) {
+  if (typeof priority === "number") return priority;
+  switch (priority) {
+    case "critical":
+      return 100;
+    case "high":
+      return 75;
+    case "normal":
+      return 50;
+    case "low":
+      return 25;
+    default:
+      return 50;
+  }
+}
+function parseDelay(delay) {
+  if (typeof delay === "number") return delay;
+  const match = delay.match(/^(\d+)(ms|s|m|h|d)?$/);
+  if (!match) {
+    throw new Error(`Invalid delay format: ${delay}`);
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2] || "ms";
+  switch (unit) {
+    case "ms":
+      return value;
+    case "s":
+      return value * 1e3;
+    case "m":
+      return value * 60 * 1e3;
+    case "h":
+      return value * 60 * 60 * 1e3;
+    case "d":
+      return value * 24 * 60 * 60 * 1e3;
+    default:
+      return value;
+  }
+}
+class JobBuilder {
+  constructor(objectType, objectId, method, args, collection) {
+    this.objectType = objectType;
+    this.objectId = objectId;
+    this.method = method;
+    this.args = args;
+    this.collection = collection;
+  }
+  objectType;
+  objectId;
+  method;
+  args;
+  collection;
+  _queue = "default";
+  _delay = 0;
+  _retries = 3;
+  _priority = 50;
+  _timeout = 3e5;
+  _timeoutBehavior = "fail";
+  _retryStrategy = exponential();
+  _tenantJobCap = DEFAULT_TENANT_JOB_CAP;
+  /**
+   * Set the queue name
+   */
+  queue(name) {
+    this._queue = name;
+    return this;
+  }
+  /**
+   * Set a delay before the job runs
+   * @param delay - Delay as milliseconds or string like '5m', '1h', '30s'
+   */
+  delay(delay) {
+    this._delay = parseDelay(delay);
+    return this;
+  }
+  /**
+   * Set when the job should run
+   */
+  runAt(date) {
+    this._delay = date.getTime() - Date.now();
+    return this;
+  }
+  /**
+   * Set the maximum number of retry attempts.
+   *
+   * Clamped to {@link MAX_JOB_RETRIES} so a misconfigured caller cannot pin a
+   * worker on a poison job indefinitely (S5 audit #1402).
+   */
+  retries(count) {
+    this._retries = clampRetries(count);
+    return this;
+  }
+  /**
+   * Set the retry strategy
+   */
+  retryStrategy(strategy) {
+    this._retryStrategy = strategy;
+    return this;
+  }
+  /**
+   * Set the job priority
+   */
+  priority(level) {
+    this._priority = priorityToNumber(level);
+    return this;
+  }
+  /**
+   * Set the job timeout in milliseconds
+   */
+  timeout(ms) {
+    this._timeout = ms;
+    return this;
+  }
+  /**
+   * Set what happens when the job times out
+   */
+  timeoutBehavior(behavior) {
+    this._timeoutBehavior = behavior;
+    return this;
+  }
+  /**
+   * Override the per-tenant in-flight job cap for this enqueue.
+   *
+   * Defaults to {@link DEFAULT_TENANT_JOB_CAP}. Pass `0` (or a negative value)
+   * to disable the cap for trusted internal callers (S5 audit #1402).
+   */
+  tenantJobCap(max) {
+    this._tenantJobCap = max;
+    return this;
+  }
+  /**
+   * Enqueue the job and return a handle
+   */
+  async enqueue() {
+    const runAt = new Date(Date.now() + this._delay);
+    const retryConfig = "toConfig" in this._retryStrategy ? this._retryStrategy.toConfig() : this._retryStrategy;
+    const job = await this.collection.enqueueJob(
+      {
+        queue: this._queue,
+        objectType: this.objectType,
+        objectId: this.objectId,
+        method: this.method,
+        args: this.args,
+        runAt,
+        priority: this._priority,
+        maxAttempts: this._retries,
+        timeout: this._timeout,
+        timeoutBehavior: this._timeoutBehavior,
+        retryStrategy: retryConfig
+      },
+      { tenantJobCap: this._tenantJobCap }
+    );
+    const jobId = job.id;
+    if (!jobId) {
+      throw new Error("Job was created but has no ID");
+    }
+    return new JobHandle(jobId, this.collection);
+  }
+}
+const collectionCache = /* @__PURE__ */ new WeakMap();
+async function getJobCollection(db) {
+  let collection = collectionCache.get(db);
+  if (!collection) {
+    collection = await SmrtJobCollection.create({
+      db: { type: "sqlite", url: ":memory:" }
+      // Placeholder
+    });
+    collection._db = db;
+    collectionCache.set(db, collection);
+  }
+  return collection;
+}
+function getObjectTypeName(instance) {
+  const metaType = instance._meta_type;
+  if (typeof metaType === "string" && metaType.length > 0) {
+    return metaType;
+  }
+  const className = instance.constructor.name;
+  return ObjectRegistry.getClass(className)?.qualifiedName || className;
+}
+function requireObjectDb(instance) {
+  const db = instance._db;
+  if (!db) {
+    throw new Error("Object not initialized. Call initialize() first.");
+  }
+  return db;
+}
+async function bgImpl(method, args = {}, options = {}) {
+  const db = requireObjectDb(this);
+  const collection = await getJobCollection(db);
+  const builder = new JobBuilder(
+    getObjectTypeName(this),
+    this.id ?? null,
+    method,
+    args,
+    collection
+  );
+  if (options.queue) builder.queue(options.queue);
+  if (options.priority) builder.priority(options.priority);
+  if (options.delay) builder.delay(options.delay);
+  if (options.retries !== void 0) builder.retries(options.retries);
+  if (options.timeout) builder.timeout(options.timeout);
+  return builder.enqueue();
+}
+function backgroundImpl(method, args = {}) {
+  const db = requireObjectDb(this);
+  const objectType = getObjectTypeName(this);
+  const objectId = this.id ?? null;
+  const lazyBuilder = {
+    _queue: "default",
+    _delay: 0,
+    _retries: 3,
+    _priority: 50,
+    _timeout: 3e5,
+    _timeoutBehavior: "fail",
+    _retryStrategy: null,
+    // `undefined` => fall through to JobBuilder's DEFAULT_TENANT_JOB_CAP. A
+    // caller can override (incl. `0` to disable) via tenantJobCap() below.
+    _tenantJobCap: void 0,
+    queue(name) {
+      this._queue = name;
+      return this;
+    },
+    delay(d) {
+      this._delay = parseDelay(d);
+      return this;
+    },
+    runAt(date) {
+      this._delay = date.getTime() - Date.now();
+      return this;
+    },
+    retries(count) {
+      this._retries = count;
+      return this;
+    },
+    retryStrategy(strategy) {
+      this._retryStrategy = strategy;
+      return this;
+    },
+    priority(level) {
+      this._priority = priorityToNumber(level);
+      return this;
+    },
+    timeout(ms) {
+      this._timeout = ms;
+      return this;
+    },
+    timeoutBehavior(behavior) {
+      this._timeoutBehavior = behavior;
+      return this;
+    },
+    tenantJobCap(max) {
+      this._tenantJobCap = max;
+      return this;
+    },
+    async enqueue() {
+      const collection = await getJobCollection(db);
+      const builder = new JobBuilder(
+        objectType,
+        objectId,
+        method,
+        args,
+        collection
+      );
+      builder.queue(this._queue);
+      builder.delay(this._delay);
+      builder.retries(this._retries);
+      builder.priority(this._priority);
+      builder.timeout(this._timeout);
+      builder.timeoutBehavior(this._timeoutBehavior);
+      if (this._tenantJobCap !== void 0) {
+        builder.tenantJobCap(this._tenantJobCap);
+      }
+      if (this._retryStrategy) {
+        builder.retryStrategy(
+          this._retryStrategy
+        );
+      }
+      return builder.enqueue();
+    }
+  };
+  return lazyBuilder;
+}
+function withBackgroundJobs(BaseClass) {
+  const prototype = BaseClass.prototype;
+  if (typeof prototype.bg !== "function") {
+    Object.defineProperty(prototype, "bg", {
+      value: bgImpl,
+      writable: true,
+      configurable: true
+    });
+  }
+  if (typeof prototype.background !== "function") {
+    Object.defineProperty(prototype, "background", {
+      value: backgroundImpl,
+      writable: true,
+      configurable: true
+    });
+  }
+  return BaseClass;
+}
+const DEFAULT_CONFIG = {
+  id: "",
+  pollInterval: 6e4,
+  // 1 minute
+  batchSize: 50,
+  staleJobThresholdMs: 9e4,
+  taskHeartbeatInterval: DEFAULT_TASK_HEARTBEAT_INTERVAL_MS
+};
+class ScheduleRunner extends EventEmitter {
+  id;
+  config;
+  jobCollection = null;
+  workerCollection = null;
+  running = false;
+  pollTimer = null;
+  db = null;
+  logger = createLogger(true);
+  constructor(config = {}) {
+    super();
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config,
+      id: config.id || `schedule_${createId().slice(0, 8)}`
+    };
+    this.id = this.config.id;
+  }
+  /**
+   * Initialize the runner with database connection
+   */
+  async initialize(db) {
+    this.db = db;
+    this.jobCollection = await SmrtJobCollection.create({ db });
+    this.workerCollection = await SmrtWorkerCollection.create({ db });
+  }
+  /**
+   * Start processing schedules
+   */
+  async start() {
+    if (this.running) return;
+    if (!this.db) {
+      throw new Error(
+        "ScheduleRunner not initialized. Call initialize() first."
+      );
+    }
+    this.running = true;
+    this.startPolling();
+    this.emit("runner:started");
+    this.logger.info("ScheduleRunner started", { id: this.id });
+  }
+  /**
+   * Stop processing schedules
+   */
+  async stop() {
+    if (!this.running) return;
+    this.running = false;
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.emit("runner:stopped");
+    this.logger.info("ScheduleRunner stopped", { id: this.id });
+  }
+  /**
+   * Check if runner is running
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Handle job completion for a scheduled job.
+   *
+   * Call this from TaskRunner's job:completed / job:failed events
+   * when the job has a `_scheduleId` in its args.
+   */
+  async handleJobCompletion(scheduleId, success, errorMessage) {
+    if (!this.db) return;
+    const safeErrorMessage = redactErrorMessage(
+      errorMessage ?? "Unknown error"
+    );
+    try {
+      if (success) {
+        await this.db.query(
+          `UPDATE _smrt_agent_schedules
+           SET running_count = CASE WHEN COALESCE(running_count, 0) > 0 THEN running_count - 1 ELSE 0 END,
+               last_run = ?,
+               last_status = 'success',
+               last_error = NULL,
+               run_count = COALESCE(run_count, 0) + 1,
+               success_count = COALESCE(success_count, 0) + 1
+           WHERE id = ?`,
+          (/* @__PURE__ */ new Date()).toISOString(),
+          scheduleId
+        );
+        this.emit("schedule:completed", scheduleId);
+      } else {
+        await this.db.query(
+          `UPDATE _smrt_agent_schedules
+           SET running_count = CASE WHEN COALESCE(running_count, 0) > 0 THEN running_count - 1 ELSE 0 END,
+               last_run = ?,
+               last_status = 'failed',
+               last_error = ?,
+               run_count = COALESCE(run_count, 0) + 1,
+               failure_count = COALESCE(failure_count, 0) + 1
+           WHERE id = ?`,
+          (/* @__PURE__ */ new Date()).toISOString(),
+          safeErrorMessage,
+          scheduleId
+        );
+        this.emit("schedule:failed", scheduleId, safeErrorMessage);
+      }
+    } catch (err) {
+      this.logger.error("Failed to update schedule after job completion", {
+        scheduleId,
+        error: err
+      });
+    }
+  }
+  /**
+   * Start the polling loop
+   */
+  startPolling() {
+    const poll = async () => {
+      if (!this.running) return;
+      try {
+        await this.poll();
+      } catch (error) {
+        this.emit("runner:error", error);
+        this.logger.error("ScheduleRunner poll error", { error });
+      }
+      if (this.running) {
+        this.pollTimer = setTimeout(poll, this.config.pollInterval);
+      }
+    };
+    poll();
+  }
+  /**
+   * Poll for due schedules and create jobs
+   */
+  async poll() {
+    if (!this.db || !this.jobCollection) return;
+    await this.recoverStaleScheduleState();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const result = await this.db.query(
+      `SELECT * FROM _smrt_agent_schedules
+       WHERE enabled = true
+       AND status = 'active'
+       AND next_run <= ?
+       AND COALESCE(running_count, 0) < COALESCE(max_concurrent, 1)
+       ORDER BY next_run ASC
+       LIMIT ?`,
+      now,
+      this.config.batchSize
+    );
+    for (const row of result.rows) {
+      await this.triggerSchedule(row);
+    }
+  }
+  /**
+   * Reconcile stuck schedule slots against running jobs.
+   *
+   * This handles two failure modes:
+   * - a running job's owning worker is no longer alive (dead/restarted)
+   * - a schedule slot remains occupied even though no running job still exists
+   *
+   * Staleness keys on worker *liveness* (issue #1474), not per-job heartbeat
+   * freshness: a job whose `worker_id` is live in this process or holds a fresh
+   * lease in `_smrt_workers` is healthy even if its handler is holding the loop
+   * synchronously. ScheduleRunner has no in-process active-job set, so this is
+   * its entire correctness mechanism.
+   */
+  async recoverStaleScheduleState() {
+    if (!this.db || !this.workerCollection) return;
+    const schedulesResult = await this.db.query(
+      `SELECT id, running_count
+         FROM _smrt_agent_schedules
+        WHERE COALESCE(running_count, 0) > 0`
+    );
+    const schedules = schedulesResult.rows;
+    if (schedules.length === 0) return;
+    const workersReady = await this.workerCollection.tableReady();
+    const freshLeaseKeys = workersReady ? await this.workerCollection.freshLeaseWorkerKeys() : /* @__PURE__ */ new Set();
+    const jobsResult = await this.db.query(
+      `SELECT id, args, worker_id
+         FROM _smrt_jobs
+        WHERE status = 'running'`
+    );
+    const jobRows = jobsResult.rows;
+    const stateBySchedule = /* @__PURE__ */ new Map();
+    for (const schedule of schedules) {
+      stateBySchedule.set(schedule.id, { live: 0, staleJobIds: [] });
+    }
+    for (const row of jobRows) {
+      const scheduleId = this.getScheduleIdFromJobArgs(row.args);
+      if (!scheduleId) continue;
+      const state = stateBySchedule.get(scheduleId);
+      if (!state) continue;
+      const alive = workersReady ? isWorkerAlive(row.worker_id, freshLeaseKeys) : true;
+      if (!alive) {
+        state.staleJobIds.push(row.id);
+      } else {
+        state.live += 1;
+      }
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const staleJobIds = schedules.flatMap((schedule) => {
+      const state = stateBySchedule.get(schedule.id);
+      return state?.staleJobIds ?? [];
+    });
+    const recoveredJobIds = /* @__PURE__ */ new Set();
+    if (staleJobIds.length > 0) {
+      const placeholders = staleJobIds.map(() => "?").join(", ");
+      const result = await this.db.query(
+        `UPDATE _smrt_jobs
+            SET status = 'failed',
+                completed_at = ?,
+                last_error = ?,
+                worker_id = NULL,
+                worker_heartbeat = NULL
+          WHERE status = 'running'
+            AND id IN (${placeholders})
+          RETURNING id`,
+        now,
+        "Recovered orphaned scheduled job: its owning worker is no longer alive (no fresh liveness lease in _smrt_workers and not running in this process).",
+        ...staleJobIds
+      );
+      for (const row of result.rows) {
+        if (typeof row.id === "string") recoveredJobIds.add(row.id);
+      }
+    }
+    for (const schedule of schedules) {
+      const state = stateBySchedule.get(schedule.id);
+      if (!state) continue;
+      const desiredRunningCount = state.live;
+      const recoveredCount = state.staleJobIds.filter(
+        (id) => recoveredJobIds.has(id)
+      ).length;
+      if (Number(schedule.running_count) === desiredRunningCount && recoveredCount === 0) {
+        continue;
+      }
+      if (recoveredCount > 0) {
+        await this.db.query(
+          `UPDATE _smrt_agent_schedules
+              SET running_count = ?,
+                  last_run = ?,
+                  last_status = 'failed',
+                  last_error = ?,
+                  run_count = COALESCE(run_count, 0) + ?,
+                  failure_count = COALESCE(failure_count, 0) + ?
+            WHERE id = ?`,
+          desiredRunningCount,
+          now,
+          `Recovered ${recoveredCount} orphaned scheduled job(s) from dead worker(s)`,
+          recoveredCount,
+          recoveredCount,
+          schedule.id
+        );
+        this.emit(
+          "schedule:failed",
+          schedule.id,
+          `Recovered ${recoveredCount} orphaned scheduled job(s)`
+        );
+      } else {
+        await this.db.query(
+          `UPDATE _smrt_agent_schedules
+              SET running_count = ?
+            WHERE id = ?`,
+          desiredRunningCount,
+          schedule.id
+        );
+      }
+    }
+  }
+  getScheduleIdFromJobArgs(args) {
+    if (!args) return null;
+    let parsedArgs = args;
+    if (typeof parsedArgs === "string") {
+      try {
+        parsedArgs = JSON.parse(parsedArgs);
+      } catch {
+        return null;
+      }
+    }
+    if (!parsedArgs || typeof parsedArgs !== "object" || Array.isArray(parsedArgs)) {
+      return null;
+    }
+    const scheduleId = parsedArgs._scheduleId;
+    return typeof scheduleId === "string" && scheduleId.length > 0 ? scheduleId : null;
+  }
+  /**
+   * Trigger a schedule by creating a job
+   */
+  async triggerSchedule(schedule) {
+    if (!this.db || !this.jobCollection) return;
+    const rawAgentType = schedule.agent_type;
+    const canonicalAgentType = ObjectRegistry.getClass(rawAgentType)?.qualifiedName || rawAgentType;
+    const scheduleInfo = {
+      id: schedule.id,
+      agentType: canonicalAgentType,
+      agentId: schedule.agent_id,
+      cron: schedule.cron
+    };
+    try {
+      let methodArgs = {};
+      if (schedule.method_args) {
+        methodArgs = typeof schedule.method_args === "string" ? JSON.parse(schedule.method_args) : schedule.method_args;
+      }
+      let agentConfig = {};
+      if (schedule.agent_config) {
+        agentConfig = typeof schedule.agent_config === "string" ? JSON.parse(schedule.agent_config) : schedule.agent_config;
+      }
+      const nextRun = getNextCronDate(schedule.cron);
+      await this.db.query(
+        `UPDATE _smrt_agent_schedules
+         SET agent_type = ?,
+             running_count = running_count + 1,
+             next_run = ?
+         WHERE id = ?`,
+        canonicalAgentType,
+        nextRun.toISOString(),
+        schedule.id
+      );
+      const args = {
+        ...methodArgs,
+        _scheduleId: schedule.id
+      };
+      if (Object.keys(agentConfig).length > 0) {
+        args._agentConfig = agentConfig;
+      }
+      const job = await this.jobCollection.enqueueJob({
+        tenantId: typeof schedule.tenant_id === "string" && schedule.tenant_id.length > 0 ? schedule.tenant_id : null,
+        queue: "agents",
+        objectType: canonicalAgentType,
+        objectId: schedule.agent_id,
+        method: schedule.method || "run",
+        args,
+        priority: 75,
+        // High priority for scheduled agents
+        maxAttempts: 3,
+        timeout: schedule.timeout || 36e5
+      });
+      this.emit("schedule:triggered", scheduleInfo);
+      this.logger.info("Schedule triggered", {
+        scheduleId: schedule.id,
+        agentType: canonicalAgentType,
+        jobId: job.id,
+        nextRun: nextRun.toISOString()
+      });
+    } catch (error) {
+      await this.db.query(
+        `UPDATE _smrt_agent_schedules
+         SET running_count = running_count - 1,
+             status = 'error',
+             last_error = ?
+         WHERE id = ?`,
+        // Tolerate non-Error throwables: a thrown string/object has no
+        // `.message`, which would otherwise persist an empty `last_error`.
+        redactErrorForPersistence(error),
+        schedule.id
+      );
+      this.emit("schedule:error", scheduleInfo, error);
+      this.logger.error("Schedule trigger failed", {
+        scheduleId: schedule.id,
+        error
+      });
+    }
+  }
+}
+const CRON_FIELD_RANGES = [
+  { name: "minute", min: 0, max: 59 },
+  { name: "hour", min: 0, max: 23 },
+  { name: "day-of-month", min: 1, max: 31 },
+  { name: "month", min: 1, max: 12 },
+  { name: "day-of-week", min: 0, max: 7 }
+];
+function validateCronField(expr, range) {
+  if (expr === "*") return;
+  const reject = (detail) => {
+    throw new Error(
+      `Invalid cron expression: ${range.name} field "${expr}" ${detail} (valid range ${range.min}-${range.max})`
+    );
+  };
+  const assertInRange = (value) => {
+    if (!Number.isInteger(value) || value < range.min || value > range.max) {
+      reject("is out of range");
+    }
+  };
+  for (const term of expr.split(",")) {
+    if (term === "") reject("contains an empty value");
+    let body = term;
+    if (body.includes("/")) {
+      const stepParts = body.split("/");
+      if (stepParts.length !== 2) {
+        reject("has malformed step syntax");
+      }
+      const [rangePart, stepStr] = stepParts;
+      const step = Number(stepStr);
+      if (!Number.isInteger(step) || step <= 0) {
+        reject("has an invalid step");
+      }
+      body = rangePart;
+      if (body === "*") continue;
+    }
+    if (body.includes("-")) {
+      const rangeParts = body.split("-");
+      if (rangeParts.length !== 2) {
+        reject("has malformed range syntax");
+      }
+      const [startStr, endStr] = rangeParts;
+      if (startStr === "" || endStr === "") {
+        reject("has an empty range part");
+      }
+      const start = Number(startStr);
+      const end = Number(endStr);
+      assertInRange(start);
+      assertInRange(end);
+      if (start > end) reject("has an inverted range");
+    } else {
+      assertInRange(Number(body));
+    }
+  }
+}
+function validateCronExpression(cron) {
+  const parts = cron.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new Error(
+      `Invalid cron expression: expected 5 fields, got ${parts.length}`
+    );
+  }
+  parts.forEach((field, index) => {
+    validateCronField(field, CRON_FIELD_RANGES[index]);
+  });
+  return parts;
+}
+function getNextCronDate(cron) {
+  const [minuteExpr, hourExpr, dayExpr, monthExpr, dowExpr] = validateCronExpression(cron);
+  const now = /* @__PURE__ */ new Date();
+  const candidate = new Date(now);
+  candidate.setSeconds(0);
+  candidate.setMilliseconds(0);
+  candidate.setMinutes(candidate.getMinutes() + 1);
+  const dayIsWildcard = dayExpr === "*";
+  const dowIsWildcard = dowExpr === "*";
+  const maxIterations = 525600;
+  for (let i2 = 0; i2 < maxIterations; i2++) {
+    const dayMatches = matchesCronField(candidate.getDate(), dayExpr);
+    const dow = candidate.getDay();
+    const dowMatches = matchesCronField(dow, dowExpr) || dow === 0 && matchesCronField(7, dowExpr);
+    let dayOfMonthOrWeekMatches;
+    if (!dayIsWildcard && !dowIsWildcard) {
+      dayOfMonthOrWeekMatches = dayMatches || dowMatches;
+    } else if (!dayIsWildcard) {
+      dayOfMonthOrWeekMatches = dayMatches;
+    } else if (!dowIsWildcard) {
+      dayOfMonthOrWeekMatches = dowMatches;
+    } else {
+      dayOfMonthOrWeekMatches = true;
+    }
+    if (matchesCronField(candidate.getMonth() + 1, monthExpr) && dayOfMonthOrWeekMatches && matchesCronField(candidate.getHours(), hourExpr) && matchesCronField(candidate.getMinutes(), minuteExpr)) {
+      return candidate;
+    }
+    candidate.setMinutes(candidate.getMinutes() + 1);
+  }
+  throw new Error(`Could not find next run date for cron: ${cron}`);
+}
+function matchesCronField(value, expr) {
+  if (expr === "*") return true;
+  if (expr.includes("/")) {
+    const [range, stepStr] = expr.split("/");
+    const step = parseInt(stepStr, 10);
+    if (range === "*") return value % step === 0;
+    if (range.includes("-")) {
+      const [startStr, endStr] = range.split("-");
+      const start = parseInt(startStr, 10);
+      const end = parseInt(endStr, 10);
+      if (value < start || value > end) return false;
+      return (value - start) % step === 0;
+    }
+  }
+  if (expr.includes("-")) {
+    const [startStr, endStr] = expr.split("-");
+    const start = parseInt(startStr, 10);
+    const end = parseInt(endStr, 10);
+    return value >= start && value <= end;
+  }
+  if (expr.includes(",")) {
+    const values = expr.split(",").map((v) => parseInt(v.trim(), 10));
+    return values.includes(value);
+  }
+  return value === parseInt(expr, 10);
+}
+function createScheduleRunner(config) {
+  return new ScheduleRunner(config);
+}
+export {
+  DEFAULT_TENANT_JOB_CAP,
+  JobBuilder,
+  J as JobContextLogger,
+  JobHandle,
+  M as MAX_JOB_RETRIES,
+  ScheduleRunner,
+  e as SmrtJob,
+  SmrtJobCollection,
+  f as SmrtJobEvent,
+  g as SmrtJobEventCollection,
+  h as SmrtWorker,
+  SmrtWorkerCollection,
+  T as TaskRunner,
+  i as TenantJobCapExceededError,
+  j as assertWithinTenantCreationCap,
+  k as backgroundEligible,
+  clampRetries,
+  createScheduleRunner,
+  l as createTaskRunner,
+  c as createWorkerKey,
+  m as getBackgroundEligibleMethods,
+  n as isBackgroundEligibleMethod,
+  isWorkerAlive,
+  o as markBackgroundEligible,
+  parseDelay,
+  priorityToNumber,
+  redactErrorForPersistence,
+  redactErrorMessage,
+  r as registerLiveWorker,
+  u as unregisterLiveWorker,
+  validateCronExpression,
+  withBackgroundJobs
+};
+//# sourceMappingURL=index.js.map