@keystrokehq/scheduler 0.0.0-staging-20260714211819

package/dist/index.mjs

@@ -0,0 +1,739 @@
+import { n as DEFAULT_RETRY_DELAY_MS, r as retryDelayMs, t as defineSchedulerPlugin } from "./contract-E1QJBH6_.mjs";
+import { DEFAULT_DATABASE_URL, claimDueTriggers, claimDueTriggersForOrg, claimNextJob, createPostgresCancelChannel as createPgCancelChannel, disableAllTriggerSchedules, disableTriggerSchedulesNotInSlugs, enqueueJob, failAgentSession, failWorkflowRun, getProjectScopeId, inferDialect, listEnabledScheduledTriggers, listExecutableAttachmentsByTriggerIds, markJobComplete, markJobFailed, requeueExpiredLeases, resolvePostgresUrlFromEnv, resolveProjectDatabaseUrlFromEnv, scheduleJobRetry, selectActiveEphemeralScheduledTriggerSlugs, selectTriggerBySlug, setTriggerScheduleEnabled, triggerTimezoneFromConfig, 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/cancel-channel.ts
+/** In-process cancel pub/sub for single-process queues (memory, db polling). */
+function createInProcessCancelChannel() {
+	const emitter = new EventEmitter();
+	return {
+		async publishCancel(runId) {
+			emitter.emit("cancel", runId);
+		},
+		async subscribeCancel(handler) {
+			const listener = (runId) => {
+				handler(runId);
+			};
+			emitter.on("cancel", listener);
+			return async () => {
+				emitter.off("cancel", listener);
+			};
+		}
+	};
+}
+//#endregion
+//#region src/database-queue.ts
+function toJobPayload(job) {
+	return {
+		jobId: job.id,
+		kind: job.kind,
+		targetId: job.targetId,
+		runId: job.runId,
+		trigger: job.trigger,
+		payload: job.payload,
+		attempt: job.attempt,
+		maxAttempts: job.maxAttempts,
+		scheduledAt: job.scheduledAt,
+		...job.parent ? { parent: job.parent } : {}
+	};
+}
+function createDatabaseJobQueue() {
+	const cancelChannel = createInProcessCancelChannel();
+	let handler;
+	let running = false;
+	let lentSlots = 0;
+	let activeLoops = 0;
+	let workerIdBase = "";
+	let pollIntervalMs = 250;
+	let leaseSweepIntervalMs = 3e4;
+	let leaseTimer;
+	const desiredConcurrency = () => 1 + lentSlots;
+	const loop = async (workerId) => {
+		try {
+			while (running && handler) {
+				if (activeLoops > desiredConcurrency()) return;
+				try {
+					const job = await claimNextJob(workerId);
+					if (!job) {
+						await sleep$1(pollIntervalMs);
+						continue;
+					}
+					try {
+						await handler(toJobPayload(job));
+						await markJobComplete(job.id);
+					} catch (error) {
+						if (job.attempt < job.maxAttempts) await scheduleJobRetry(job.id, job.attempt + 1, retryDelayMs(job.attempt));
+						else {
+							await markJobFailed(job.id, error);
+							if (job.kind === "workflow") await failWorkflowRun(job.runId, error);
+							if (job.kind === "agent") {
+								const sessionId = job.payload?.sessionId;
+								if (sessionId) await failAgentSession(sessionId, error);
+							}
+						}
+					}
+				} catch {
+					await sleep$1(pollIntervalMs);
+				}
+			}
+		} finally {
+			activeLoops -= 1;
+			ensureWorkers();
+		}
+	};
+	const ensureWorkers = () => {
+		while (running && handler && activeLoops < desiredConcurrency()) {
+			activeLoops += 1;
+			loop(`${workerIdBase}:${activeLoops}`);
+		}
+	};
+	return {
+		async enqueue(input) {
+			return enqueueJob(input);
+		},
+		async startWorker(nextHandler, options = {}) {
+			handler = nextHandler;
+			running = true;
+			workerIdBase = options.workerId ?? crypto.randomUUID();
+			pollIntervalMs = options.pollIntervalMs ?? 250;
+			leaseSweepIntervalMs = options.leaseSweepIntervalMs ?? 3e4;
+			leaseTimer = setInterval(() => {
+				requeueExpiredLeases();
+			}, leaseSweepIntervalMs);
+			ensureWorkers();
+			return async () => {
+				running = false;
+				clearInterval(leaseTimer);
+				leaseTimer = void 0;
+			};
+		},
+		async withLentSlot(fn) {
+			lentSlots += 1;
+			ensureWorkers();
+			try {
+				return await fn();
+			} finally {
+				lentSlots -= 1;
+			}
+		},
+		publishCancel: (runId) => cancelChannel.publishCancel(runId),
+		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, timezone) => nextTriggerRunAt(schedule, asOf, timezone), 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
+			});
+		}
+		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, timezone) => nextTriggerRunAt(schedule, /* @__PURE__ */ new Date(), timezone), 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 existingTimezone = triggerTimezoneFromConfig(existing.config);
+		const nextRunAt = !(existing.schedule !== schedule || existingTimezone !== spec.timezone) && existing.enabled === 1 ? existing.nextRunAt : nextTriggerRunAt(schedule, now, spec.timezone);
+		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) {
+	const resolved = url ?? resolvePostgresUrlFromEnv(process.env);
+	if (!resolved) throw new Error("DATABASE_URL or POSTGRES_HOST/POSTGRES_USER/POSTGRES_PASSWORD/POSTGRES_DB is required");
+	return resolved;
+}
+async function startPgBoss(url) {
+	if (boss) return boss;
+	const next = new PgBoss({
+		connectionString: resolveDatabaseUrl(url),
+		schema: "pgboss"
+	});
+	next.on("error", (error) => {
+		console.error("[pg-boss]", error);
+	});
+	await next.start();
+	boss = next;
+	return next;
+}
+function getPgBoss() {
+	if (!boss) throw new Error("PgBoss not started. Call startPgBoss() first.");
+	return boss;
+}
+async function stopPgBoss() {
+	if (!boss) return;
+	await boss.stop();
+	boss = void 0;
+}
+//#endregion
+//#region src/pg-cancel-channel.ts
+/** Postgres NOTIFY channel — lowercase identifier (project ids are UUIDs, well under 63 chars). */
+function pgCancelChannelName(scope, id) {
+	if (scope === "platform") return "keystroke_cancel_platform";
+	if (scope === "organization") return `keystroke_cancel_org_${(id ?? "default").replace(/[^a-z0-9_]/gi, "_").toLowerCase()}`;
+	return `keystroke_cancel_${(id ?? "default").replace(/[^a-z0-9_]/gi, "_").toLowerCase()}`;
+}
+//#endregion
+//#region src/pg-boss-queue.ts
+/** Shared queue name for the platform control-plane scope. */
+const DEFAULT_QUEUE_NAME = "keystroke";
+const PGBOSS_SCHEMA = "pgboss";
+/**
+* Derive a per-project pg-boss queue name. pg-boss queue names must be <= 50
+* chars, contain only [A-Za-z0-9_], and not start with a digit. Project ids are
+* usually UUIDs (hyphens, may start with a digit), so we sanitize, and fall back
+* to a hash when the sanitized name would exceed the length limit.
+*/
+function pgBossProjectQueueName(projectId) {
+	const name = `${DEFAULT_QUEUE_NAME}_${projectId.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+	if (name.length <= 50) return name;
+	return `${DEFAULT_QUEUE_NAME}_${createHash("sha1").update(projectId).digest("hex").slice(0, 40)}`;
+}
+function pgBossOrgQueueName(organizationId) {
+	const name = `${DEFAULT_QUEUE_NAME}_org_${organizationId.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+	if (name.length <= 50) return name;
+	return `${DEFAULT_QUEUE_NAME}_org_${createHash("sha1").update(organizationId).digest("hex").slice(0, 36)}`;
+}
+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,
+				payload: input.payload
+			}, {
+				retryLimit: (input.maxAttempts ?? 3) - 1,
+				retryDelay: Math.ceil(retryDelayMs(1) / 1e3),
+				startAfter: input.scheduledAt,
+				singletonKey: input.dedupeKey
+			});
+			if (!jobId) {
+				if (input.dedupeKey) return input.dedupeKey;
+				throw new Error("Failed to enqueue job");
+			}
+			return jobId;
+		},
+		async startWorker(handler) {
+			let stopped = false;
+			const workerId = await boss.work(queueName, {
+				batchSize: 1,
+				includeMetadata: true
+			}, async (jobs) => {
+				if (stopped) return;
+				const job = jobs[0];
+				if (!job) return;
+				const data = job.data;
+				const maxAttempts = data.maxAttempts ?? (job.retryLimit ?? 0) + 1;
+				const attempt = (job.retryCount ?? 0) + 1;
+				await handler({
+					jobId: job.id,
+					kind: data.kind,
+					targetId: data.targetId,
+					runId: data.runId,
+					trigger: data.trigger,
+					payload: data.payload ?? {},
+					attempt,
+					maxAttempts,
+					exhaustedRetries: attempt >= maxAttempts,
+					scheduledAt: data.scheduledAt ? new Date(data.scheduledAt) : /* @__PURE__ */ new Date(),
+					projectId: data.projectId,
+					parent: data.parent,
+					...data.traceContext ? { traceContext: data.traceContext } : {}
+				});
+			});
+			return async () => {
+				stopped = true;
+				await boss.offWork(queueName, { id: workerId });
+				if (options.stopBossOnWorkerStop) await boss.stop({
+					graceful: true,
+					timeout: 5e3
+				});
+			};
+		},
+		publishCancel: (runId) => cancelChannel.publishCancel(runId),
+		subscribeCancel: (handler) => cancelChannel.subscribeCancel(handler)
+	};
+}
+async function createPgBossQueue(options) {
+	const queueName = options.queueName ?? "keystroke";
+	const boss = new PgBoss({
+		connectionString: options.connectionString,
+		schema: PGBOSS_SCHEMA
+	});
+	await boss.start();
+	await boss.createQueue(queueName);
+	return buildPgBossJobQueue(boss, {
+		stopBossOnWorkerStop: true,
+		queueName,
+		connectionString: options.connectionString,
+		cancelScope: options.cancelScope ?? "project",
+		projectId: options.projectId,
+		organizationId: options.organizationId
+	});
+}
+async function createSharedPgBossJobQueue(boss, options) {
+	const queueName = options.queueName ?? "keystroke";
+	await boss.createQueue(queueName);
+	return buildPgBossJobQueue(boss, {
+		queueName,
+		connectionString: options.connectionString,
+		cancelScope: "platform"
+	});
+}
+//#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;
+	const timezone = triggerTimezoneFromConfig(row.config ?? null);
+	return {
+		triggerSlug: row.slug,
+		kind: row.kind,
+		schedule: row.schedule,
+		...timezone ? { timezone } : {},
+		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,
+			...spec.timezone ? { tz: spec.timezone } : {}
+		});
+	}
+	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({
+		name: "pg-boss",
+		async createJobQueue(ctx) {
+			const url = resolveUrl(ctx);
+			if (ctx.scope === "platform") {
+				await startPgBoss(url);
+				return createSharedPgBossJobQueue(getPgBoss(), { connectionString: url });
+			}
+			if (ctx.scope === "organization") {
+				const organizationId = ctx.organizationId;
+				if (!organizationId) throw new Error("organizationId is required for organization-scoped pg-boss queue");
+				return createPgBossQueue({
+					connectionString: url,
+					queueName: pgBossOrgQueueName(organizationId),
+					cancelScope: "organization",
+					organizationId
+				});
+			}
+			const projectId = ctx.projectId ?? getProjectScopeId();
+			return createPgBossQueue({
+				connectionString: url,
+				queueName: pgBossProjectQueueName(projectId),
+				projectId
+			});
+		},
+		createTriggerScheduler: createPgBossTriggerSchedulerForPlugin
+	});
+}
+/** DB-table queue (Drizzle `jobs`), for SQLite / self-host. */
+function pollingSchedulerPlugin() {
+	return defineSchedulerPlugin({
+		name: "polling",
+		async createJobQueue() {
+			return createDatabaseJobQueue();
+		},
+		createTriggerScheduler: createPollingTriggerScheduler
+	});
+}
+/** Auto-selects pg-boss (postgres) or polling (sqlite) by dialect. */
+function defaultSchedulerPlugin() {
+	return defineSchedulerPlugin({
+		name: "default",
+		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/create-scheduler.ts
+async function createUnderlyingJobQueue(options = {}) {
+	if (options.adapter) return options.adapter;
+	return (options.plugin ?? defaultSchedulerPlugin()).createJobQueue({
+		scope: options.scope ?? "project",
+		url: options.url,
+		dialect: options.dialect,
+		projectId: options.projectId,
+		organizationId: options.organizationId
+	});
+}
+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, workerOptions) => jobQueue.startWorker(handler, workerOptions),
+		...jobQueue.withLentSlot ? { withLentSlot: (fn) => jobQueue.withLentSlot(fn) } : {},
+		publishCancel: (runId) => jobQueue.publishCancel(runId),
+		subscribeCancel: (handler) => jobQueue.subscribeCancel(handler),
+		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 = {}) {
+	const jobQueue = await createUnderlyingJobQueue(options);
+	return wrapScheduler(jobQueue, await createTriggerScheduler(options, jobQueue));
+}
+async function createJobQueue(options = {}) {
+	return createUnderlyingJobQueue(options);
+}
+async function wrapJobQueueAsScheduler(jobQueue, scope) {
+	return wrapScheduler(jobQueue, createDatabaseTriggerScheduler({
+		jobQueue,
+		scope
+	}));
+}
+//#endregion
+//#region src/memory.ts
+function createMemoryJobQueue(options = {}) {
+	const cancelChannel = createInProcessCancelChannel();
+	const pending = [];
+	let handler;
+	let draining = false;
+	async function drain() {
+		if (!handler || draining) return;
+		draining = true;
+		try {
+			while (pending.length > 0) {
+				const next = pending.shift();
+				if (!next) break;
+				const input = next.input;
+				await handler({
+					jobId: next.id,
+					kind: input.kind,
+					targetId: input.targetId,
+					runId: input.runId,
+					trigger: input.trigger,
+					payload: input.payload ?? {},
+					attempt: input.attempt ?? 1,
+					maxAttempts: input.maxAttempts ?? 3,
+					scheduledAt: input.scheduledAt ?? next.enqueuedAt,
+					...input.parent ? { parent: input.parent } : {},
+					...input.traceContext ? { traceContext: input.traceContext } : {}
+				});
+			}
+		} finally {
+			draining = false;
+		}
+	}
+	return {
+		async enqueue(input) {
+			const id = crypto.randomUUID();
+			pending.push({
+				id,
+				input,
+				enqueuedAt: /* @__PURE__ */ new Date()
+			});
+			if (options.sync) await drain();
+			return id;
+		},
+		async startWorker(nextHandler, _opts = {}) {
+			handler = nextHandler;
+			if (!options.sync) drain();
+			return async () => {
+				handler = void 0;
+			};
+		},
+		publishCancel: (runId) => cancelChannel.publishCancel(runId),
+		subscribeCancel: (handler) => cancelChannel.subscribeCancel(handler)
+	};
+}
+//#endregion
+//#region src/shared-pgboss-queue.ts
+let sharedJobQueue$1;
+async function createSharedPgBossScheduler() {
+	return await wrapJobQueueAsScheduler(await getSharedPgBossJobQueue());
+}
+async function getSharedPgBossJobQueue() {
+	if (sharedJobQueue$1) return sharedJobQueue$1;
+	const connectionString = resolvePostgresUrlFromEnv(process.env);
+	if (!connectionString) throw new Error("Postgres connection string is required for shared pg-boss queue");
+	sharedJobQueue$1 = await createSharedPgBossJobQueue(getPgBoss(), { connectionString });
+	return sharedJobQueue$1;
+}
+function resetSharedPgBossJobQueueForTests() {
+	sharedJobQueue$1 = void 0;
+}
+//#endregion
+//#region src/shared-scheduler.ts
+let configuredPlugin;
+let sharedJobQueue;
+function configureSharedScheduler(plugin) {
+	configuredPlugin = plugin;
+	sharedJobQueue = void 0;
+}
+async function createSharedScheduler() {
+	const plugin = configuredPlugin ?? defaultSchedulerPlugin();
+	if (plugin.name === "default") return createSharedPgBossScheduler();
+	if (!sharedJobQueue) sharedJobQueue = await plugin.createJobQueue({ scope: "platform" });
+	return await wrapJobQueueAsScheduler(sharedJobQueue);
+}
+function resetSharedSchedulerForTests() {
+	configuredPlugin = void 0;
+	sharedJobQueue = void 0;
+	resetSharedPgBossJobQueueForTests();
+}
+//#endregion
+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