@rebasepro/server 0.12.0 → 0.12.1-canary.gdfba2a1

package/dist/cron-scheduler-B3RFt0HS.js

@@ -0,0 +1,647 @@
+import { createRequire as __createRequire } from "module";
+import process from "process";
+__createRequire(import.meta.url);
+import { n as __exportAll } from "./rolldown-runtime-DSJWtz9O.js";
+import { t as logger } from "./logger-BYU66ENZ.js";
+//#region src/cron/scale-to-zero.ts
+/**
+* Scale-to-zero detection for the cron scheduler.
+*
+* The scheduler drives jobs with in-process `setTimeout`. That works on any
+* always-running instance, but on a platform that freezes or evicts the
+* container between requests (Cloud Run with `--min-instances=0`, AWS Lambda,
+* Vercel functions) the timers simply never fire — the process boots, logs the
+* jobs as registered, and silently runs nothing.
+*
+* None of these platforms expose their scaling floor to the container, so this
+* detection is a heuristic: it identifies the *platform*, not the setting. It
+* is a warning only — it must never influence boot.
+*
+* Environment variables used here were verified against vendor documentation:
+*  - `K_SERVICE` / `K_REVISION` / `K_CONFIGURATION` — Cloud Run services
+*    (Cloud Run container contract; no variable exposes min-instances).
+*  - `CLOUD_RUN_JOB` — Cloud Run jobs (same contract).
+*  - `AWS_LAMBDA_FUNCTION_NAME` — reserved AWS Lambda runtime variable.
+*  - `VERCEL=1` — Vercel system environment variable, available at runtime.
+*  - `KUBERNETES_SERVICE_HOST` — injected into every pod by the kubelet. Used
+*    as an *exclusion*: a Deployment pod runs continuously, and Knative on
+*    Kubernetes also sets `K_SERVICE`, so a pod is never warned about.
+*/
+/** Environment variable that permanently silences the scale-to-zero warning. */
+var CRON_ALWAYS_ON_ENV = "REBASE_CRON_ALWAYS_ON";
+/** Accepts the usual truthy spellings; anything else (including "") is false. */
+function isTruthy(value) {
+	if (!value) return false;
+	const normalised = value.trim().toLowerCase();
+	return normalised === "1" || normalised === "true" || normalised === "yes" || normalised === "on";
+}
+/**
+* Identify a runtime whose instances can be frozen or torn down between
+* requests. Returns `undefined` when the platform is unknown or known to run
+* continuously.
+*/
+function detectFreezableRuntime(env = process.env) {
+	if (env.KUBERNETES_SERVICE_HOST) return void 0;
+	if (env.K_SERVICE) {
+		const signals = ["K_SERVICE"];
+		if (env.K_REVISION) signals.push("K_REVISION");
+		if (env.K_CONFIGURATION) signals.push("K_CONFIGURATION");
+		return {
+			platform: "Cloud Run",
+			signals
+		};
+	}
+	if (env.CLOUD_RUN_JOB) return {
+		platform: "Cloud Run Jobs",
+		signals: ["CLOUD_RUN_JOB"]
+	};
+	if (env.AWS_LAMBDA_FUNCTION_NAME) return {
+		platform: "AWS Lambda",
+		signals: ["AWS_LAMBDA_FUNCTION_NAME"]
+	};
+	if (env.VERCEL === "1") return {
+		platform: "Vercel",
+		signals: ["VERCEL"]
+	};
+}
+/** How many job ids to name before collapsing the rest into "+N more". */
+var MAX_NAMED_JOBS = 10;
+/**
+* Build the boot-time warning, or `undefined` when it does not apply.
+*
+* Fires only when all of the following hold:
+*  1. `NODE_ENV=production` — a laptop or CI run is not at risk.
+*  2. At least one *enabled* job is registered — nothing to lose otherwise.
+*  3. The environment looks like a freezable platform (see above).
+*  4. `REBASE_CRON_ALWAYS_ON` is not set to a truthy value.
+*/
+function buildScaleToZeroWarning(jobs, env = process.env) {
+	if (env.NODE_ENV !== "production") return void 0;
+	if (isTruthy(env["REBASE_CRON_ALWAYS_ON"])) return void 0;
+	const enabled = jobs.filter((job) => job.enabled).map((job) => job.id);
+	if (enabled.length === 0) return void 0;
+	const runtime = detectFreezableRuntime(env);
+	if (!runtime) return void 0;
+	const named = enabled.slice(0, MAX_NAMED_JOBS);
+	const list = enabled.length > named.length ? `${named.join(", ")} (+${enabled.length - named.length} more)` : named.join(", ");
+	return {
+		message: `[cron] ${runtime.platform} detected — in-process timers do not fire while an instance is frozen or scaled to zero, so ${enabled.length} enabled job(s) may never run: ${list}; drive them from an external scheduler instead (POST /api/cron/:id/trigger, e.g. Cloud Scheduler). ${runtime.platform} does not expose its scaling floor to the container, so an always-warm deployment cannot be confirmed from inside the process — set ${CRON_ALWAYS_ON_ENV}=1 to silence this if at least one instance is pinned warm.`,
+		data: {
+			platform: runtime.platform,
+			signals: runtime.signals,
+			jobs: enabled
+		}
+	};
+}
+//#endregion
+//#region src/cron/cron-scheduler.ts
+var cron_scheduler_exports = /* @__PURE__ */ __exportAll({
+	CronScheduler: () => CronScheduler,
+	findMostRecentSlot: () => findMostRecentSlot,
+	validateCronExpression: () => validateCronExpression
+});
+/**
+* Expand a single cron field into an ordered array of allowed values.
+* Supports: `*`, `N`, `N-M`, `N/S`, `N-M/S`, `*\/S`, and comma-separated combinations.
+*/
+function expandCronField(field, min, max) {
+	const results = /* @__PURE__ */ new Set();
+	for (const segment of field.split(",")) {
+		const trimmed = segment.trim();
+		if (trimmed === "*") for (let i = min; i <= max; i++) results.add(i);
+		else if (trimmed.includes("/")) {
+			const [rangeStr, stepStr] = trimmed.split("/");
+			const step = parseInt(stepStr, 10);
+			if (isNaN(step) || step <= 0) throw new Error(`Invalid step value "${stepStr}" in cron field "${field}"`);
+			let start = min;
+			let end = max;
+			if (rangeStr !== "*") if (rangeStr.includes("-")) {
+				const [a, b] = rangeStr.split("-").map(Number);
+				start = a;
+				end = b;
+			} else start = parseInt(rangeStr, 10);
+			for (let i = start; i <= end; i += step) results.add(i);
+		} else if (trimmed.includes("-")) {
+			const [a, b] = trimmed.split("-").map(Number);
+			for (let i = a; i <= b; i++) results.add(i);
+		} else {
+			const val = parseInt(trimmed, 10);
+			if (isNaN(val)) throw new Error(`Invalid value "${trimmed}" in cron field "${field}"`);
+			results.add(val);
+		}
+	}
+	return [...results].sort((a, b) => a - b);
+}
+/**
+* Validates a standard 5-field cron expression structurally and semantically.
+* Returns `{ valid: true }` or `{ valid: false, reason: string }`.
+*/
+function validateCronExpression(schedule) {
+	if (!schedule || typeof schedule !== "string") return {
+		valid: false,
+		reason: "Schedule must be a non-empty string"
+	};
+	const parts = schedule.trim().split(/\s+/);
+	if (parts.length !== 5) return {
+		valid: false,
+		reason: `Expected 5 fields, got ${parts.length}`
+	};
+	const fieldRanges = [
+		[
+			"minute",
+			0,
+			59
+		],
+		[
+			"hour",
+			0,
+			23
+		],
+		[
+			"day of month",
+			1,
+			31
+		],
+		[
+			"month",
+			1,
+			12
+		],
+		[
+			"day of week",
+			0,
+			6
+		]
+	];
+	for (let i = 0; i < 5; i++) {
+		const [name, min, max] = fieldRanges[i];
+		try {
+			const values = expandCronField(parts[i], min, max);
+			if (values.length === 0) return {
+				valid: false,
+				reason: `${name} field "${parts[i]}" produces no values`
+			};
+			for (const v of values) if (v < min || v > max) return {
+				valid: false,
+				reason: `${name} field value ${v} out of range [${min}–${max}]`
+			};
+		} catch (err) {
+			return {
+				valid: false,
+				reason: `${name} field: ${err instanceof Error ? err.message : String(err)}`
+			};
+		}
+	}
+	return { valid: true };
+}
+/** Expand all five fields of an expression. Throws on invalid expressions. */
+function parseCronFields(expression) {
+	const parts = expression.trim().split(/\s+/);
+	if (parts.length < 5) throw new Error(`Invalid cron expression: "${expression}". Expected 5 fields.`);
+	const [minField, hourField, domField, monField, dowField] = parts;
+	return {
+		minutes: expandCronField(minField, 0, 59),
+		hours: expandCronField(hourField, 0, 23),
+		doms: expandCronField(domField, 1, 31),
+		months: expandCronField(monField, 1, 12),
+		dows: expandCronField(dowField, 0, 6)
+	};
+}
+/** Whether a minute-precision instant matches every field of the expression. */
+function matchesCronFields(candidate, fields) {
+	return fields.months.includes(candidate.getMonth() + 1) && fields.doms.includes(candidate.getDate()) && fields.dows.includes(candidate.getDay()) && fields.hours.includes(candidate.getHours()) && fields.minutes.includes(candidate.getMinutes());
+}
+/** ~1 year in minutes — the walk bound for both search directions. */
+var MAX_SLOT_SEARCH_MINUTES = 525960;
+/**
+* Calculate the next Date after `after` that matches the cron expression.
+* Throws on invalid expressions.
+*/
+function parseCronExpression(expression, after) {
+	const fields = parseCronFields(expression);
+	const candidate = new Date(after);
+	candidate.setSeconds(0, 0);
+	candidate.setMinutes(candidate.getMinutes() + 1);
+	for (let i = 0; i < MAX_SLOT_SEARCH_MINUTES; i++) {
+		if (matchesCronFields(candidate, fields)) return candidate;
+		candidate.setMinutes(candidate.getMinutes() + 1);
+	}
+	const fallback = new Date(after);
+	fallback.setMinutes(fallback.getMinutes() + 1);
+	return fallback;
+}
+/**
+* The latest slot matching `expression` within the inclusive window
+* `[from, to]`, or `undefined` when the expression has no slot in it.
+*
+* Walks backwards a minute at a time from `to`, so the first hit is already
+* the answer — in the common case (a job that ran normally moments ago) that
+* is a handful of iterations, not a scan of the whole window.
+*
+* `to`'s own minute is included: an instance booting at 06:00:30 has *not* run
+* the 06:00 slot — `parseCronExpression` already skipped past it to tomorrow —
+* so that slot is genuinely missed and must be a candidate.
+*
+* Seconds and milliseconds are zeroed to match how `parseCronExpression`
+* builds a slot, so the same wall-clock slot serialises to a byte-identical
+* ISO string down either path. The claim key depends on that.
+*/
+function findMostRecentSlot(expression, from, to) {
+	const fields = parseCronFields(expression);
+	const candidate = new Date(to);
+	candidate.setSeconds(0, 0);
+	for (let i = 0; i < MAX_SLOT_SEARCH_MINUTES && candidate.getTime() >= from.getTime(); i++) {
+		if (matchesCronFields(candidate, fields)) return candidate;
+		candidate.setMinutes(candidate.getMinutes() - 1);
+	}
+}
+var MAX_LOGS_PER_JOB = 50;
+/**
+* Minimum milliseconds between scheduled executions of the same job.
+* Prevents tight re-execution loops caused by jitter or clock drift.
+*/
+var MIN_SCHEDULE_INTERVAL_MS = 5e3;
+var CronScheduler = class {
+	jobs = /* @__PURE__ */ new Map();
+	started = false;
+	store;
+	client;
+	/**
+	* Set the RebaseClient instance to make it available to cron job handlers.
+	*/
+	setClient(client) {
+		this.client = client;
+	}
+	/**
+	* Attach a persistence store for cron logs.
+	* When set, execution logs are written to the database after each run,
+	* and counters are seeded from the database on start.
+	*/
+	setStore(store) {
+		this.store = store;
+	}
+	/**
+	* Register a batch of loaded cron jobs.
+	*
+	* If the scheduler is already started, newly registered jobs are
+	* automatically scheduled (so late-registered jobs don't sit idle).
+	*
+	* Validates the cron schedule on registration — invalid schedules
+	* are rejected with a warning and the job is NOT registered.
+	*/
+	registerJobs(loadedJobs) {
+		for (const loaded of loadedJobs) {
+			const validation = validateCronExpression(loaded.definition.schedule);
+			if (!validation.valid) {
+				logger.error(`[cron] Rejecting job "${loaded.id}": invalid schedule "${loaded.definition.schedule}" — ${validation.reason}`);
+				continue;
+			}
+			if (this.jobs.get(loaded.id)) {
+				logger.warn(`[cron] Duplicate cron job id: "${loaded.id}". Overwriting.`);
+				this.stopJob(loaded.id);
+			}
+			const enabled = loaded.definition.enabled !== false;
+			this.jobs.set(loaded.id, {
+				id: loaded.id,
+				definition: loaded.definition,
+				enabled,
+				state: enabled ? "idle" : "disabled",
+				totalRuns: 0,
+				totalFailures: 0,
+				logs: [],
+				executing: false
+			});
+			if (this.started && enabled) this.scheduleNext(loaded.id);
+		}
+	}
+	/**
+	* Start the scheduler — begins ticking all enabled jobs.
+	*/
+	start() {
+		if (this.started) return;
+		this.started = true;
+		if (this.store) this.store.fetchJobStats().then((stats) => {
+			for (const [jobId, data] of stats) {
+				const job = this.jobs.get(jobId);
+				if (job) {
+					job.totalRuns = data.totalRuns;
+					job.totalFailures = data.totalFailures;
+					if (data.lastRunAt) job.lastRunAt = new Date(data.lastRunAt);
+				}
+			}
+		}).catch((err) => {
+			logger.warn("[cron] Failed to seed job stats from database", { error: err });
+		});
+		for (const [id, job] of this.jobs) if (job.enabled) this.scheduleNext(id);
+		if (!this.store) logger.warn("[cron] No cron store attached — runs are uncoordinated; with multiple app instances every instance will execute every job");
+		this.warnIfScaleToZero();
+		this.catchUpMissedSlots();
+		logger.info(`⏰ Cron scheduler started with ${this.jobs.size} job(s)`);
+	}
+	/**
+	* Stop the scheduler and clear all timers.
+	*
+	* Currently-executing handlers run to completion (they are async),
+	* but no further scheduling occurs after stop.
+	*/
+	stop() {
+		this.started = false;
+		for (const [id] of this.jobs) this.stopJob(id);
+	}
+	/**
+	* List all registered jobs with their current status.
+	*/
+	listJobs() {
+		return [...this.jobs.values()].map((job) => this.toStatus(job));
+	}
+	/**
+	* Get a single job status by ID.
+	*/
+	getJob(id) {
+		const job = this.jobs.get(id);
+		return job ? this.toStatus(job) : void 0;
+	}
+	/**
+	* Get log entries for a job.
+	*/
+	getJobLogs(id, limit) {
+		const job = this.jobs.get(id);
+		if (!job) return [];
+		const logs = [...job.logs].reverse();
+		return limit ? logs.slice(0, limit) : logs;
+	}
+	/**
+	* Get log entries for a job from the database (if store is available).
+	* Falls back to in-memory logs if no store is configured.
+	*/
+	async getJobLogsFromDb(id, limit) {
+		if (this.store) {
+			const dbLogs = await this.store.fetchLogs(id, limit);
+			if (dbLogs.length > 0) return dbLogs;
+		}
+		return this.getJobLogs(id, limit);
+	}
+	/**
+	* Enable or disable a job at runtime.
+	*/
+	setJobEnabled(id, enabled) {
+		const job = this.jobs.get(id);
+		if (!job) return void 0;
+		job.enabled = enabled;
+		if (enabled && this.started) {
+			job.state = "idle";
+			this.scheduleNext(id);
+		} else if (!enabled) {
+			this.stopJob(id);
+			job.state = "disabled";
+		}
+		return this.toStatus(job);
+	}
+	/**
+	* Manually trigger a job execution immediately.
+	*
+	* Returns `undefined` if the job doesn't exist.
+	* If the job is currently executing, returns the log entry with
+	* a `skipped: true` result rather than running concurrently.
+	*/
+	async triggerJob(id) {
+		const job = this.jobs.get(id);
+		if (!job) return void 0;
+		if (job.executing) {
+			logger.warn(`[cron] Skipping manual trigger of "${id}" — already executing`);
+			const logEntry = {
+				jobId: id,
+				startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				durationMs: 0,
+				success: true,
+				result: {
+					skipped: true,
+					reason: "already_executing"
+				},
+				logs: ["Skipped: job is already running"],
+				manual: true
+			};
+			job.logs.push(logEntry);
+			if (job.logs.length > MAX_LOGS_PER_JOB) job.logs.shift();
+			return logEntry;
+		}
+		return this.executeJob(job, true);
+	}
+	/**
+	* Warn once at start when the process looks like it is running on a
+	* platform that freezes or evicts instances between requests, where the
+	* in-process timers this scheduler relies on never fire.
+	*
+	* Advisory only: any failure here is swallowed so a detection bug can
+	* never take a production boot down.
+	*/
+	warnIfScaleToZero() {
+		try {
+			const warning = buildScaleToZeroWarning([...this.jobs.values()].map((job) => ({
+				id: job.id,
+				enabled: job.enabled
+			})));
+			if (warning) logger.warn(warning.message, warning.data);
+		} catch {}
+	}
+	/**
+	* Schedule the next execution for a job.
+	*
+	* Safety guarantees:
+	* 1. Clears any existing timer first (prevents leaked/duplicate timers)
+	* 2. Enforces a minimum delay to prevent tight loops from jitter
+	* 3. Unref's the timer so it doesn't prevent process exit
+	* 4. Re-checks enabled & started state before executing
+	* 5. Concurrency guard prevents overlapping handler executions
+	*/
+	scheduleNext(id) {
+		const job = this.jobs.get(id);
+		if (!job || !job.enabled || !this.started) return;
+		this.stopJob(id);
+		try {
+			const now = /* @__PURE__ */ new Date();
+			const nextRun = parseCronExpression(job.definition.schedule, now);
+			job.nextRunAt = nextRun;
+			const rawDelay = nextRun.getTime() - now.getTime();
+			const timer = setTimeout(async () => {
+				if (!job.enabled || !this.started) return;
+				if (job.executing) {
+					logger.warn(`[cron] Skipping scheduled run of "${id}" — still executing from previous run`);
+					this.scheduleNext(id);
+					return;
+				}
+				if (this.store?.tryClaimRun) {
+					let claimed = true;
+					try {
+						claimed = await this.store.tryClaimRun(id, nextRun.toISOString());
+					} catch (err) {
+						logger.warn(`[cron] Claim check threw for "${id}" — running uncoordinated`, { error: err });
+					}
+					if (!claimed) {
+						logger.info(`[cron] Slot ${nextRun.toISOString()} for "${id}" claimed by another instance — skipping`);
+						if (this.started && job.enabled) this.scheduleNext(id);
+						return;
+					}
+				}
+				await this.executeJob(job, false);
+				if (this.started && job.enabled) this.scheduleNext(id);
+			}, Math.max(rawDelay, MIN_SCHEDULE_INTERVAL_MS));
+			if (timer && typeof timer === "object" && "unref" in timer) timer.unref();
+			job.timerId = timer;
+		} catch (err) {
+			logger.error(`[cron] Failed to schedule "${id}"`, { error: err });
+			job.state = "error";
+			job.lastError = err instanceof Error ? err.message : String(err);
+		}
+	}
+	/**
+	* Run any slot that elapsed while no instance was holding a timer for it.
+	*
+	* Only jobs that opted in via `catchUpWindowSeconds` are considered, and
+	* only their single most recent missed slot — see the field's docs for why
+	* both limits are deliberate.
+	*
+	* The claim is what makes this safe. In the ordinary case — an instance
+	* restarting minutes after a slot ran normally — the most recent slot is
+	* already claimed, so this costs one `tryClaimRun` per job per boot and
+	* does nothing. A slot is only executed when no instance, past or present,
+	* ever claimed it.
+	*
+	* Never throws: a failure here must not take down a scheduler that is
+	* otherwise ticking correctly.
+	*/
+	async catchUpMissedSlots() {
+		const candidates = [...this.jobs.values()].filter((job) => job.enabled && (job.definition.catchUpWindowSeconds ?? 0) > 0);
+		if (candidates.length === 0) return;
+		if (!this.store?.tryClaimRun) {
+			logger.warn(`[cron] Catch-up is configured on ${candidates.length} job(s) but no claims-capable store is attached — skipping. Without claims a restart cannot tell an unrun slot from one the previous instance already ran.`);
+			return;
+		}
+		const now = /* @__PURE__ */ new Date();
+		for (const job of candidates) try {
+			if (!this.started || !job.enabled || job.executing) continue;
+			const windowSeconds = job.definition.catchUpWindowSeconds;
+			const from = /* @__PURE__ */ new Date(now.getTime() - windowSeconds * 1e3);
+			const slot = findMostRecentSlot(job.definition.schedule, from, now);
+			if (!slot) continue;
+			const slotIso = slot.toISOString();
+			let claimed;
+			try {
+				claimed = await this.store.tryClaimRun(job.id, slotIso);
+			} catch (err) {
+				logger.warn(`[cron] Catch-up claim threw for "${job.id}" — skipping catch-up`, { error: err });
+				continue;
+			}
+			if (!claimed) continue;
+			const lateBy = Math.round((now.getTime() - slot.getTime()) / 1e3);
+			logger.info(`[cron] Catching up missed slot ${slotIso} for "${job.id}" (${lateBy}s late)`);
+			await this.executeJob(job, false, `⏰ Catch-up run for missed slot ${slotIso} (${lateBy}s late)`);
+		} catch (err) {
+			logger.error(`[cron] Catch-up failed for "${job.id}"`, { error: err });
+		}
+	}
+	/**
+	* Stop a single job's timer and clear its next run state.
+	*/
+	stopJob(id) {
+		const job = this.jobs.get(id);
+		if (job?.timerId) {
+			clearTimeout(job.timerId);
+			job.timerId = void 0;
+			job.nextRunAt = void 0;
+		}
+	}
+	/**
+	* Execute a job's handler with full isolation and safety.
+	*
+	* - Sets a concurrency flag to prevent overlapping runs
+	* - Wraps handler in a timeout race
+	* - Captures all logs, errors, and results
+	* - Persists to store (non-blocking) if available
+	* - Always restores state even on catastrophic errors
+	*/
+	async executeJob(job, manual, seedLog) {
+		const startedAt = /* @__PURE__ */ new Date();
+		const capturedLogs = seedLog ? [seedLog] : [];
+		job.executing = true;
+		const ctx = {
+			jobId: job.id,
+			scheduledAt: startedAt,
+			log: (...args) => {
+				const line = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+				capturedLogs.push(line);
+			},
+			client: this.client
+		};
+		job.state = "running";
+		job.lastRunAt = startedAt;
+		job.totalRuns++;
+		let success = true;
+		let error;
+		let result;
+		try {
+			const timeout = (job.definition.timeoutSeconds ?? 300) * 1e3;
+			const handlerPromise = Promise.resolve(job.definition.handler(ctx));
+			let timeoutHandle;
+			const timeoutPromise = new Promise((_, reject) => {
+				timeoutHandle = setTimeout(() => reject(/* @__PURE__ */ new Error(`Cron job "${job.id}" timed out after ${timeout}ms`)), timeout);
+			});
+			try {
+				result = await Promise.race([handlerPromise, timeoutPromise]);
+			} finally {
+				clearTimeout(timeoutHandle);
+			}
+		} catch (err) {
+			success = false;
+			error = err instanceof Error ? err.message : String(err);
+			job.totalFailures++;
+		} finally {
+			job.executing = false;
+		}
+		const finishedAt = /* @__PURE__ */ new Date();
+		const durationMs = finishedAt.getTime() - startedAt.getTime();
+		job.state = success ? job.enabled ? "idle" : "disabled" : "error";
+		job.lastDurationMs = durationMs;
+		job.lastError = error;
+		const logEntry = {
+			jobId: job.id,
+			startedAt: startedAt.toISOString(),
+			finishedAt: finishedAt.toISOString(),
+			durationMs,
+			success,
+			error,
+			result: result !== void 0 ? result : void 0,
+			logs: capturedLogs,
+			manual
+		};
+		job.logs.push(logEntry);
+		if (job.logs.length > MAX_LOGS_PER_JOB) job.logs.shift();
+		if (this.store) this.store.insertLog(logEntry).catch((persistErr) => {
+			logger.error(`[cron] Failed to persist log for "${job.id}"`, { error: persistErr });
+		});
+		if (success) logger.info(`✅ [cron] "${job.id}" completed in ${durationMs}ms`);
+		else logger.error(`❌ [cron] "${job.id}" failed in ${durationMs}ms: ${error}`);
+		return logEntry;
+	}
+	toStatus(job) {
+		return {
+			id: job.id,
+			name: job.definition.name,
+			description: job.definition.description,
+			schedule: job.definition.schedule,
+			enabled: job.enabled,
+			state: job.state,
+			lastRunAt: job.lastRunAt?.toISOString(),
+			nextRunAt: job.nextRunAt?.toISOString(),
+			lastDurationMs: job.lastDurationMs,
+			lastError: job.lastError,
+			totalRuns: job.totalRuns,
+			totalFailures: job.totalFailures
+		};
+	}
+};
+//#endregion
+export { cron_scheduler_exports as n, validateCronExpression as r, CronScheduler as t };
+
+//# sourceMappingURL=cron-scheduler-B3RFt0HS.js.map