@happyvertical/smrt-jobs 0.37.1 → 0.37.3

package/dist/index.js

@@ -1,619 +1,523 @@
-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-2zRlEef7.js";
-import { J, e, M, f, g, h, i, T, j, k, l, m, n, o, p } from "./chunks/runner-2zRlEef7.js";
-import { exponential } from "@happyvertical/jobs";
+import { S as markBackgroundEligible, _ as assertWithinTenantCreationCap, a as SmrtWorker, b as getBackgroundEligibleMethods, c as SmrtJobEventCollection, d as JobContextLogger, f as redactErrorForPersistence, g as TenantJobCapExceededError, h as MAX_JOB_RETRIES, i as DEFAULT_TASK_HEARTBEAT_INTERVAL_MS, l as SmrtJob, m as DEFAULT_TENANT_JOB_CAP, n as TaskRunner, o as SmrtWorkerCollection, p as redactErrorMessage, r as createTaskRunner, s as SmrtJobEvent, t as JobTimeoutError, u as SmrtJobCollection, v as backgroundEligible, x as isBackgroundEligibleMethod, y as clampRetries } from "./chunks/runner-DLsWfeY-.js";
+import { c as unregisterLiveWorker, i as registerLiveWorker, n as isWorkerAlive, t as createWorkerKey } from "./chunks/worker-liveness-C1Gjnhax.js";
 import { ObjectRegistry } from "@happyvertical/smrt-core";
+import { exponential } from "@happyvertical/jobs";
 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";
-  }
-}
+//#region src/job-handle.ts
+var JobHandle = class {
+	constructor(id, collection) {
+		this.id = id;
+		this.collection = collection;
+	}
+	id;
+	collection;
+	/**
+	* Get the current job status
+	*/
+	async status() {
+		return (await this.getJob()).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() {
+		await (await this.getJob()).cancel();
+	}
+	/**
+	* Retry a failed job
+	*/
+	async retry() {
+		await (await this.getJob()).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";
+	}
+};
+//#endregion
+//#region src/job-builder.ts
 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;
-  }
+	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") {
-    if (!Number.isFinite(delay)) {
-      throw new Error(`Invalid delay value: ${delay}`);
-    }
-    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);
-  }
+	if (typeof delay === "number") {
+		if (!Number.isFinite(delay)) throw new Error(`Invalid delay value: ${delay}`);
+		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);
+	switch (match[2] || "ms") {
+		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;
+	}
 }
-const collectionCache = /* @__PURE__ */ new WeakMap();
+var JobBuilder = class {
+	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 jobId = (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 })).id;
+		if (!jobId) throw new Error("Job was created but has no ID");
+		return new JobHandle(jobId, this.collection);
+	}
+};
+//#endregion
+//#region src/object-extension.ts
+var 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;
+	let collection = collectionCache.get(db);
+	if (!collection) {
+		collection = await SmrtJobCollection.create({ db: {
+			type: "sqlite",
+			url: ":memory:"
+		} });
+		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;
+	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;
+	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();
+	const collection = await getJobCollection(requireObjectDb(this));
+	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;
+	const db = requireObjectDb(this);
+	const objectType = getObjectTypeName(this);
+	const objectId = this.id ?? null;
+	return {
+		_queue: "default",
+		_delay: 0,
+		_retries: 3,
+		_priority: 50,
+		_timeout: 3e5,
+		_timeoutBehavior: "fail",
+		_retryStrategy: null,
+		_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 builder = new JobBuilder(objectType, objectId, method, args, await getJobCollection(db));
+			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();
+		}
+	};
 }
 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 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
