@keystrokehq/scheduler 0.1.4 → 0.2.0

package/dist/index.mjs

@@ -1,65 +1,9 @@
 import { n as DEFAULT_RETRY_DELAY_MS, r as retryDelayMs, t as defineSchedulerPlugin } from "./contract-E1QJBH6_.mjs";
-import { DEFAULT_DATABASE_URL, claimDueTriggerSchedules, claimDueTriggerSchedulesForOrg, claimNextJob, createPostgresCancelChannel as createPgCancelChannel, disableAllTriggerSchedules, disableTriggerSchedulesNotInSlugs, enqueueJob, failWorkflowRun, getProjectScopeId, inferDialect, markJobComplete, markJobFailed, requeueExpiredLeases, resolvePostgresUrlFromEnv, resolveProjectDatabaseUrlFromEnv, scheduleJobRetry, selectActiveEphemeralScheduledAttachmentSlugs, selectTriggerScheduleBySlug, upsertTriggerSchedule } from "@keystrokehq/database";
-import { nextTriggerRunAt, resolveCronSchedule } from "@keystrokehq/trigger";
+import { DEFAULT_DATABASE_URL, claimDueTriggers, claimDueTriggersForOrg, claimNextJob, createPostgresCancelChannel as createPgCancelChannel, disableAllTriggerSchedules, disableTriggerSchedulesNotInSlugs, enqueueJob, failWorkflowRun, getProjectScopeId, inferDialect, listEnabledScheduledTriggers, listExecutableAttachmentsByTriggerIds, markJobComplete, markJobFailed, requeueExpiredLeases, resolvePostgresUrlFromEnv, resolveProjectDatabaseUrlFromEnv, scheduleJobRetry, selectActiveEphemeralScheduledTriggerSlugs, selectTriggerBySlug, setTriggerScheduleEnabled, upsertTriggerScheduleFields } from "@keystrokehq/database";
 import { EventEmitter } from "node:events";
+import { nextTriggerRunAt, resolveCronSchedule } from "@keystrokehq/trigger";
 import { PgBoss } from "pg-boss";
 import { createHash } from "node:crypto";
