@keystrokehq/scheduler 0.1.4 → 0.2.0

package/dist/index.cjs

@@ -1,66 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_contract = require("./contract-C5JvbyQ-.cjs");
 let _keystrokehq_database = require("@keystrokehq/database");
-let _keystrokehq_trigger = require("@keystrokehq/trigger");
 let node_events = require("node:events");
+let _keystrokehq_trigger = require("@keystrokehq/trigger");
 let pg_boss = require("pg-boss");
 let node_crypto = require("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 (0, _keystrokehq_database.claimDueTriggerSchedulesForOrg)(asOf, resolveNextRunAt, limit);
-	return (0, _keystrokehq_database.claimDueTriggerSchedules)(asOf, resolveNextRunAt, limit).then((rows) => rows.map((row) => ({
-		...row,
-		projectId: (0, _keystrokehq_database.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) => (0, _keystrokehq_trigger.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) => (0, _keystrokehq_trigger.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() {
@@ -113,7 +57,7 @@ function createDatabaseJobQueue() {
 				while (running) try {
 					const job = await (0, _keystrokehq_database.claimNextJob)(workerId);
 					if (!job) {
-						await sleep(pollIntervalMs);
+						await sleep$1(pollIntervalMs);
 						continue;
 					}
 					try {
@@ -127,7 +71,7 @@ function createDatabaseJobQueue() {
 						}
 					}
 				} catch {
-					await sleep(pollIntervalMs);
+					await sleep$1(pollIntervalMs);
 				}
 			};
 			loop();
@@ -140,10 +84,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 (0, _keystrokehq_database.claimDueTriggersForOrg)(asOf, resolveNextRunAt, limit);
+	return (0, _keystrokehq_database.claimDueTriggers)(asOf, resolveNextRunAt, limit).then((rows) => rows.map((row) => ({
+		...row,
+		projectId: (0, _keystrokehq_database.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) => (0, _keystrokehq_trigger.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) => (0, _keystrokehq_trigger.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 (0, _keystrokehq_trigger.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 (0, _keystrokehq_database.selectActiveEphemeralScheduledTriggerSlugs)();
+	const slugs = [...projectSlugs, ...ephemeralSlugs];
+	if (slugs.length === 0) {
+		await (0, _keystrokehq_database.disableAllTriggerSchedules)(now);
+		return;
+	}
+	await (0, _keystrokehq_database.disableTriggerSchedulesNotInSlugs)(slugs, now);
+	for (const spec of options.schedules) {
+		const schedule = resolveTriggerSchedule(spec.triggerSlug, spec.schedule, options.scheduleOverrides);
+		const existing = await (0, _keystrokehq_database.selectTriggerBySlug)(spec.triggerSlug);
+		if (!existing) continue;
+		const nextRunAt = !(existing.schedule !== schedule) && existing.enabled === 1 ? existing.nextRunAt : (0, _keystrokehq_trigger.nextTriggerRunAt)(schedule, now);
+		const enabled = (await (0, _keystrokehq_database.listExecutableAttachmentsByTriggerIds)([existing.id])).length > 0;
+		await (0, _keystrokehq_database.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 (0, _keystrokehq_database.setTriggerScheduleEnabled)(triggerSlug, false, /* @__PURE__ */ new Date());
+		},
+		async upsert(_spec) {}
+	};
+}
+//#endregion
 //#region src/pg-boss-client.ts
 let boss;
 function resolveDatabaseUrl(url) {
@@ -206,6 +275,8 @@ function buildPgBossJobQueue(boss, options) {
 	const queueName = options.queueName ?? "keystroke";
 	const cancelChannel = (0, _keystrokehq_database.createPostgresCancelChannel)(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,
@@ -288,10 +359,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 ?? (0, _keystrokehq_database.getProjectScopeId)()).replaceAll(":", "-")}-${spec.triggerSlug.replaceAll(":", "-")}`;
+}
+/** Key prefix scoping reconcile cleanup to the active project (org queues are shared). */
+function pgBossTriggerScheduleKeyPrefix(projectId) {
+	return `trigger-${(projectId ?? (0, _keystrokehq_database.getProjectScopeId)()).replaceAll(":", "-")}-`;
+}
+function triggerJobData(spec) {
+	return {
+		kind: "trigger",
+		targetId: spec.triggerSlug,
+		runId: "",
+		trigger: spec.kind,
+		payload: {},
+		projectId: spec.projectId ?? (0, _keystrokehq_database.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 (0, _keystrokehq_database.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 ?? (0, _keystrokehq_database.resolveProjectDatabaseUrlFromEnv)(process.env) ?? _keystrokehq_database.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 require_contract.defineSchedulerPlugin({
@@ -318,7 +511,8 @@ function pgBossSchedulerPlugin() {
 				queueName: pgBossProjectQueueName(projectId),
 				projectId
 			});
-		}
+		},
+		createTriggerScheduler: createPgBossTriggerSchedulerForPlugin
 	});
 }
 /** DB-table queue (Drizzle `jobs`), for SQLite / self-host. */
@@ -327,7 +521,8 @@ function pollingSchedulerPlugin() {
 		name: "polling",
 		async createJobQueue() {
 			return createDatabaseJobQueue();
-		}
+		},
+		createTriggerScheduler: createPollingTriggerScheduler
 	});
 }
 /** Auto-selects pg-boss (postgres) or polling (sqlite) by dialect. */
@@ -337,45 +532,14 @@ function defaultSchedulerPlugin() {
 		async createJobQueue(ctx) {
 			if ((0, _keystrokehq_database.inferDialect)(resolveUrl(ctx), ctx.dialect) === "postgres") return pgBossSchedulerPlugin().createJobQueue(ctx);
 			return pollingSchedulerPlugin().createJobQueue(ctx);
+		},
+		async createTriggerScheduler(ctx, queue) {
+			if ((0, _keystrokehq_database.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 (0, _keystrokehq_trigger.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 (0, _keystrokehq_database.selectActiveEphemeralScheduledAttachmentSlugs)();
-	const slugs = [...projectSlugs, ...ephemeralSlugs];
-	if (slugs.length === 0) {
-		await (0, _keystrokehq_database.disableAllTriggerSchedules)(now);
-		return;
-	}
-	await (0, _keystrokehq_database.disableTriggerSchedulesNotInSlugs)(slugs, now);
-	for (const spec of options.schedules) {
-		const schedule = resolveTriggerSchedule(spec.attachmentKey, spec.schedule, options.scheduleOverrides);
-		const existing = await (0, _keystrokehq_database.selectTriggerScheduleBySlug)(spec.attachmentKey);
-		const scheduleChanged = existing?.schedule !== schedule;
-		const nextRunAt = existing && !scheduleChanged && existing.enabled === 1 ? existing.nextRunAt : (0, _keystrokehq_trigger.nextTriggerRunAt)(schedule, now);
-		await (0, _keystrokehq_database.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;
@@ -387,29 +551,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
@@ -468,7 +653,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;
@@ -492,7 +677,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;
@@ -504,8 +689,10 @@ exports.DEFAULT_QUEUE_NAME = DEFAULT_QUEUE_NAME;
 exports.DEFAULT_RETRY_DELAY_MS = require_contract.DEFAULT_RETRY_DELAY_MS;
 exports.buildPgBossJobQueue = buildPgBossJobQueue;
 exports.configureSharedScheduler = configureSharedScheduler;
+exports.createDatabaseTriggerScheduler = createDatabaseTriggerScheduler;
 exports.createJobQueue = createJobQueue;
 exports.createMemoryJobQueue = createMemoryJobQueue;
+exports.createPgBossTriggerScheduler = createPgBossTriggerScheduler;
 exports.createScheduler = createScheduler;
 exports.createSharedPgBossJobQueue = createSharedPgBossJobQueue;
 exports.createSharedPgBossScheduler = createSharedPgBossScheduler;
@@ -516,12 +703,16 @@ exports.getPgBoss = getPgBoss;
 exports.getSharedPgBossJobQueue = getSharedPgBossJobQueue;
 exports.pgBossProjectQueueName = pgBossProjectQueueName;
 exports.pgBossSchedulerPlugin = pgBossSchedulerPlugin;
+exports.pgBossTriggerScheduleKey = pgBossTriggerScheduleKey;
+exports.pgBossTriggerScheduleKeyPrefix = pgBossTriggerScheduleKeyPrefix;
 exports.pollingSchedulerPlugin = pollingSchedulerPlugin;
 exports.resetSharedPgBossJobQueueForTests = resetSharedPgBossJobQueueForTests;
 exports.resetSharedSchedulerForTests = resetSharedSchedulerForTests;
+exports.resolveTriggerSchedule = resolveTriggerSchedule;
 exports.retryDelayMs = require_contract.retryDelayMs;
 exports.startPgBoss = startPgBoss;
 exports.stopPgBoss = stopPgBoss;
+exports.syncTriggerSchedules = syncTriggerSchedules;
 exports.wrapJobQueueAsScheduler = wrapJobQueueAsScheduler;
 
 //# sourceMappingURL=index.cjs.map