+//#endregion
+//#region src/schedule-runner.ts
+var DEFAULT_CONFIG = {
+	id: "",
+	pollInterval: 6e4,
+	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
+var ScheduleRunner = class 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
+           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 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
+       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 schedules = (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
+        WHERE COALESCE(running_count, 0) > 0`)).rows;
+		if (schedules.length === 0) return;
+		const workersReady = await this.workerCollection.tableReady();
+		const freshLeaseKeys = workersReady ? await this.workerCollection.freshLeaseWorkerKeys() : /* @__PURE__ */ new Set();
+		const jobRows = (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
+        WHERE status = 'running'`)).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;
+			if (!(workersReady ? isWorkerAlive(row.worker_id, freshLeaseKeys) : true)) state.staleJobIds.push(row.id);
+			else state.live += 1;
+		}
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const staleJobIds = schedules.flatMap((schedule) => {
+			return stateBySchedule.get(schedule.id)?.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 = ?,
@@ -621,311 +525,216 @@ class ScheduleRunner extends EventEmitter {
                 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
+          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
+            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);
-      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
-      });
-      await this.db.query(
-        `UPDATE _smrt_agent_schedules
+            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);
+			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,
+				maxAttempts: 3,
+				timeout: schedule.timeout || 36e5
+			});
+			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
-      );
-      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
+         WHERE id = ?`, canonicalAgentType, nextRun.toISOString(), schedule.id);
+			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 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 }
+         WHERE id = ?`, redactErrorForPersistence(error), schedule.id);
+			this.emit("schedule:error", scheduleInfo, error);
+			this.logger.error("Schedule trigger failed", {
+				scheduleId: schedule.id,
+				error
+			});
+		}
+	}
+};
+var 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));
-    }
-  }
+	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;
+	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}`);
+	const [minuteExpr, hourExpr, dayExpr, monthExpr, dowExpr] = validateCronExpression(cron);
+	const candidate = /* @__PURE__ */ new Date(/* @__PURE__ */ new Date());
+	candidate.setSeconds(0);
+	candidate.setMilliseconds(0);
+	candidate.setMinutes(candidate.getMinutes() + 1);
+	const dayIsWildcard = dayExpr === "*";
+	const dowIsWildcard = dowExpr === "*";
+	const maxIterations = 525600;
+	for (let i = 0; i < maxIterations; i++) {
+		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);
+	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);
+			if (value < start || value > parseInt(endStr, 10)) return false;
+			return (value - start) % step === 0;
+		}
+	}
+	if (expr.includes("-")) {
+		const [startStr, endStr] = expr.split("-");
+		return value >= parseInt(startStr, 10) && value <= parseInt(endStr, 10);
+	}
+	if (expr.includes(",")) return expr.split(",").map((v) => parseInt(v.trim(), 10)).includes(value);
+	return value === parseInt(expr, 10);
 }
 function createScheduleRunner(config) {
-  return new ScheduleRunner(config);
+	return new ScheduleRunner(config);
 }
-export {
-  DEFAULT_TENANT_JOB_CAP,
-  JobBuilder,
-  J as JobContextLogger,
-  JobHandle,
-  e as JobTimeoutError,
-  M as MAX_JOB_RETRIES,
-  ScheduleRunner,
-  f as SmrtJob,
-  SmrtJobCollection,
-  g as SmrtJobEvent,
-  h as SmrtJobEventCollection,
-  i as SmrtWorker,
-  SmrtWorkerCollection,
-  T as TaskRunner,
-  j as TenantJobCapExceededError,
-  k as assertWithinTenantCreationCap,
-  l as backgroundEligible,
-  clampRetries,
-  createScheduleRunner,
-  m as createTaskRunner,
-  c as createWorkerKey,
-  n as getBackgroundEligibleMethods,
-  getNextCronDate,
-  o as isBackgroundEligibleMethod,
-  isWorkerAlive,
-  p as markBackgroundEligible,
-  parseDelay,
-  priorityToNumber,
-  redactErrorForPersistence,
-  redactErrorMessage,
-  r as registerLiveWorker,
-  u as unregisterLiveWorker,
-  validateCronExpression,
-  withBackgroundJobs
-};
-//# sourceMappingURL=index.js.map
+//#endregion
+export { DEFAULT_TENANT_JOB_CAP, JobBuilder, JobContextLogger, JobHandle, JobTimeoutError, MAX_JOB_RETRIES, ScheduleRunner, SmrtJob, SmrtJobCollection, SmrtJobEvent, SmrtJobEventCollection, SmrtWorker, SmrtWorkerCollection, TaskRunner, TenantJobCapExceededError, assertWithinTenantCreationCap, backgroundEligible, clampRetries, createScheduleRunner, createTaskRunner, createWorkerKey, getBackgroundEligibleMethods, getNextCronDate, isBackgroundEligibleMethod, isWorkerAlive, markBackgroundEligible, parseDelay, priorityToNumber, redactErrorForPersistence, redactErrorMessage, registerLiveWorker, unregisterLiveWorker, validateCronExpression, withBackgroundJobs };
+
+//# sourceMappingURL=index.js.map