-//#region src/schedule-ticker.ts
-function enqueueTriggerJob(jobQueue, row, scheduledAt) {
-	const input = {
-		kind: "trigger",
-		targetId: row.attachmentSlug,
-		runId: crypto.randomUUID(),
-		trigger: row.kind,
-		payload: {},
-		projectId: row.projectId
-	};
-	if (scheduledAt) input.scheduledAt = scheduledAt;
-	return jobQueue.enqueue(input);
-}
-async function claimDue(scope, asOf, resolveNextRunAt, limit) {
-	if (scope === "organization") return claimDueTriggerSchedulesForOrg(asOf, resolveNextRunAt, limit);
-	return claimDueTriggerSchedules(asOf, resolveNextRunAt, limit).then((rows) => rows.map((row) => ({
-		...row,
-		projectId: getProjectScopeId()
-	})));
-}
-function createScheduleTicker(ctx) {
-	const pollIntervalMs = ctx.pollIntervalMs ?? 1e3;
-	const batchSize = ctx.batchSize ?? 10;
-	async function fireDueSchedules(asOf = /* @__PURE__ */ new Date()) {
-		const claimed = await claimDue(ctx.scope ?? "project", asOf, (schedule) => nextTriggerRunAt(schedule, asOf), batchSize);
-		for (const row of claimed) await enqueueTriggerJob(ctx.jobQueue, row, asOf);
-		return claimed.length;
-	}
-	async function startScheduleTicker(options = {}) {
-		const intervalMs = options.pollIntervalMs ?? pollIntervalMs;
-		const limit = options.batchSize ?? batchSize;
-		const scope = options.scope ?? ctx.scope ?? "project";
-		let running = true;
-		const loop = async () => {
-			while (running) {
-				try {
-					const claimed = await claimDue(scope, /* @__PURE__ */ new Date(), (schedule) => nextTriggerRunAt(schedule, /* @__PURE__ */ new Date()), limit);
-					for (const row of claimed) await enqueueTriggerJob(ctx.jobQueue, row);
-				} catch {}
-				await sleep$1(intervalMs);
-			}
-		};
-		loop();
-		return async () => {
-			running = false;
-		};
-	}
-	return {
-		fireDueSchedules,
-		startScheduleTicker
-	};
-}
-function sleep$1(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-//#endregion
 //#region src/cancel-channel.ts
 /** In-process cancel pub/sub for single-process queues (memory, db polling). */
 function createInProcessCancelChannel() {
@@ -112,7 +56,7 @@ function createDatabaseJobQueue() {
 				while (running) try {
 					const job = await claimNextJob(workerId);
 					if (!job) {
-						await sleep(pollIntervalMs);
+						await sleep$1(pollIntervalMs);
 						continue;
 					}
 					try {
@@ -126,7 +70,7 @@ function createDatabaseJobQueue() {
 						}
 					}
 				} catch {
-					await sleep(pollIntervalMs);
+					await sleep$1(pollIntervalMs);
 				}
 			};
 			loop();
@@ -139,10 +83,135 @@ function createDatabaseJobQueue() {
 		subscribeCancel: (handler) => cancelChannel.subscribeCancel(handler)
 	};
 }
+function sleep$1(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//#endregion
+//#region src/schedule-ticker.ts
+function enqueueTriggerJob(jobQueue, row, scheduledAt) {
+	const input = {
+		kind: "trigger",
+		targetId: row.slug,
+		runId: crypto.randomUUID(),
+		trigger: row.kind,
+		payload: {},
+		projectId: row.projectId
+	};
+	if (scheduledAt) input.scheduledAt = scheduledAt;
+	return jobQueue.enqueue(input);
+}
+async function claimDue(scope, asOf, resolveNextRunAt, limit) {
+	if (scope === "organization") return claimDueTriggersForOrg(asOf, resolveNextRunAt, limit);
+	return claimDueTriggers(asOf, resolveNextRunAt, limit).then((rows) => rows.map((row) => ({
+		...row,
+		projectId: getProjectScopeId()
+	})));
+}
+function createScheduleTicker(ctx) {
+	const pollIntervalMs = ctx.pollIntervalMs ?? 1e3;
+	const batchSize = ctx.batchSize ?? 10;
+	async function fireDueSchedules(asOf = /* @__PURE__ */ new Date()) {
+		const claimed = await claimDue(ctx.scope ?? "project", asOf, (schedule) => nextTriggerRunAt(schedule, asOf), batchSize);
+		for (const row of claimed) {
+			if (row.kind !== "cron" && row.kind !== "poll") continue;
+			await enqueueTriggerJob(ctx.jobQueue, {
+				slug: row.slug,
+				kind: row.kind,
+				projectId: row.projectId
+			}, asOf);
+		}
+		return claimed.length;
+	}
+	async function startScheduleTicker(options = {}) {
+		const intervalMs = options.pollIntervalMs ?? pollIntervalMs;
+		const limit = options.batchSize ?? batchSize;
+		const scope = options.scope ?? ctx.scope ?? "project";
+		let running = true;
+		const loop = async () => {
+			while (running) {
+				try {
+					const claimed = await claimDue(scope, /* @__PURE__ */ new Date(), (schedule) => nextTriggerRunAt(schedule, /* @__PURE__ */ new Date()), limit);
+					for (const row of claimed) {
+						if (row.kind !== "cron" && row.kind !== "poll") continue;
+						await enqueueTriggerJob(ctx.jobQueue, {
+							slug: row.slug,
+							kind: row.kind,
+							projectId: row.projectId
+						});
+					}
+				} catch {}
+				await sleep(intervalMs);
+			}
+		};
+		loop();
+		return async () => {
+			running = false;
+		};
+	}
+	return {
+		fireDueSchedules,
+		startScheduleTicker
+	};
+}
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 //#endregion
+//#region src/resolve-schedule.ts
+function resolveTriggerSchedule(triggerSlug, schedule, overrides) {
+	return resolveCronSchedule(triggerSlug, schedule, {
+		cronScheduleOverride: overrides?.global,
+		attachmentScheduleOverrides: overrides?.byTrigger
+	});
+}
+//#endregion
+//#region src/sync-trigger-schedules.ts
+async function syncTriggerSchedules(options) {
+	const now = /* @__PURE__ */ new Date();
+	const projectSlugs = options.schedules.map((schedule) => schedule.triggerSlug);
+	const ephemeralSlugs = await selectActiveEphemeralScheduledTriggerSlugs();
+	const slugs = [...projectSlugs, ...ephemeralSlugs];
+	if (slugs.length === 0) {
+		await disableAllTriggerSchedules(now);
+		return;
+	}
+	await disableTriggerSchedulesNotInSlugs(slugs, now);
+	for (const spec of options.schedules) {
+		const schedule = resolveTriggerSchedule(spec.triggerSlug, spec.schedule, options.scheduleOverrides);
+		const existing = await selectTriggerBySlug(spec.triggerSlug);
+		if (!existing) continue;
+		const nextRunAt = !(existing.schedule !== schedule) && existing.enabled === 1 ? existing.nextRunAt : nextTriggerRunAt(schedule, now);
+		const enabled = (await listExecutableAttachmentsByTriggerIds([existing.id])).length > 0;
+		await upsertTriggerScheduleFields({
+			triggerSlug: spec.triggerSlug,
+			schedule,
+			nextRunAt: nextRunAt ?? now,
+			enabled,
+			updatedAt: now
+		});
+	}
+}
+//#endregion
+//#region src/database-trigger-scheduler.ts
+/** Postgres poll loop — default trigger scheduler for pg-boss, polling, and memory paths. */
+function createDatabaseTriggerScheduler(options) {
+	const ticker = createScheduleTicker({
+		jobQueue: options.jobQueue,
+		scope: options.scope,
+		pollIntervalMs: options.pollIntervalMs,
+		batchSize: options.batchSize
+	});
+	return {
+		sync: (syncOptions) => syncTriggerSchedules(syncOptions),
+		start: (startOptions) => ticker.startScheduleTicker(startOptions),
+		fireDue: (asOf) => ticker.fireDueSchedules(asOf),
+		async remove(triggerSlug) {
+			await setTriggerScheduleEnabled(triggerSlug, false, /* @__PURE__ */ new Date());
+		},
+		async upsert(_spec) {}
+	};
+}
+//#endregion
 //#region src/pg-boss-client.ts
 let boss;
 function resolveDatabaseUrl(url) {
@@ -205,6 +274,8 @@ function buildPgBossJobQueue(boss, options) {
 	const queueName = options.queueName ?? "keystroke";
 	const cancelChannel = createPgCancelChannel(options.connectionString, pgCancelChannelName(options.cancelScope ?? "platform", options.cancelScope === "organization" ? options.organizationId : options.projectId));
 	return {
+		boss,
+		queueName,
 		async enqueue(input) {
 			const jobId = await boss.send(queueName, {
 				...input,
@@ -287,10 +358,132 @@ async function createSharedPgBossJobQueue(boss, options) {
 	});
 }
 //#endregion
+//#region src/pg-boss-trigger-scheduler.ts
+/**
+* pg-boss schedule key for one trigger. Mirrors {@link bullmqTriggerSchedulerId}
+* so the firing backend is interchangeable: `trigger-<projectId>-<slug>`. pg-boss
+* keys allow hyphens, so colons (legal in ids) are swapped for `-`.
+*/
+function pgBossTriggerScheduleKey(spec) {
+	return `trigger-${(spec.projectId ?? getProjectScopeId()).replaceAll(":", "-")}-${spec.triggerSlug.replaceAll(":", "-")}`;
+}
+/** Key prefix scoping reconcile cleanup to the active project (org queues are shared). */
+function pgBossTriggerScheduleKeyPrefix(projectId) {
+	return `trigger-${(projectId ?? getProjectScopeId()).replaceAll(":", "-")}-`;
+}
+function triggerJobData(spec) {
+	return {
+		kind: "trigger",
+		targetId: spec.triggerSlug,
+		runId: "",
+		trigger: spec.kind,
+		payload: {},
+		projectId: spec.projectId ?? getProjectScopeId()
+	};
+}
+function rowToSpec(row) {
+	if (row.kind !== "cron" && row.kind !== "poll") return;
+	if (!row.schedule) return;
+	return {
+		triggerSlug: row.slug,
+		kind: row.kind,
+		schedule: row.schedule,
+		projectId: row.projectId
+	};
+}
+/**
+* Trigger scheduler backed by pg-boss native cron scheduling. Mirrors
+* {@link createBullmqTriggerScheduler}: `boss.schedule` registers a recurring job
+* onto the project/org queue (no per-second DB poll), and reconcile keeps the
+* `pgboss.schedule` table in sync with the `triggers` table (source of truth).
+*
+* Granularity: pg-boss cron is minute-level (it checks schedules every ~30s and
+* dedupes per minute), so sub-minute schedules effectively fire at most once per
+* minute — unlike the DB ticker's 1s loop.
+*/
+function createPgBossTriggerScheduler(_ctx, queue) {
+	async function upsertScheduler(spec, overrides) {
+		const schedule = resolveTriggerSchedule(spec.triggerSlug, spec.schedule, overrides);
+		const key = pgBossTriggerScheduleKey(spec);
+		await queue.boss.schedule(queue.queueName, schedule, triggerJobData({
+			...spec,
+			schedule
+		}), { key });
+	}
+	async function reconcileFromDatabase(overrides) {
+		const projectPrefix = pgBossTriggerScheduleKeyPrefix();
+		const rows = await listEnabledScheduledTriggers();
+		const expectedKeys = /* @__PURE__ */ new Set();
+		const failures = [];
+		for (const row of rows) {
+			const spec = rowToSpec(row);
+			if (!spec) continue;
+			expectedKeys.add(pgBossTriggerScheduleKey(spec));
+			try {
+				await upsertScheduler(spec, overrides);
+			} catch (error) {
+				failures.push({
+					triggerSlug: spec.triggerSlug,
+					error
+				});
+				console.error(`[pg-boss-trigger-scheduler] failed to schedule ${spec.triggerSlug}`, error);
+			}
+		}
+		const schedules = await queue.boss.getSchedules(queue.queueName);
+		for (const schedule of schedules) {
+			const key = schedule.key;
+			if (!key || !key.startsWith(projectPrefix)) continue;
+			if (!expectedKeys.has(key)) try {
+				await queue.boss.unschedule(queue.queueName, key);
+			} catch (error) {
+				failures.push({
+					triggerSlug: key,
+					error
+				});
+				console.error(`[pg-boss-trigger-scheduler] failed to unschedule stale ${key}`, error);
+			}
+		}
+		if (failures.length > 0) throw new Error(`pg-boss trigger scheduler reconcile failed for ${failures.length} trigger(s)`);
+	}
+	return {
+		async sync(syncOptions) {
+			await syncTriggerSchedules(syncOptions);
+			await reconcileFromDatabase(syncOptions.scheduleOverrides);
+		},
+		async start(_options) {
+			return async () => void 0;
+		},
+		fireDue: async () => 0,
+		upsert: upsertScheduler,
+		async remove(triggerSlug, projectId) {
+			await queue.boss.unschedule(queue.queueName, pgBossTriggerScheduleKey({
+				triggerSlug,
+				projectId
+			}));
+		}
+	};
+}
+//#endregion
 //#region src/plugin.ts
 function resolveUrl(ctx) {
 	return ctx.url ?? resolveProjectDatabaseUrlFromEnv(process.env) ?? DEFAULT_DATABASE_URL;
 }
+/** DB poll-loop trigger scheduler — used by the SQLite/self-host polling backend. */
+function createPollingTriggerScheduler(ctx, queue) {
+	const scope = ctx.scope === "organization" ? "organization" : "project";
+	return Promise.resolve(createDatabaseTriggerScheduler({
+		jobQueue: queue,
+		scope
+	}));
+}
+function isPgBossJobQueue(queue) {
+	return "boss" in queue && "queueName" in queue;
+}
+/** Native pg-boss cron scheduler; falls back to the DB ticker if the queue isn't pg-boss. */
+function createPgBossTriggerSchedulerForPlugin(ctx, queue) {
+	if (!isPgBossJobQueue(queue)) return createPollingTriggerScheduler(ctx, queue);
+	return Promise.resolve(createPgBossTriggerScheduler(ctx, queue));
+}
 /** Postgres pg-boss backend. Platform scope shares one queue; org scope gets one queue per org. */
 function pgBossSchedulerPlugin() {
 	return defineSchedulerPlugin({
@@ -317,7 +510,8 @@ function pgBossSchedulerPlugin() {
 				queueName: pgBossProjectQueueName(projectId),
 				projectId
 			});
-		}
+		},
+		createTriggerScheduler: createPgBossTriggerSchedulerForPlugin
 	});
 }
 /** DB-table queue (Drizzle `jobs`), for SQLite / self-host. */
@@ -326,7 +520,8 @@ function pollingSchedulerPlugin() {
 		name: "polling",
 		async createJobQueue() {
 			return createDatabaseJobQueue();
-		}
+		},
+		createTriggerScheduler: createPollingTriggerScheduler
 	});
 }
 /** Auto-selects pg-boss (postgres) or polling (sqlite) by dialect. */
@@ -336,45 +531,14 @@ function defaultSchedulerPlugin() {
 		async createJobQueue(ctx) {
 			if (inferDialect(resolveUrl(ctx), ctx.dialect) === "postgres") return pgBossSchedulerPlugin().createJobQueue(ctx);
 			return pollingSchedulerPlugin().createJobQueue(ctx);
+		},
+		async createTriggerScheduler(ctx, queue) {
+			if (inferDialect(resolveUrl(ctx), ctx.dialect) === "postgres") return pgBossSchedulerPlugin().createTriggerScheduler(ctx, queue);
+			return pollingSchedulerPlugin().createTriggerScheduler(ctx, queue);
 		}
 	});
 }
 //#endregion
-//#region src/resolve-schedule.ts
-function resolveTriggerSchedule(attachmentKey, schedule, overrides) {
-	return resolveCronSchedule(attachmentKey, schedule, {
-		cronScheduleOverride: overrides?.global,
-		attachmentScheduleOverrides: overrides?.byAttachment
-	});
-}
-//#endregion
-//#region src/sync-trigger-schedules.ts
-async function syncTriggerSchedules(options) {
-	const now = /* @__PURE__ */ new Date();
-	const projectSlugs = options.schedules.map((schedule) => schedule.attachmentKey);
-	const ephemeralSlugs = await selectActiveEphemeralScheduledAttachmentSlugs();
-	const slugs = [...projectSlugs, ...ephemeralSlugs];
-	if (slugs.length === 0) {
-		await disableAllTriggerSchedules(now);
-		return;
-	}
-	await disableTriggerSchedulesNotInSlugs(slugs, now);
-	for (const spec of options.schedules) {
-		const schedule = resolveTriggerSchedule(spec.attachmentKey, spec.schedule, options.scheduleOverrides);
-		const existing = await selectTriggerScheduleBySlug(spec.attachmentKey);
-		const scheduleChanged = existing?.schedule !== schedule;
-		const nextRunAt = existing && !scheduleChanged && existing.enabled === 1 ? existing.nextRunAt : nextTriggerRunAt(schedule, now);
-		await upsertTriggerSchedule({
-			attachmentSlug: spec.attachmentKey,
-			kind: spec.kind,
-			schedule,
-			nextRunAt,
-			enabled: true,
-			updatedAt: now
-		});
-	}
-}
-//#endregion
 //#region src/create-scheduler.ts
 async function createUnderlyingJobQueue(options = {}) {
 	if (options.adapter) return options.adapter;
@@ -386,29 +550,50 @@ async function createUnderlyingJobQueue(options = {}) {
 		organizationId: options.organizationId
 	});
 }
-function wrapScheduler(jobQueue, scope) {
-	const ticker = createScheduleTicker({
+function pluginContext(options = {}) {
+	return {
+		scope: options.scope ?? "project",
+		url: options.url,
+		dialect: options.dialect,
+		projectId: options.projectId,
+		organizationId: options.organizationId
+	};
+}
+async function createTriggerScheduler(options, jobQueue) {
+	const scope = options.scope === "organization" ? "organization" : "project";
+	const plugin = options.plugin ?? defaultSchedulerPlugin();
+	const ctx = pluginContext(options);
+	if (plugin.createTriggerScheduler) return plugin.createTriggerScheduler(ctx, jobQueue);
+	return createDatabaseTriggerScheduler({
 		jobQueue,
 		scope
 	});
+}
+function wrapScheduler(jobQueue, triggerScheduler) {
 	return {
 		enqueue: (input) => jobQueue.enqueue(input),
-		startWorker: (handler, options) => jobQueue.startWorker(handler, options),
+		startWorker: (handler, workerOptions) => jobQueue.startWorker(handler, workerOptions),
 		publishCancel: (runId) => jobQueue.publishCancel(runId),
 		subscribeCancel: (handler) => jobQueue.subscribeCancel(handler),
-		syncTriggerSchedules: (options) => syncTriggerSchedules(options),
-		startScheduleTicker: (options) => ticker.startScheduleTicker(options),
-		fireDueSchedules: (asOf) => ticker.fireDueSchedules(asOf)
+		syncTriggerSchedules: (options) => triggerScheduler.sync(options),
+		startScheduleTicker: (options) => triggerScheduler.start(options),
+		fireDueSchedules: (asOf) => triggerScheduler.fireDue?.(asOf) ?? Promise.resolve(0),
+		...triggerScheduler.upsert ? { upsertTriggerSchedule: (spec, overrides) => triggerScheduler.upsert(spec, overrides) } : {},
+		...triggerScheduler.remove ? { removeTriggerSchedule: (triggerSlug, projectId) => triggerScheduler.remove(triggerSlug, projectId) } : {}
 	};
 }
 async function createScheduler(options = {}) {
-	return wrapScheduler(await createUnderlyingJobQueue(options), options.scope === "organization" ? "organization" : "project");
+	const jobQueue = await createUnderlyingJobQueue(options);
+	return wrapScheduler(jobQueue, await createTriggerScheduler(options, jobQueue));
 }
 async function createJobQueue(options = {}) {
 	return createUnderlyingJobQueue(options);
 }
-function wrapJobQueueAsScheduler(jobQueue, scope) {
-	return wrapScheduler(jobQueue, scope);
+async function wrapJobQueueAsScheduler(jobQueue, scope) {
+	return wrapScheduler(jobQueue, createDatabaseTriggerScheduler({
+		jobQueue,
+		scope
+	}));
 }
 //#endregion
 //#region src/memory.ts
@@ -467,7 +652,7 @@ function createMemoryJobQueue(options = {}) {
 //#region src/shared-pgboss-queue.ts
 let sharedJobQueue$1;
 async function createSharedPgBossScheduler() {
-	return wrapJobQueueAsScheduler(await getSharedPgBossJobQueue());
+	return await wrapJobQueueAsScheduler(await getSharedPgBossJobQueue());
 }
 async function getSharedPgBossJobQueue() {
 	if (sharedJobQueue$1) return sharedJobQueue$1;
@@ -491,7 +676,7 @@ async function createSharedScheduler() {
 	const plugin = configuredPlugin ?? defaultSchedulerPlugin();
 	if (plugin.name === "default") return createSharedPgBossScheduler();
 	if (!sharedJobQueue) sharedJobQueue = await plugin.createJobQueue({ scope: "platform" });
-	return wrapJobQueueAsScheduler(sharedJobQueue);
+	return await wrapJobQueueAsScheduler(sharedJobQueue);
 }
 function resetSharedSchedulerForTests() {
 	configuredPlugin = void 0;
@@ -499,6 +684,6 @@ function resetSharedSchedulerForTests() {
 	resetSharedPgBossJobQueueForTests();
 }
 //#endregion
-export { DEFAULT_QUEUE_NAME, DEFAULT_RETRY_DELAY_MS, buildPgBossJobQueue, configureSharedScheduler, createJobQueue, createMemoryJobQueue, createScheduler, createSharedPgBossJobQueue, createSharedPgBossScheduler, createSharedScheduler, defaultSchedulerPlugin, defineSchedulerPlugin, getPgBoss, getSharedPgBossJobQueue, pgBossProjectQueueName, pgBossSchedulerPlugin, pollingSchedulerPlugin, resetSharedPgBossJobQueueForTests, resetSharedSchedulerForTests, retryDelayMs, startPgBoss, stopPgBoss, wrapJobQueueAsScheduler };
+export { DEFAULT_QUEUE_NAME, DEFAULT_RETRY_DELAY_MS, buildPgBossJobQueue, configureSharedScheduler, createDatabaseTriggerScheduler, createJobQueue, createMemoryJobQueue, createPgBossTriggerScheduler, createScheduler, createSharedPgBossJobQueue, createSharedPgBossScheduler, createSharedScheduler, defaultSchedulerPlugin, defineSchedulerPlugin, getPgBoss, getSharedPgBossJobQueue, pgBossProjectQueueName, pgBossSchedulerPlugin, pgBossTriggerScheduleKey, pgBossTriggerScheduleKeyPrefix, pollingSchedulerPlugin, resetSharedPgBossJobQueueForTests, resetSharedSchedulerForTests, resolveTriggerSchedule, retryDelayMs, startPgBoss, stopPgBoss, syncTriggerSchedules, wrapJobQueueAsScheduler };
 
 //# sourceMappingURL=index.mjs.map