@rebasepro/server 0.21.2-canary.g1ea48be → 0.23.0

package/dist/{jobs-2fO2BI8P.js → jobs-CazMYhyy.js}

@@ -3,11 +3,12 @@ import __rebaseProcess from "process";
 globalThis.process ??= __rebaseProcess;
 __rebaseCreateRequire(import.meta.url);
 import { n as __exportAll } from "./rolldown-runtime-dW7B1o5h.js";
-import { N as REBASE_USER_ROLE, P as revokeInternalTableSql } from "./src-BYax9_rm.js";
-import "./src-Br6ARbs6.js";
-import { n as createDdlBootstrapper, o as isSQLAdmin, r as hasInCauseChain } from "./ddl-bootstrap-CfNvxMuK.js";
+import { F as revokeInternalTableSql, P as REBASE_USER_ROLE } from "./src-pmvW7BFx.js";
+import "./src-vkcwKXbT.js";
+import { t as isSQLAdmin } from "./backend-DTAOsLQc.js";
 import { n as sqlRows, t as firstSqlRow } from "./sql-rows-C6GEc2oE.js";
 import { r as logger } from "./logger-DO2PZc4i.js";
+import { n as createDdlBootstrapper, r as hasInCauseChain } from "./ddl-bootstrap-C6mo0Kmz.js";
 import { randomUUID } from "crypto";
 //#region src/db/ambient-transaction.ts
 /** Frozen — see above. `server-postgres/src/services/write-transaction-scope.ts` writes it. */
@@ -17,6 +18,255 @@ function currentAmbientTransaction() {
 	return globalThis[RESOLVER_SLOT]?.();
 }
 //#endregion
+//#region src/jobs/job-queue.ts
+/**
+* The worker: claim, run, record, repeat.
+*
+* Everything difficult about running jobs concurrently is in `job-store.ts`,
+* where one `UPDATE … FOR UPDATE SKIP LOCKED` does the arbitration. What is
+* left here is a loop and the decisions around a handler that throws.
+*/
+var DEFAULT_CONCURRENCY = 5;
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+var DEFAULT_VISIBILITY_TIMEOUT_MS = 5 * 6e4;
+var DEFAULT_MAX_ATTEMPTS = 3;
+/** 1s, 5s, 25s, 125s … capped at an hour. */
+function defaultBackoff(attempt) {
+	return Math.min(1e3 * Math.pow(5, Math.max(0, attempt - 1)), 60 * 6e4);
+}
+/**
+* How often the reaper runs, relative to the visibility timeout.
+*
+* A quarter of it, so a stranded job waits at most 1.25× the timeout rather
+* than 2× — and so the sweep is not itself a per-poll query against a table
+* whose interesting rows are, almost always, none.
+*/
+var REAP_INTERVAL_FACTOR = .25;
+/**
+* Thrown by a handler for a failure no retry can change — a destination that
+* is refused, a receiver that redirects. The job is dead-lettered on this
+* attempt, with the message as its `last_error`, instead of spending its
+* remaining attempts proving the same thing. Returning normally is not the
+* alternative: that records the job as succeeded.
+*/
+var PermanentJobError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "PermanentJobError";
+	}
+};
+function createJobQueue(store, options = {}) {
+	const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
+	const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+	const visibilityTimeoutMs = options.visibilityTimeoutMs ?? DEFAULT_VISIBILITY_TIMEOUT_MS;
+	const defaultMaxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+	const backoff = options.backoff ?? defaultBackoff;
+	const handlers = /* @__PURE__ */ new Map();
+	for (const [task, handler] of Object.entries(options.tasks ?? {})) handlers.set(task, handler);
+	const workerId = `${process.pid}-${randomUUID().slice(0, 8)}`;
+	let timer = null;
+	let reapTimer = null;
+	let running = false;
+	/**
+	* Every job this worker is running, tracked one by one rather than per
+	* claimed batch: a batch would let its slowest job decide when the next
+	* claim happens, so one handler that never settled would idle every other
+	* slot — and hold `stop()` with it.
+	*/
+	const active = /* @__PURE__ */ new Set();
+	/** The claim in progress, so `stop()` also waits for jobs it is about to hand out. */
+	let claiming = null;
+	/** The last claim filled every free slot, so more work is probably waiting. */
+	let backlog = false;
+	let reaping = false;
+	let draining = null;
+	/**
+	* Renew `claim` while its handler runs, at a third of the visibility
+	* timeout, so the reaper only ever takes a job from a worker that stopped
+	* renewing — a dead one — and never from one that is merely slow. Returns
+	* the stop.
+	*/
+	function keepClaim(job, claim) {
+		if (!store.heartbeat) return () => void 0;
+		const renew = store.heartbeat.bind(store);
+		const interval = setInterval(() => {
+			renew(job.id, claim).then((held) => {
+				if (held) return;
+				clearInterval(interval);
+				logger.warn(`[jobs] "${job.task}" lost its claim on attempt ${claim.attempt} while running; its outcome will not be recorded`, { jobId: job.id });
+			}).catch((error) => {
+				logger.warn(`[jobs] Could not renew the claim on "${job.task}"`, {
+					jobId: job.id,
+					error
+				});
+			});
+		}, Math.max(1, Math.floor(visibilityTimeoutMs / 3)));
+		interval.unref?.();
+		return () => clearInterval(interval);
+	}
+	async function runJob(job) {
+		const handler = handlers.get(job.task);
+		const claim = {
+			workerId,
+			attempt: job.attempts
+		};
+		if (!handler) {
+			logger.warn(`[jobs] No handler registered for task "${job.task}" — returning the job to the queue`);
+			await store.fail(job.id, `No handler registered for task "${job.task}"`, job.attempts < job.maxAttempts ? new Date(Date.now() + backoff(job.attempts)) : null, claim);
+			return;
+		}
+		const releaseClaim = keepClaim(job, claim);
+		try {
+			try {
+				await handler({
+					id: job.id,
+					task: job.task,
+					payload: job.payload,
+					attempt: job.attempts,
+					maxAttempts: job.maxAttempts
+				});
+			} finally {
+				releaseClaim();
+			}
+			await store.complete(job.id, claim);
+		} catch (error) {
+			const message = error instanceof Error ? error.stack ?? error.message : String(error);
+			const permanent = error instanceof PermanentJobError;
+			const willRetry = !permanent && job.attempts < job.maxAttempts;
+			await store.fail(job.id, message.slice(0, 4e3), willRetry ? new Date(Date.now() + backoff(job.attempts)) : null, claim);
+			if (willRetry) logger.warn(`[jobs] "${job.task}" failed on attempt ${job.attempts}/${job.maxAttempts}; retrying`, { jobId: job.id });
+			else if (permanent) logger.error(`[jobs] "${job.task}" failed permanently on attempt ${job.attempts}; not retrying`, {
+				jobId: job.id,
+				error: message
+			});
+			else logger.error(`[jobs] "${job.task}" failed permanently after ${job.attempts} attempts`, {
+				jobId: job.id,
+				error: message
+			});
+		}
+	}
+	/**
+	* Return jobs stranded by a dead worker. On its own timer, not inside the
+	* poll: a poll can be skipped for as long as every slot is busy, and that
+	* is exactly when a stranded job most needs a peer to take it back.
+	*/
+	async function reap() {
+		if (reaping) return;
+		reaping = true;
+		try {
+			await store.reapExpired(visibilityTimeoutMs);
+		} catch (error) {
+			logger.error("[jobs] Failed to reclaim expired jobs", { error });
+		} finally {
+			reaping = false;
+		}
+	}
+	/** Claim as many jobs as there are free slots and start each one on its own. */
+	async function claimAndStart() {
+		const free = concurrency - active.size;
+		if (free <= 0) return [];
+		if (handlers.size === 0) return [];
+		const jobs = await store.claim(free, workerId, [...handlers.keys()]);
+		backlog = jobs.length >= free;
+		return jobs.map((job) => {
+			const run = runJob(job).catch((error) => {
+				logger.error(`[jobs] Could not record the outcome of "${job.task}"`, {
+					jobId: job.id,
+					error
+				});
+			}).finally(() => {
+				active.delete(run);
+				if (backlog) schedule(0);
+			});
+			active.add(run);
+			return run;
+		});
+	}
+	function schedule(delayMs) {
+		if (!running) return;
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			timer = null;
+			tick();
+		}, delayMs);
+		timer.unref?.();
+	}
+	async function tick() {
+		if (!running || claiming) return;
+		const work = claimAndStart().catch((error) => {
+			logger.error("[jobs] Poll failed", { error });
+			backlog = false;
+		});
+		claiming = work;
+		await work;
+		claiming = null;
+		schedule(backlog && active.size < concurrency ? 0 : pollIntervalMs);
+	}
+	async function drain() {
+		await claiming;
+		await Promise.allSettled([...active]);
+	}
+	return {
+		start() {
+			if (running) return;
+			running = true;
+			logger.info(`[jobs] Worker started (concurrency ${concurrency}, poll ${pollIntervalMs}ms)`);
+			reap();
+			reapTimer = setInterval(() => {
+				reap();
+			}, visibilityTimeoutMs * REAP_INTERVAL_FACTOR);
+			reapTimer.unref?.();
+			schedule(0);
+		},
+		async stop(timeoutMs) {
+			running = false;
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			if (reapTimer) {
+				clearInterval(reapTimer);
+				reapTimer = null;
+			}
+			draining ??= drain().finally(() => {
+				draining = null;
+			});
+			if (timeoutMs === void 0) {
+				await draining;
+				return;
+			}
+			let budget;
+			const finished = await Promise.race([draining.then(() => true), new Promise((resolve) => {
+				budget = setTimeout(() => resolve(false), timeoutMs);
+				budget.unref?.();
+			})]);
+			clearTimeout(budget);
+			if (!finished) logger.warn(`[jobs] ${active.size} job(s) still running after ${timeoutMs}ms; stopping without them. They keep their claim and are retried once the visibility timeout reclaims it.`);
+		},
+		async runOnce() {
+			const started = await claimAndStart();
+			await Promise.allSettled(started);
+			return started.length;
+		},
+		register(task, handler) {
+			if (handlers.has(task)) logger.warn(`[jobs] Task "${task}" was already registered; the later handler wins`);
+			handlers.set(task, handler);
+		},
+		isRunning() {
+			return running;
+		},
+		async enqueue(task, payload, enqueueOptions = {}) {
+			return store.insert({
+				task,
+				payload: payload ?? null,
+				runAt: new Date(Date.now() + (enqueueOptions.delayMs ?? 0)),
+				maxAttempts: enqueueOptions.maxAttempts ?? defaultMaxAttempts,
+				idempotencyKey: enqueueOptions.idempotencyKey
+			});
+		}
+	};
+}
+//#endregion
 //#region src/jobs/job-store.ts
 /**
 * The queue's storage, as SQL against `rebase.jobs`.
@@ -77,6 +327,11 @@ function isUniqueViolation(err) {
 */
 var ENQUEUE_FUNCTION = "rebase.enqueue_job";
 var ENQUEUE_SIGNATURE = `${ENQUEUE_FUNCTION}(text, jsonb, timestamptz, integer, text)`;
+/** The rows a claim's writes may touch: `$1` the job, `$2` the worker, `$3` the attempt. */
+var HELD_BY_CLAIM = "id = $1 AND status = 'running' AND locked_by = $2 AND attempts = $3";
+function warnStaleOutcome(id, claim, outcome) {
+	logger.warn(`[jobs] Ignored the ${outcome} of attempt ${claim.attempt} of job ${id}: the job was reclaimed from this worker while it ran, so that attempt's outcome is no longer the job's.`);
+}
 function createJobStore(driver) {
 	const admin = driver.admin;
 	if (!isSQLAdmin(admin)) {
@@ -184,7 +439,9 @@ function createJobStore(driver) {
 				throw error;
 			}
 		},
-		async claim(limit, workerId) {
+		async claim(limit, workerId, tasks) {
+			if (tasks && tasks.length === 0) return [];
+			const taskFilter = tasks ? `AND task IN (${tasks.map((_, i) => `$${i + 3}`).join(", ")})` : "";
 			return sqlRows(await exec(`UPDATE ${TABLE} SET
                     status = 'running',
                     attempts = attempts + 1,
@@ -193,32 +450,55 @@ function createJobStore(driver) {
                     updated_at = now()
                  WHERE id IN (
                      SELECT id FROM ${TABLE}
-                     WHERE status = 'pending' AND run_at <= now()
+                     WHERE status = 'pending' AND run_at <= now() ${taskFilter}
                      ORDER BY run_at, created_at
                      LIMIT $1
                      FOR UPDATE SKIP LOCKED
                  )
-                 RETURNING *`, [limit, workerId])).map(toRecord);
+                 RETURNING *`, [
+				limit,
+				workerId,
+				...tasks ?? []
+			])).map(toRecord);
 		},
-		async complete(id) {
-			await exec(`UPDATE ${TABLE} SET status = 'succeeded', locked_at = NULL, locked_by = NULL,
+		async complete(id, claim) {
+			if (sqlRows(await exec(`UPDATE ${TABLE} SET status = 'succeeded', locked_at = NULL, locked_by = NULL,
                         last_error = NULL, updated_at = now()
-                 WHERE id = $1`, [id]);
+                 WHERE ${HELD_BY_CLAIM}
+                 RETURNING id`, [
+				id,
+				claim.workerId,
+				claim.attempt
+			])).length === 0) warnStaleOutcome(id, claim, "success");
 		},
-		async fail(id, error, retryAt) {
-			if (retryAt) {
-				await exec(`UPDATE ${TABLE} SET status = 'pending', run_at = $2, locked_at = NULL,
-                            locked_by = NULL, last_error = $3, updated_at = now()
-                     WHERE id = $1`, [
-					id,
-					retryAt.toISOString(),
-					error
-				]);
-				return;
-			}
-			await exec(`UPDATE ${TABLE} SET status = 'failed', locked_at = NULL, locked_by = NULL,
-                        last_error = $2, updated_at = now()
-                 WHERE id = $1`, [id, error]);
+		async fail(id, error, retryAt, claim) {
+			if (sqlRows(retryAt ? await exec(`UPDATE ${TABLE} SET status = 'pending', run_at = $4, locked_at = NULL,
+                            locked_by = NULL, last_error = $5, updated_at = now()
+                     WHERE ${HELD_BY_CLAIM}
+                     RETURNING id`, [
+				id,
+				claim.workerId,
+				claim.attempt,
+				retryAt.toISOString(),
+				error
+			]) : await exec(`UPDATE ${TABLE} SET status = 'failed', locked_at = NULL, locked_by = NULL,
+                            last_error = $4, updated_at = now()
+                     WHERE ${HELD_BY_CLAIM}
+                     RETURNING id`, [
+				id,
+				claim.workerId,
+				claim.attempt,
+				error
+			])).length === 0) warnStaleOutcome(id, claim, "failure");
+		},
+		async heartbeat(id, claim) {
+			return sqlRows(await exec(`UPDATE ${TABLE} SET locked_at = now()
+                 WHERE ${HELD_BY_CLAIM}
+                 RETURNING id`, [
+				id,
+				claim.workerId,
+				claim.attempt
+			])).length > 0;
 		},
 		async reapExpired(visibilityTimeoutMs) {
 			const seconds = Math.max(1, Math.round(visibilityTimeoutMs / 1e3));
@@ -245,153 +525,12 @@ function createJobStore(driver) {
 	};
 }
 //#endregion
-//#region src/jobs/job-queue.ts
-/**
-* The worker: claim, run, record, repeat.
-*
-* Everything difficult about running jobs concurrently is in `job-store.ts`,
-* where one `UPDATE … FOR UPDATE SKIP LOCKED` does the arbitration. What is
-* left here is a loop and the decisions around a handler that throws.
-*/
-var DEFAULT_CONCURRENCY = 5;
-var DEFAULT_POLL_INTERVAL_MS = 2e3;
-var DEFAULT_VISIBILITY_TIMEOUT_MS = 5 * 6e4;
-var DEFAULT_MAX_ATTEMPTS = 3;
-/** 1s, 5s, 25s, 125s … capped at an hour. */
-function defaultBackoff(attempt) {
-	return Math.min(1e3 * Math.pow(5, Math.max(0, attempt - 1)), 60 * 6e4);
-}
-/**
-* How often the reaper runs, relative to the visibility timeout.
-*
-* A quarter of it, so a stranded job waits at most 1.25× the timeout rather
-* than 2× — and so the sweep is not itself a per-poll query against a table
-* whose interesting rows are, almost always, none.
-*/
-var REAP_INTERVAL_FACTOR = .25;
-function createJobQueue(store, options = {}) {
-	const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
-	const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-	const visibilityTimeoutMs = options.visibilityTimeoutMs ?? DEFAULT_VISIBILITY_TIMEOUT_MS;
-	const defaultMaxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-	const backoff = options.backoff ?? defaultBackoff;
-	const handlers = /* @__PURE__ */ new Map();
-	for (const [task, handler] of Object.entries(options.tasks ?? {})) handlers.set(task, handler);
-	const workerId = `${process.pid}-${randomUUID().slice(0, 8)}`;
-	let timer = null;
-	let running = false;
-	let draining = false;
-	/** Resolves when the in-flight poll finishes, so `stop()` can wait for it. */
-	let inFlight = Promise.resolve();
-	let lastReapAt = 0;
-	async function runJob(job) {
-		const handler = handlers.get(job.task);
-		if (!handler) {
-			logger.warn(`[jobs] No handler registered for task "${job.task}" — returning the job to the queue`);
-			await store.fail(job.id, `No handler registered for task "${job.task}"`, job.attempts < job.maxAttempts ? new Date(Date.now() + backoff(job.attempts)) : null);
-			return;
-		}
-		try {
-			await handler({
-				id: job.id,
-				task: job.task,
-				payload: job.payload,
-				attempt: job.attempts,
-				maxAttempts: job.maxAttempts
-			});
-			await store.complete(job.id);
-		} catch (error) {
-			const message = error instanceof Error ? error.stack ?? error.message : String(error);
-			const willRetry = job.attempts < job.maxAttempts;
-			await store.fail(job.id, message.slice(0, 4e3), willRetry ? new Date(Date.now() + backoff(job.attempts)) : null);
-			if (willRetry) logger.warn(`[jobs] "${job.task}" failed on attempt ${job.attempts}/${job.maxAttempts}; retrying`, { jobId: job.id });
-			else logger.error(`[jobs] "${job.task}" failed permanently after ${job.attempts} attempts`, {
-				jobId: job.id,
-				error: message
-			});
-		}
-	}
-	async function poll() {
-		const now = Date.now();
-		if (now - lastReapAt > visibilityTimeoutMs * REAP_INTERVAL_FACTOR) {
-			lastReapAt = now;
-			try {
-				await store.reapExpired(visibilityTimeoutMs);
-			} catch (error) {
-				logger.error("[jobs] Failed to reclaim expired jobs", { error });
-			}
-		}
-		const jobs = await store.claim(concurrency, workerId);
-		if (jobs.length === 0) return 0;
-		await Promise.allSettled(jobs.map(runJob));
-		return jobs.length;
-	}
-	function schedule(delayMs) {
-		if (!running) return;
-		timer = setTimeout(() => {
-			tick();
-		}, delayMs);
-		timer.unref?.();
-	}
-	async function tick() {
-		if (!running) return;
-		const work = (async () => {
-			try {
-				return await poll();
-			} catch (error) {
-				logger.error("[jobs] Poll failed", { error });
-				return 0;
-			}
-		})();
-		inFlight = work;
-		schedule(await work >= concurrency ? 0 : pollIntervalMs);
-	}
-	return {
-		start() {
-			if (running) return;
-			running = true;
-			logger.info(`[jobs] Worker started (concurrency ${concurrency}, poll ${pollIntervalMs}ms)`);
-			schedule(0);
-		},
-		async stop() {
-			running = false;
-			if (timer) {
-				clearTimeout(timer);
-				timer = null;
-			}
-			if (draining) return;
-			draining = true;
-			await inFlight.catch(() => void 0);
-			draining = false;
-		},
-		runOnce() {
-			return poll();
-		},
-		register(task, handler) {
-			if (handlers.has(task)) logger.warn(`[jobs] Task "${task}" was already registered; the later handler wins`);
-			handlers.set(task, handler);
-		},
-		isRunning() {
-			return running;
-		},
-		async enqueue(task, payload, enqueueOptions = {}) {
-			return store.insert({
-				task,
-				payload: payload ?? null,
-				runAt: new Date(Date.now() + (enqueueOptions.delayMs ?? 0)),
-				maxAttempts: enqueueOptions.maxAttempts ?? defaultMaxAttempts,
-				idempotencyKey: enqueueOptions.idempotencyKey
-			});
-		}
-	};
-}
-//#endregion
 //#region src/jobs/index.ts
 var jobs_exports = /* @__PURE__ */ __exportAll({
 	createJobQueue: () => createJobQueue,
 	createJobStore: () => createJobStore
 });
 //#endregion
-export { currentAmbientTransaction as a, createJobStore as i, createJobQueue as n, defaultBackoff as r, jobs_exports as t };
+export { defaultBackoff as a, createJobQueue as i, createJobStore as n, currentAmbientTransaction as o, PermanentJobError as r, jobs_exports as t };
 
-//# sourceMappingURL=jobs-2fO2BI8P.js.map
+//# sourceMappingURL=jobs-CazMYhyy.js.map

package/dist/jobs-CazMYhyy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jobs-CazMYhyy.js","names":[],"sources":["../src/db/ambient-transaction.ts","../src/jobs/job-queue.ts","../src/jobs/job-store.ts","../src/jobs/index.ts"],"sourcesContent":["/**\n * The write transaction the current code is running inside, when there is one.\n *\n * A collection callback runs inside the transaction that carries its write.\n * Work it hands off — a job, a queue message, a topic event, a webhook\n * delivery — has to share that write's fate: queued when it commits, never\n * queued when it rolls back, and invisible to a worker until the commit. The\n * code that queues it lives in this package and knows no driver; the\n * transaction belongs to the driver. So the driver publishes the transaction it\n * opened for a write, and the queueing code asks for it here.\n *\n * Until this existed the job store wrote through the default driver's own\n * connection, in autocommit, whatever called it. A job enqueued from an\n * `afterSave` that then threw stayed queued for a row that was never written,\n * and a worker could claim it before the row it was about committed.\n *\n * The resolver lives on `globalThis` under a registered symbol, like the\n * `rebase` singleton: a managed runtime can load two copies of this package,\n * and the copy a driver registers with must be the one the job store reads.\n * No Node imports — the store is reachable from code that has to stay portable.\n *\n * **The symbol's key is a contract between packages, and frozen.** The\n * Postgres driver writes the slot itself rather than importing a setter from\n * here: the managed runtime supplies this package from the image while a\n * bundle brings its own driver, and a driver importing a function an older\n * image does not export would fail to link and take the boot down. Written\n * through the slot, any pairing of versions degrades to the old behaviour —\n * jobs committing on their own — instead.\n */\nexport interface AmbientTransaction {\n    /**\n     * Run one statement on the transaction, `$1…` placeholders as\n     * `executeSql` takes them. It runs as the transaction's current role — on\n     * Postgres the request's restricted one — so a statement that needs more\n     * goes through a function granted to that role.\n     */\n    exec(sqlText: string, params?: unknown[]): Promise<Record<string, unknown>[]>;\n    /** Run `fn` after the transaction commits. Never runs if it rolls back. */\n    afterCommit(fn: () => void): void;\n}\n\n/** Frozen — see above. `server-postgres/src/services/write-transaction-scope.ts` writes it. */\nconst RESOLVER_SLOT = Symbol.for(\"rebase.server.ambientTransactionResolver\");\n\ntype ResolverSlot = { [RESOLVER_SLOT]?: () => AmbientTransaction | undefined };\n\n/**\n * Register how to find the write transaction the caller is inside; pass\n * `undefined` to unregister. For tests and for drivers in this repository's\n * lockstep — a driver shipped separately writes the slot, as above.\n */\nexport function setAmbientTransactionResolver(resolve: (() => AmbientTransaction | undefined) | undefined): void {\n    (globalThis as ResolverSlot)[RESOLVER_SLOT] = resolve;\n}\n\n/** The write transaction the caller is inside, or `undefined` outside one. */\nexport function currentAmbientTransaction(): AmbientTransaction | undefined {\n    return (globalThis as ResolverSlot)[RESOLVER_SLOT]?.();\n}\n","import { randomUUID } from \"crypto\";\nimport { logger } from \"../utils/logger.js\";\nimport type { JobClaim, JobStore } from \"./job-store.js\";\nimport type { EnqueueOptions, JobHandler, JobQueueClient, JobQueueOptions, JobRecord } from \"./types.js\";\n\n/**\n * The worker: claim, run, record, repeat.\n *\n * Everything difficult about running jobs concurrently is in `job-store.ts`,\n * where one `UPDATE … FOR UPDATE SKIP LOCKED` does the arbitration. What is\n * left here is a loop and the decisions around a handler that throws.\n */\n\nconst DEFAULT_CONCURRENCY = 5;\nconst DEFAULT_POLL_INTERVAL_MS = 2_000;\nconst DEFAULT_VISIBILITY_TIMEOUT_MS = 5 * 60_000;\nconst DEFAULT_MAX_ATTEMPTS = 3;\n\n/** 1s, 5s, 25s, 125s … capped at an hour. */\nexport function defaultBackoff(attempt: number): number {\n    return Math.min(1_000 * Math.pow(5, Math.max(0, attempt - 1)), 60 * 60_000);\n}\n\n/**\n * How often the reaper runs, relative to the visibility timeout.\n *\n * A quarter of it, so a stranded job waits at most 1.25× the timeout rather\n * than 2× — and so the sweep is not itself a per-poll query against a table\n * whose interesting rows are, almost always, none.\n */\nconst REAP_INTERVAL_FACTOR = 0.25;\n\n/**\n * Thrown by a handler for a failure no retry can change — a destination that\n * is refused, a receiver that redirects. The job is dead-lettered on this\n * attempt, with the message as its `last_error`, instead of spending its\n * remaining attempts proving the same thing. Returning normally is not the\n * alternative: that records the job as succeeded.\n */\nexport class PermanentJobError extends Error {\n    constructor(message: string, options?: { cause?: unknown }) {\n        super(message, options);\n        this.name = \"PermanentJobError\";\n    }\n}\n\nexport interface JobQueue extends JobQueueClient {\n    start(): void;\n    /**\n     * Stop claiming, and wait for the jobs in flight — for at most `timeoutMs`\n     * when given. A job still running when the budget runs out keeps its claim\n     * and is recovered by the visibility timeout; waiting on it without a bound\n     * would let one handler that never settles hold the whole shutdown.\n     */\n    stop(timeoutMs?: number): Promise<void>;\n    /**\n     * Claim what fits in the free slots, run it, and resolve with how many jobs\n     * ran. For tests and for `/jobs/drain`; not meant to run beside `start()`.\n     */\n    runOnce(): Promise<number>;\n    /** Registered after construction — how `tasks` from config and internal producers meet. */\n    register<P = unknown>(task: string, handler: JobHandler<P>): void;\n    isRunning(): boolean;\n}\n\nexport function createJobQueue(store: JobStore, options: JobQueueOptions = {}): JobQueue {\n    const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;\n    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;\n    const visibilityTimeoutMs = options.visibilityTimeoutMs ?? DEFAULT_VISIBILITY_TIMEOUT_MS;\n    const defaultMaxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;\n    const backoff = options.backoff ?? defaultBackoff;\n\n    const handlers = new Map<string, JobHandler<never>>();\n    for (const [task, handler] of Object.entries(options.tasks ?? {})) {\n        handlers.set(task, handler);\n    }\n\n    // Identifies this process in `locked_by`: \"which pod had it when it\n    // stopped\" is the first question anyone asks of a stuck job, and with the\n    // attempt it is the claim an outcome is written under (see `JobClaim`).\n    const workerId = `${process.pid}-${randomUUID().slice(0, 8)}`;\n\n    let timer: NodeJS.Timeout | null = null;\n    let reapTimer: NodeJS.Timeout | null = null;\n    let running = false;\n    /**\n     * Every job this worker is running, tracked one by one rather than per\n     * claimed batch: a batch would let its slowest job decide when the next\n     * claim happens, so one handler that never settled would idle every other\n     * slot — and hold `stop()` with it.\n     */\n    const active = new Set<Promise<void>>();\n    /** The claim in progress, so `stop()` also waits for jobs it is about to hand out. */\n    let claiming: Promise<unknown> | null = null;\n    /** The last claim filled every free slot, so more work is probably waiting. */\n    let backlog = false;\n    let reaping = false;\n    let draining: Promise<void> | null = null;\n\n    /**\n     * Renew `claim` while its handler runs, at a third of the visibility\n     * timeout, so the reaper only ever takes a job from a worker that stopped\n     * renewing — a dead one — and never from one that is merely slow. Returns\n     * the stop.\n     */\n    function keepClaim(job: JobRecord, claim: JobClaim): () => void {\n        if (!store.heartbeat) return () => undefined;\n        const renew = store.heartbeat.bind(store);\n        const interval = setInterval(() => {\n            renew(job.id, claim).then((held) => {\n                if (held) return;\n                clearInterval(interval);\n                logger.warn(\n                    `[jobs] \"${job.task}\" lost its claim on attempt ${claim.attempt} while running; ` +\n                    \"its outcome will not be recorded\", { jobId: job.id }\n                );\n            }).catch((error: unknown) => {\n                logger.warn(`[jobs] Could not renew the claim on \"${job.task}\"`, { jobId: job.id, error });\n            });\n        }, Math.max(1, Math.floor(visibilityTimeoutMs / 3)));\n        interval.unref?.();\n        return () => clearInterval(interval);\n    }\n\n    async function runJob(job: JobRecord): Promise<void> {\n        const handler = handlers.get(job.task);\n        const claim: JobClaim = { workerId, attempt: job.attempts };\n\n        if (!handler) {\n            // Only reachable through a store that ignores the `tasks` filter on\n            // `claim` — the one that ships never hands this worker a task it\n            // has no handler for. Give the row back for a peer that has one.\n            // The attempt the claim spent is not undone, so a task nobody in\n            // the fleet implements dead-letters with an error naming it rather\n            // than cycling through such a store forever.\n            logger.warn(`[jobs] No handler registered for task \"${job.task}\" — returning the job to the queue`);\n            await store.fail(\n                job.id,\n                `No handler registered for task \"${job.task}\"`,\n                job.attempts < job.maxAttempts ? new Date(Date.now() + backoff(job.attempts)) : null,\n                claim\n            );\n            return;\n        }\n\n        const releaseClaim = keepClaim(job, claim);\n        try {\n            try {\n                await handler({\n                    id: job.id,\n                    task: job.task,\n                    payload: job.payload as never,\n                    attempt: job.attempts,\n                    maxAttempts: job.maxAttempts\n                } as never);\n            } finally {\n                releaseClaim();\n            }\n            await store.complete(job.id, claim);\n        } catch (error) {\n            const message = error instanceof Error ? (error.stack ?? error.message) : String(error);\n            const permanent = error instanceof PermanentJobError;\n            const willRetry = !permanent && job.attempts < job.maxAttempts;\n\n            // Truncated, because `last_error` holds a stack and a queue that\n            // accumulates megabytes of them is its own outage.\n            await store.fail(job.id, message.slice(0, 4_000), willRetry ? new Date(Date.now() + backoff(job.attempts)) : null, claim);\n\n            if (willRetry) {\n                logger.warn(`[jobs] \"${job.task}\" failed on attempt ${job.attempts}/${job.maxAttempts}; retrying`, { jobId: job.id });\n            } else if (permanent) {\n                logger.error(`[jobs] \"${job.task}\" failed permanently on attempt ${job.attempts}; not retrying`, { jobId: job.id, error: message });\n            } else {\n                // The last attempt is an error, not a warning: nothing else will\n                // touch this job, and if nobody looks at the table it is simply\n                // lost work.\n                logger.error(`[jobs] \"${job.task}\" failed permanently after ${job.attempts} attempts`, { jobId: job.id, error: message });\n            }\n        }\n    }\n\n    /**\n     * Return jobs stranded by a dead worker. On its own timer, not inside the\n     * poll: a poll can be skipped for as long as every slot is busy, and that\n     * is exactly when a stranded job most needs a peer to take it back.\n     */\n    async function reap(): Promise<void> {\n        if (reaping) return;\n        reaping = true;\n        try {\n            await store.reapExpired(visibilityTimeoutMs);\n        } catch (error) {\n            logger.error(\"[jobs] Failed to reclaim expired jobs\", { error });\n        } finally {\n            reaping = false;\n        }\n    }\n\n    /** Claim as many jobs as there are free slots and start each one on its own. */\n    async function claimAndStart(): Promise<Promise<void>[]> {\n        const free = concurrency - active.size;\n        if (free <= 0) return [];\n\n        // Only the tasks this worker can run. During a rolling deploy an\n        // instance on older code shares the table with jobs whose task only\n        // the newer code implements, and a claim spends an attempt: claiming\n        // them here would dead-letter them before an updated peer got to them.\n        // A handler registered after `start()` joins the next claim.\n        if (handlers.size === 0) return [];\n        const jobs = await store.claim(free, workerId, [...handlers.keys()]);\n        backlog = jobs.length >= free;\n\n        return jobs.map((job) => {\n            const run: Promise<void> = runJob(job)\n                .catch((error) => {\n                    // `runJob` handles a throwing handler; this is a store\n                    // write failing after it. The job keeps its claim, so the\n                    // visibility timeout recovers it.\n                    logger.error(`[jobs] Could not record the outcome of \"${job.task}\"`, { jobId: job.id, error });\n                })\n                .finally(() => {\n                    active.delete(run);\n                    // A slot just came free and there is work waiting: take the\n                    // next job now, not a poll interval from now.\n                    if (backlog) schedule(0);\n                });\n            active.add(run);\n            return run;\n        });\n    }\n\n    function schedule(delayMs: number): void {\n        if (!running) return;\n        if (timer) clearTimeout(timer);\n        timer = setTimeout(() => {\n            timer = null;\n            void tick();\n        }, delayMs);\n        // Never hold the process open. A queue with nothing to do should not be\n        // the reason `rebase dev` will not exit.\n        timer.unref?.();\n    }\n\n    async function tick(): Promise<void> {\n        // A claim already in progress reschedules when it finishes.\n        if (!running || claiming) return;\n        const work = claimAndStart().catch((error) => {\n            logger.error(\"[jobs] Poll failed\", { error });\n            backlog = false;\n        });\n        claiming = work;\n        await work;\n        claiming = null;\n\n        // A full claim with a slot still free — a job already finished — means\n        // go straight back. Otherwise sleep; a job finishing during a backlog\n        // wakes the loop early.\n        schedule(backlog && active.size < concurrency ? 0 : pollIntervalMs);\n    }\n\n    async function drain(): Promise<void> {\n        await claiming;\n        await Promise.allSettled([...active]);\n    }\n\n    return {\n        start(): void {\n            if (running) return;\n            running = true;\n            logger.info(`[jobs] Worker started (concurrency ${concurrency}, poll ${pollIntervalMs}ms)`);\n            void reap();\n            reapTimer = setInterval(() => { void reap(); }, visibilityTimeoutMs * REAP_INTERVAL_FACTOR);\n            reapTimer.unref?.();\n            schedule(0);\n        },\n\n        async stop(timeoutMs?: number): Promise<void> {\n            running = false;\n            if (timer) {\n                clearTimeout(timer);\n                timer = null;\n            }\n            if (reapTimer) {\n                clearInterval(reapTimer);\n                reapTimer = null;\n            }\n            // Jobs in flight keep their claim until they finish or the\n            // visibility timeout expires, so waiting here is what turns a\n            // graceful shutdown into \"no job runs twice\".\n            draining ??= drain().finally(() => { draining = null; });\n            if (timeoutMs === undefined) {\n                await draining;\n                return;\n            }\n            let budget: NodeJS.Timeout | undefined;\n            const finished = await Promise.race([\n                draining.then(() => true),\n                new Promise<false>((resolve) => {\n                    budget = setTimeout(() => resolve(false), timeoutMs);\n                    budget.unref?.();\n                })\n            ]);\n            clearTimeout(budget);\n            if (!finished) {\n                logger.warn(\n                    `[jobs] ${active.size} job(s) still running after ${timeoutMs}ms; stopping without them. ` +\n                    \"They keep their claim and are retried once the visibility timeout reclaims it.\"\n                );\n            }\n        },\n\n        async runOnce(): Promise<number> {\n            const started = await claimAndStart();\n            await Promise.allSettled(started);\n            return started.length;\n        },\n\n        register<P = unknown>(task: string, handler: JobHandler<P>): void {\n            if (handlers.has(task)) {\n                logger.warn(`[jobs] Task \"${task}\" was already registered; the later handler wins`);\n            }\n            handlers.set(task, handler as JobHandler<never>);\n        },\n\n        isRunning(): boolean {\n            return running;\n        },\n\n        async enqueue<P = unknown>(task: string, payload?: P, enqueueOptions: EnqueueOptions = {}): Promise<string | null> {\n            return store.insert({\n                task,\n                payload: payload ?? null,\n                runAt: new Date(Date.now() + (enqueueOptions.delayMs ?? 0)),\n                maxAttempts: enqueueOptions.maxAttempts ?? defaultMaxAttempts,\n                idempotencyKey: enqueueOptions.idempotencyKey\n            });\n        }\n    };\n}\n","import type { DataDriver } from \"@rebasepro/types\";\nimport { isSQLAdmin } from \"@rebasepro/types\";\nimport { REBASE_USER_ROLE, revokeInternalTableSql, sqlRows, firstSqlRow } from \"@rebasepro/common\";\nimport { logger } from \"../utils/logger.js\";\nimport { createDdlBootstrapper, hasInCauseChain, type SqlExec } from \"../boot/ddl-bootstrap.js\";\nimport { currentAmbientTransaction } from \"../db/ambient-transaction.js\";\nimport type { JobRecord } from \"./types.js\";\n\n/**\n * The queue's storage, as SQL against `rebase.jobs`.\n *\n * Split from the worker for the same reason `cron-store` is split from\n * `cron-scheduler`: the interesting parts here are three statements that have\n * to be exactly right under concurrency, and they are much easier to reason\n * about — and to test — away from a polling loop.\n */\n\nconst TABLE = \"rebase.jobs\";\n\n/** How long finished jobs are kept before the boot sweep removes them. */\nconst SUCCEEDED_RETENTION_DAYS = 3;\n/**\n * Failures outlive successes by a lot. A dead-lettered job is evidence, and the\n * person who needs it is usually looking on Monday for something that happened\n * on Friday night.\n */\nconst FAILED_RETENTION_DAYS = 30;\n\n/** A row as Postgres returns it. */\ninterface JobRow {\n    id: string;\n    task: string;\n    payload: unknown;\n    status: string;\n    run_at: string;\n    attempts: number;\n    max_attempts: number;\n    last_error: string | null;\n    created_at: string;\n    updated_at: string;\n}\n\nfunction toRecord(row: JobRow): JobRecord {\n    return {\n        id: row.id,\n        task: row.task,\n        payload: row.payload,\n        status: row.status as JobRecord[\"status\"],\n        runAt: new Date(row.run_at).toISOString(),\n        attempts: Number(row.attempts),\n        maxAttempts: Number(row.max_attempts),\n        lastError: row.last_error,\n        createdAt: new Date(row.created_at).toISOString(),\n        updatedAt: new Date(row.updated_at).toISOString()\n    };\n}\n\n/** Same rule as `cron-store`: match the SQLSTATE, never the message. */\nfunction isUniqueViolation(err: unknown): boolean {\n    return hasInCauseChain(err, (e) => e.code === \"23505\");\n}\n\n/**\n * How a job gets into `rebase.jobs` from inside somebody else's transaction.\n *\n * An enqueue from a collection callback has to ride the write's transaction —\n * committed with it, discarded with it, invisible to workers until then — and\n * that transaction runs as the request's restricted role, which has no access\n * to `rebase.jobs` at all (see the revoke in `ensureTable`). This function is\n * the one door: `SECURITY DEFINER`, so the insert runs with the owner's rights\n * for that one statement and the transaction's role never changes. Switching\n * the role for the insert instead would elevate the whole connection for as\n * long as the insert took, and a callback's un-awaited statement would run\n * in that window as the owner.\n *\n * The door is narrow on purpose. It takes the five columns an enqueue sets and\n * nothing else, so it cannot claim, complete or rewrite a job — and only the\n * request role is granted it, not PUBLIC. That role runs statements the server\n * writes; nobody outside gets SQL as it.\n *\n * `ON CONFLICT DO NOTHING` rather than a caught unique violation: an error\n * inside a transaction aborts the whole transaction, so an idempotency clash\n * would have failed the customer's write. A clash returns no row, hence NULL.\n */\nconst ENQUEUE_FUNCTION = \"rebase.enqueue_job\";\nconst ENQUEUE_SIGNATURE = `${ENQUEUE_FUNCTION}(text, jsonb, timestamptz, integer, text)`;\n\n/**\n * Which claim an outcome belongs to: the worker holding the job, and the\n * attempt that claim spent.\n *\n * The visibility timeout hands a job to a second worker when the first stops\n * renewing its claim, and the first may still be running — slow, not dead. Its\n * outcome is then about an attempt the table has moved past, and writing it\n * would mark a running job `succeeded`, or send a finished one back to\n * `pending` for another run. Both writes therefore apply only while the claim\n * they name still holds the row. The attempt is part of the identity because a\n * worker's own reaper can hand a job back to the same worker in another slot.\n */\nexport interface JobClaim {\n    workerId: string;\n    attempt: number;\n}\n\nexport interface JobStore {\n    ensureTable(): Promise<void>;\n    /** Returns the new job's id, or `null` if an idempotency key matched unfinished work. */\n    insert(job: {\n        task: string;\n        payload: unknown;\n        runAt: Date;\n        maxAttempts: number;\n        idempotencyKey?: string;\n    }): Promise<string | null>;\n    /**\n     * Atomically take up to `limit` runnable jobs for this worker — only jobs\n     * whose task is in `tasks`, when it is given. A worker never claims work it\n     * cannot run: a claim spends an attempt, so an instance running older code\n     * during a rollout would otherwise dead-letter the newer code's jobs.\n     */\n    claim(limit: number, workerId: string, tasks?: readonly string[]): Promise<JobRecord[]>;\n    /** Mark the job `succeeded` — a no-op once `claim` no longer holds it. */\n    complete(id: string, claim: JobClaim): Promise<void>;\n    /**\n     * Back to `pending` with a later `runAt`, or `failed` when out of attempts —\n     * a no-op once `claim` no longer holds it.\n     */\n    fail(id: string, error: string, retryAt: Date | null, claim: JobClaim): Promise<void>;\n    /**\n     * Renew `claim` on a job whose handler is still running, so the visibility\n     * timeout only ever reclaims a job from a worker that stopped renewing.\n     * Resolves with whether the claim still held. A store without it leaves a\n     * handler that outlives the timeout to be run a second time beside itself.\n     */\n    heartbeat?(id: string, claim: JobClaim): Promise<boolean>;\n    /** Return jobs stranded by a worker that died holding them. Resolves with how many. */\n    reapExpired(visibilityTimeoutMs: number): Promise<number>;\n    fetch(id: string): Promise<JobRecord | null>;\n}\n\n/** The rows a claim's writes may touch: `$1` the job, `$2` the worker, `$3` the attempt. */\nconst HELD_BY_CLAIM = \"id = $1 AND status = 'running' AND locked_by = $2 AND attempts = $3\";\n\nfunction warnStaleOutcome(id: string, claim: JobClaim, outcome: \"success\" | \"failure\"): void {\n    logger.warn(\n        `[jobs] Ignored the ${outcome} of attempt ${claim.attempt} of job ${id}: the job was reclaimed ` +\n        \"from this worker while it ran, so that attempt's outcome is no longer the job's.\"\n    );\n}\n\nexport function createJobStore(driver: DataDriver): JobStore | undefined {\n    const admin = driver.admin;\n    if (!isSQLAdmin(admin)) {\n        logger.warn(\n            \"⚠️ [jobs] DataDriver does not support SQL admin — the durable job queue is unavailable. \" +\n            \"Work that would have been queued runs inline instead.\"\n        );\n        return undefined;\n    }\n\n    // Two shapes of the same call: the bootstrapper's `SqlExec` takes an\n    // options object, while everything below reads better with a positional\n    // parameter array.\n    const execRaw: SqlExec = (sqlText, options) =>\n        admin.executeSql(sqlText, options?.params ? { params: options.params } : undefined);\n    const exec = (sqlText: string, params?: unknown[]) =>\n        execRaw(sqlText, params ? { params } : undefined);\n\n    const ddl = createDdlBootstrapper(execRaw, \"jobs\");\n\n    /**\n     * Whether {@link ENQUEUE_FUNCTION} exists, so an enqueue inside a write can\n     * ride its transaction. Decided at boot rather than assumed: a database\n     * that refused the function would otherwise fail every write whose callback\n     * enqueues, where falling back to the old behaviour only loses atomicity.\n     */\n    let enqueueInTransaction = false;\n\n    return {\n        async ensureTable(): Promise<void> {\n            await ddl.ensureObject(\"Creating schema rebase\", \"CREATE SCHEMA IF NOT EXISTS rebase\");\n\n            await ddl.ensureObject(`Creating ${TABLE}`, `\n                CREATE TABLE IF NOT EXISTS ${TABLE} (\n                    id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,\n                    task TEXT NOT NULL,\n                    payload JSONB,\n                    status TEXT NOT NULL DEFAULT 'pending',\n                    run_at TIMESTAMPTZ NOT NULL DEFAULT now(),\n                    attempts INTEGER NOT NULL DEFAULT 0,\n                    max_attempts INTEGER NOT NULL DEFAULT 3,\n                    locked_at TIMESTAMPTZ,\n                    locked_by TEXT,\n                    idempotency_key TEXT,\n                    last_error TEXT,\n                    created_at TIMESTAMPTZ NOT NULL DEFAULT now(),\n                    updated_at TIMESTAMPTZ NOT NULL DEFAULT now()\n                )\n            `);\n\n            // The claim query's index. Partial, because the rows it has to find\n            // fast are a shrinking minority of a table that also holds every\n            // success and every dead letter.\n            await ddl.ensureObject(\"Creating idx_jobs_runnable\", `\n                CREATE INDEX IF NOT EXISTS idx_jobs_runnable\n                ON ${TABLE}(run_at, created_at)\n                WHERE status = 'pending'\n            `);\n\n            // Finds jobs stranded by a dead worker.\n            await ddl.ensureObject(\"Creating idx_jobs_running\", `\n                CREATE INDEX IF NOT EXISTS idx_jobs_running\n                ON ${TABLE}(locked_at)\n                WHERE status = 'running'\n            `);\n\n            // What makes `idempotencyKey` a guarantee rather than a\n            // check-then-act race: two instances reacting to one event both\n            // reach the INSERT, and the index decides. Partial on unfinished\n            // work — see `EnqueueOptions.idempotencyKey` for why a key must be\n            // reusable once its job is done.\n            await ddl.ensureObject(\"Creating idx_jobs_idempotency\", `\n                CREATE UNIQUE INDEX IF NOT EXISTS idx_jobs_idempotency\n                ON ${TABLE}(idempotency_key)\n                WHERE idempotency_key IS NOT NULL AND status IN ('pending', 'running')\n            `);\n\n            const ready = await ddl.isReadable(TABLE);\n\n            if (ready) {\n                await ddl.step(\"Job retention sweep\", async () => {\n                    await exec(\n                        `DELETE FROM ${TABLE}\n                         WHERE (status = 'succeeded' AND updated_at < now() - make_interval(days => $1))\n                            OR (status = 'failed'    AND updated_at < now() - make_interval(days => $2))`,\n                        [SUCCEEDED_RETENTION_DAYS, FAILED_RETENTION_DAYS]\n                    );\n                });\n\n                // Payloads are arbitrary application data — a webhook body, a\n                // user id, whatever was passed — and a writable queue lets any\n                // signed-in user schedule work of their choosing under the\n                // server's own authority. Same reasoning, and the same\n                // unconditional re-application, as `cron_claims`.\n                await ddl.step(\"Revoking end-user access to jobs\", () =>\n                    exec(revokeInternalTableSql(\"rebase\", \"jobs\")));\n\n                await ddl.ensureObject(`Creating ${ENQUEUE_FUNCTION}`, `\n                    CREATE OR REPLACE FUNCTION ${ENQUEUE_FUNCTION}(\n                        p_task text, p_payload jsonb, p_run_at timestamptz,\n                        p_max_attempts integer, p_idempotency_key text\n                    ) RETURNS text\n                    LANGUAGE sql\n                    SECURITY DEFINER\n                    SET search_path = pg_catalog, pg_temp\n                    AS $fn$\n                        INSERT INTO ${TABLE} (task, payload, run_at, max_attempts, idempotency_key)\n                        VALUES (p_task, p_payload, p_run_at, p_max_attempts, p_idempotency_key)\n                        ON CONFLICT DO NOTHING\n                        RETURNING id\n                    $fn$\n                `);\n                // Re-applied every boot: a new function is executable by PUBLIC\n                // until told otherwise, and the request role may be provisioned\n                // after the function was first made.\n                await ddl.step(`Granting ${ENQUEUE_FUNCTION} to the request role`, async () => {\n                    await exec(`REVOKE ALL ON FUNCTION ${ENQUEUE_SIGNATURE} FROM PUBLIC`);\n                    await exec(`\n                        DO $grant$ BEGIN\n                            IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = '${REBASE_USER_ROLE}') THEN\n                                GRANT EXECUTE ON FUNCTION ${ENQUEUE_SIGNATURE} TO ${REBASE_USER_ROLE};\n                            END IF;\n                        END $grant$\n                    `);\n                });\n                enqueueInTransaction = firstSqlRow<{ present: boolean }>(await exec(\n                    `SELECT to_regprocedure('${ENQUEUE_SIGNATURE}') IS NOT NULL AS present`\n                ))?.present === true;\n                if (!enqueueInTransaction) {\n                    logger.warn(\n                        `⚠️ [jobs] ${ENQUEUE_FUNCTION} could not be created, so a job enqueued inside a write ` +\n                        \"commits on its own: it stays queued if the write rolls back.\"\n                    );\n                }\n\n                logger.info(\"✅ Job queue table ready\");\n            } else {\n                logger.error(\n                    `❌ [jobs] ${TABLE} is unavailable — nothing can be queued and nothing queued earlier ` +\n                    \"will run. Callers fall back to running the work inline.\"\n                );\n            }\n        },\n\n        async insert(job): Promise<string | null> {\n            const params = [\n                job.task,\n                JSON.stringify(job.payload ?? null),\n                job.runAt.toISOString(),\n                job.maxAttempts,\n                job.idempotencyKey ?? null\n            ];\n            // Inside a write: on its transaction, through the definer function\n            // — see `ENQUEUE_FUNCTION`. Checked and used with no `await`\n            // between, so the transaction cannot close in the gap.\n            const ambient = enqueueInTransaction ? currentAmbientTransaction() : undefined;\n            if (ambient) {\n                const rows = await ambient.exec(\n                    `SELECT ${ENQUEUE_FUNCTION}($1::text, $2::jsonb, $3::timestamptz, $4::integer, $5::text) AS id`,\n                    params\n                );\n                return (rows?.[0]?.id as string | null | undefined) ?? null;\n            }\n            try {\n                const rows = await exec(\n                    `INSERT INTO ${TABLE} (task, payload, run_at, max_attempts, idempotency_key)\n                     VALUES ($1, $2::jsonb, $3, $4, $5)\n                     RETURNING id`,\n                    params\n                );\n                return (rows?.[0]?.id as string) ?? null;\n            } catch (error) {\n                // The losing side of an idempotency race. Not an error: the\n                // work the caller wanted is already queued, which is the\n                // outcome they asked for.\n                if (isUniqueViolation(error)) return null;\n                throw error;\n            }\n        },\n\n        async claim(limit: number, workerId: string, tasks?: readonly string[]): Promise<JobRecord[]> {\n            if (tasks && tasks.length === 0) return [];\n            // One placeholder per task rather than an array parameter: every\n            // driver binds a string, and not every driver binds an array.\n            const taskFilter = tasks\n                ? `AND task IN (${tasks.map((_, i) => `$${i + 3}`).join(\", \")})`\n                : \"\";\n            // `FOR UPDATE SKIP LOCKED` is the whole design. The inner select\n            // takes row locks on the jobs it picks and *skips* any a concurrent\n            // worker already holds, so N workers polling the same table divide\n            // the work instead of contending for the head of it — and no job is\n            // ever handed to two of them.\n            //\n            // `attempts` is incremented here, on claim, rather than on failure.\n            // A worker that is killed mid-job never reports anything, so\n            // counting on failure would let a job that crashes the process be\n            // retried forever, once per restart, taking the process down each\n            // time.\n            const rows = await exec(\n                `UPDATE ${TABLE} SET\n                    status = 'running',\n                    attempts = attempts + 1,\n                    locked_at = now(),\n                    locked_by = $2,\n                    updated_at = now()\n                 WHERE id IN (\n                     SELECT id FROM ${TABLE}\n                     WHERE status = 'pending' AND run_at <= now() ${taskFilter}\n                     ORDER BY run_at, created_at\n                     LIMIT $1\n                     FOR UPDATE SKIP LOCKED\n                 )\n                 RETURNING *`,\n                [limit, workerId, ...(tasks ?? [])]\n            );\n            return sqlRows<JobRow>(rows).map(toRecord);\n        },\n\n        async complete(id: string, claim: JobClaim): Promise<void> {\n            const rows = await exec(\n                `UPDATE ${TABLE} SET status = 'succeeded', locked_at = NULL, locked_by = NULL,\n                        last_error = NULL, updated_at = now()\n                 WHERE ${HELD_BY_CLAIM}\n                 RETURNING id`,\n                [id, claim.workerId, claim.attempt]\n            );\n            if (sqlRows(rows).length === 0) warnStaleOutcome(id, claim, \"success\");\n        },\n\n        async fail(id: string, error: string, retryAt: Date | null, claim: JobClaim): Promise<void> {\n            const rows = retryAt\n                ? await exec(\n                    `UPDATE ${TABLE} SET status = 'pending', run_at = $4, locked_at = NULL,\n                            locked_by = NULL, last_error = $5, updated_at = now()\n                     WHERE ${HELD_BY_CLAIM}\n                     RETURNING id`,\n                    [id, claim.workerId, claim.attempt, retryAt.toISOString(), error]\n                )\n                : await exec(\n                    `UPDATE ${TABLE} SET status = 'failed', locked_at = NULL, locked_by = NULL,\n                            last_error = $4, updated_at = now()\n                     WHERE ${HELD_BY_CLAIM}\n                     RETURNING id`,\n                    [id, claim.workerId, claim.attempt, error]\n                );\n            if (sqlRows(rows).length === 0) warnStaleOutcome(id, claim, \"failure\");\n        },\n\n        async heartbeat(id: string, claim: JobClaim): Promise<boolean> {\n            const rows = await exec(\n                `UPDATE ${TABLE} SET locked_at = now()\n                 WHERE ${HELD_BY_CLAIM}\n                 RETURNING id`,\n                [id, claim.workerId, claim.attempt]\n            );\n            return sqlRows(rows).length > 0;\n        },\n\n        async reapExpired(visibilityTimeoutMs: number): Promise<number> {\n            // A worker killed while holding a job cannot release it, so nothing\n            // but a timeout will ever free the row. Jobs that still have\n            // attempts left go back to `pending`; the rest are dead-lettered\n            // with an error that says what happened, because \"attempts: 3,\n            // lastError: null\" is otherwise a genuinely baffling row to find.\n            const seconds = Math.max(1, Math.round(visibilityTimeoutMs / 1000));\n\n            const revived = await exec(\n                `UPDATE ${TABLE} SET status = 'pending', locked_at = NULL, locked_by = NULL,\n                        last_error = 'Worker stopped responding; the job was reclaimed', updated_at = now()\n                 WHERE status = 'running'\n                   AND locked_at < now() - make_interval(secs => $1)\n                   AND attempts < max_attempts\n                 RETURNING id`,\n                [seconds]\n            );\n\n            const buried = await exec(\n                `UPDATE ${TABLE} SET status = 'failed', locked_at = NULL, locked_by = NULL,\n                        last_error = 'Worker stopped responding on the final attempt', updated_at = now()\n                 WHERE status = 'running'\n                   AND locked_at < now() - make_interval(secs => $1)\n                   AND attempts >= max_attempts\n                 RETURNING id`,\n                [seconds]\n            );\n\n            const count = (revived?.length ?? 0) + (buried?.length ?? 0);\n            if (count > 0) {\n                logger.warn(\n                    `[jobs] Reclaimed ${count} job(s) from a worker that stopped responding ` +\n                    `(${revived?.length ?? 0} retryable, ${buried?.length ?? 0} dead-lettered)`\n                );\n            }\n            return count;\n        },\n\n        async fetch(id: string): Promise<JobRecord | null> {\n            const rows = await exec(`SELECT * FROM ${TABLE} WHERE id = $1`, [id]);\n            const row = firstSqlRow<JobRow>(rows);\n            return row ? toRecord(row) : null;\n        }\n    };\n}\n","export { createJobStore } from \"./job-store\";\nexport type { JobClaim, JobStore } from \"./job-store\";\nexport { createJobQueue, defaultBackoff, PermanentJobError } from \"./job-queue\";\nexport type { JobQueue } from \"./job-queue\";\nexport type {\n    EnqueueOptions,\n    JobContext,\n    JobHandler,\n    JobQueueClient,\n    JobQueueOptions,\n    JobRecord,\n    JobStatus\n} from \"./types\";\n"],"mappings":";;;;;;;;;;;;;;AA0CA,IAAM,gBAAgB,OAAO,IAAI,0CAA0C;;AAc3E,SAAgB,4BAA4D;CACxE,OAAQ,WAA4B,cAAc,GAAG;AACzD;;;;;;;;;;AC7CA,IAAM,sBAAsB;AAC5B,IAAM,2BAA2B;AACjC,IAAM,gCAAgC,IAAI;AAC1C,IAAM,uBAAuB;;AAG7B,SAAgB,eAAe,SAAyB;CACpD,OAAO,KAAK,IAAI,MAAQ,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,UAAU,CAAC,CAAC,GAAG,KAAK,GAAM;AAC9E;;;;;;;;AASA,IAAM,uBAAuB;;;;;;;;AAS7B,IAAa,oBAAb,cAAuC,MAAM;CACzC,YAAY,SAAiB,SAA+B;EACxD,MAAM,SAAS,OAAO;EACtB,KAAK,OAAO;CAChB;AACJ;AAqBA,SAAgB,eAAe,OAAiB,UAA2B,CAAC,GAAa;CACrF,MAAM,cAAc,QAAQ,eAAe;CAC3C,MAAM,iBAAiB,QAAQ,kBAAkB;CACjD,MAAM,sBAAsB,QAAQ,uBAAuB;CAC3D,MAAM,qBAAqB,QAAQ,eAAe;CAClD,MAAM,UAAU,QAAQ,WAAW;CAEnC,MAAM,2BAAW,IAAI,IAA+B;CACpD,KAAK,MAAM,CAAC,MAAM,YAAY,OAAO,QAAQ,QAAQ,SAAS,CAAC,CAAC,GAC5D,SAAS,IAAI,MAAM,OAAO;CAM9B,MAAM,WAAW,GAAG,QAAQ,IAAI,GAAG,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC;CAE1D,IAAI,QAA+B;CACnC,IAAI,YAAmC;CACvC,IAAI,UAAU;;;;;;;CAOd,MAAM,yBAAS,IAAI,IAAmB;;CAEtC,IAAI,WAAoC;;CAExC,IAAI,UAAU;CACd,IAAI,UAAU;CACd,IAAI,WAAiC;;;;;;;CAQrC,SAAS,UAAU,KAAgB,OAA6B;EAC5D,IAAI,CAAC,MAAM,WAAW,aAAa,KAAA;EACnC,MAAM,QAAQ,MAAM,UAAU,KAAK,KAAK;EACxC,MAAM,WAAW,kBAAkB;GAC/B,MAAM,IAAI,IAAI,KAAK,CAAC,CAAC,MAAM,SAAS;IAChC,IAAI,MAAM;IACV,cAAc,QAAQ;IACtB,OAAO,KACH,WAAW,IAAI,KAAK,8BAA8B,MAAM,QAAQ,mDAC5B,EAAE,OAAO,IAAI,GAAG,CACxD;GACJ,CAAC,CAAC,CAAC,OAAO,UAAmB;IACzB,OAAO,KAAK,wCAAwC,IAAI,KAAK,IAAI;KAAE,OAAO,IAAI;KAAI;IAAM,CAAC;GAC7F,CAAC;EACL,GAAG,KAAK,IAAI,GAAG,KAAK,MAAM,sBAAsB,CAAC,CAAC,CAAC;EACnD,SAAS,QAAQ;EACjB,aAAa,cAAc,QAAQ;CACvC;CAEA,eAAe,OAAO,KAA+B;EACjD,MAAM,UAAU,SAAS,IAAI,IAAI,IAAI;EACrC,MAAM,QAAkB;GAAE;GAAU,SAAS,IAAI;EAAS;EAE1D,IAAI,CAAC,SAAS;GAOV,OAAO,KAAK,0CAA0C,IAAI,KAAK,mCAAmC;GAClG,MAAM,MAAM,KACR,IAAI,IACJ,mCAAmC,IAAI,KAAK,IAC5C,IAAI,WAAW,IAAI,cAAc,IAAI,KAAK,KAAK,IAAI,IAAI,QAAQ,IAAI,QAAQ,CAAC,IAAI,MAChF,KACJ;GACA;EACJ;EAEA,MAAM,eAAe,UAAU,KAAK,KAAK;EACzC,IAAI;GACA,IAAI;IACA,MAAM,QAAQ;KACV,IAAI,IAAI;KACR,MAAM,IAAI;KACV,SAAS,IAAI;KACb,SAAS,IAAI;KACb,aAAa,IAAI;IACrB,CAAU;GACd,UAAU;IACN,aAAa;GACjB;GACA,MAAM,MAAM,SAAS,IAAI,IAAI,KAAK;EACtC,SAAS,OAAO;GACZ,MAAM,UAAU,iBAAiB,QAAS,MAAM,SAAS,MAAM,UAAW,OAAO,KAAK;GACtF,MAAM,YAAY,iBAAiB;GACnC,MAAM,YAAY,CAAC,aAAa,IAAI,WAAW,IAAI;GAInD,MAAM,MAAM,KAAK,IAAI,IAAI,QAAQ,MAAM,GAAG,GAAK,GAAG,YAAY,IAAI,KAAK,KAAK,IAAI,IAAI,QAAQ,IAAI,QAAQ,CAAC,IAAI,MAAM,KAAK;GAExH,IAAI,WACA,OAAO,KAAK,WAAW,IAAI,KAAK,sBAAsB,IAAI,SAAS,GAAG,IAAI,YAAY,aAAa,EAAE,OAAO,IAAI,GAAG,CAAC;QACjH,IAAI,WACP,OAAO,MAAM,WAAW,IAAI,KAAK,kCAAkC,IAAI,SAAS,iBAAiB;IAAE,OAAO,IAAI;IAAI,OAAO;GAAQ,CAAC;QAKlI,OAAO,MAAM,WAAW,IAAI,KAAK,6BAA6B,IAAI,SAAS,YAAY;IAAE,OAAO,IAAI;IAAI,OAAO;GAAQ,CAAC;EAEhI;CACJ;;;;;;CAOA,eAAe,OAAsB;EACjC,IAAI,SAAS;EACb,UAAU;EACV,IAAI;GACA,MAAM,MAAM,YAAY,mBAAmB;EAC/C,SAAS,OAAO;GACZ,OAAO,MAAM,yCAAyC,EAAE,MAAM,CAAC;EACnE,UAAU;GACN,UAAU;EACd;CACJ;;CAGA,eAAe,gBAA0C;EACrD,MAAM,OAAO,cAAc,OAAO;EAClC,IAAI,QAAQ,GAAG,OAAO,CAAC;EAOvB,IAAI,SAAS,SAAS,GAAG,OAAO,CAAC;EACjC,MAAM,OAAO,MAAM,MAAM,MAAM,MAAM,UAAU,CAAC,GAAG,SAAS,KAAK,CAAC,CAAC;EACnE,UAAU,KAAK,UAAU;EAEzB,OAAO,KAAK,KAAK,QAAQ;GACrB,MAAM,MAAqB,OAAO,GAAG,CAAC,CACjC,OAAO,UAAU;IAId,OAAO,MAAM,2CAA2C,IAAI,KAAK,IAAI;KAAE,OAAO,IAAI;KAAI;IAAM,CAAC;GACjG,CAAC,CAAC,CACD,cAAc;IACX,OAAO,OAAO,GAAG;IAGjB,IAAI,SAAS,SAAS,CAAC;GAC3B,CAAC;GACL,OAAO,IAAI,GAAG;GACd,OAAO;EACX,CAAC;CACL;CAEA,SAAS,SAAS,SAAuB;EACrC,IAAI,CAAC,SAAS;EACd,IAAI,OAAO,aAAa,KAAK;EAC7B,QAAQ,iBAAiB;GACrB,QAAQ;GACR,KAAU;EACd,GAAG,OAAO;EAGV,MAAM,QAAQ;CAClB;CAEA,eAAe,OAAsB;EAEjC,IAAI,CAAC,WAAW,UAAU;EAC1B,MAAM,OAAO,cAAc,CAAC,CAAC,OAAO,UAAU;GAC1C,OAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC;GAC5C,UAAU;EACd,CAAC;EACD,WAAW;EACX,MAAM;EACN,WAAW;EAKX,SAAS,WAAW,OAAO,OAAO,cAAc,IAAI,cAAc;CACtE;CAEA,eAAe,QAAuB;EAClC,MAAM;EACN,MAAM,QAAQ,WAAW,CAAC,GAAG,MAAM,CAAC;CACxC;CAEA,OAAO;EACH,QAAc;GACV,IAAI,SAAS;GACb,UAAU;GACV,OAAO,KAAK,sCAAsC,YAAY,SAAS,eAAe,IAAI;GAC1F,KAAU;GACV,YAAY,kBAAkB;IAAE,KAAU;GAAG,GAAG,sBAAsB,oBAAoB;GAC1F,UAAU,QAAQ;GAClB,SAAS,CAAC;EACd;EAEA,MAAM,KAAK,WAAmC;GAC1C,UAAU;GACV,IAAI,OAAO;IACP,aAAa,KAAK;IAClB,QAAQ;GACZ;GACA,IAAI,WAAW;IACX,cAAc,SAAS;IACvB,YAAY;GAChB;GAIA,aAAa,MAAM,CAAC,CAAC,cAAc;IAAE,WAAW;GAAM,CAAC;GACvD,IAAI,cAAc,KAAA,GAAW;IACzB,MAAM;IACN;GACJ;GACA,IAAI;GACJ,MAAM,WAAW,MAAM,QAAQ,KAAK,CAChC,SAAS,WAAW,IAAI,GACxB,IAAI,SAAgB,YAAY;IAC5B,SAAS,iBAAiB,QAAQ,KAAK,GAAG,SAAS;IACnD,OAAO,QAAQ;GACnB,CAAC,CACL,CAAC;GACD,aAAa,MAAM;GACnB,IAAI,CAAC,UACD,OAAO,KACH,UAAU,OAAO,KAAK,8BAA8B,UAAU,0GAElE;EAER;EAEA,MAAM,UAA2B;GAC7B,MAAM,UAAU,MAAM,cAAc;GACpC,MAAM,QAAQ,WAAW,OAAO;GAChC,OAAO,QAAQ;EACnB;EAEA,SAAsB,MAAc,SAA8B;GAC9D,IAAI,SAAS,IAAI,IAAI,GACjB,OAAO,KAAK,gBAAgB,KAAK,iDAAiD;GAEtF,SAAS,IAAI,MAAM,OAA4B;EACnD;EAEA,YAAqB;GACjB,OAAO;EACX;EAEA,MAAM,QAAqB,MAAc,SAAa,iBAAiC,CAAC,GAA2B;GAC/G,OAAO,MAAM,OAAO;IAChB;IACA,SAAS,WAAW;IACpB,OAAO,IAAI,KAAK,KAAK,IAAI,KAAK,eAAe,WAAW,EAAE;IAC1D,aAAa,eAAe,eAAe;IAC3C,gBAAgB,eAAe;GACnC,CAAC;EACL;CACJ;AACJ;;;;;;;;;;;ACjUA,IAAM,QAAQ;;AAGd,IAAM,2BAA2B;;;;;;AAMjC,IAAM,wBAAwB;AAgB9B,SAAS,SAAS,KAAwB;CACtC,OAAO;EACH,IAAI,IAAI;EACR,MAAM,IAAI;EACV,SAAS,IAAI;EACb,QAAQ,IAAI;EACZ,OAAO,IAAI,KAAK,IAAI,MAAM,CAAC,CAAC,YAAY;EACxC,UAAU,OAAO,IAAI,QAAQ;EAC7B,aAAa,OAAO,IAAI,YAAY;EACpC,WAAW,IAAI;EACf,WAAW,IAAI,KAAK,IAAI,UAAU,CAAC,CAAC,YAAY;EAChD,WAAW,IAAI,KAAK,IAAI,UAAU,CAAC,CAAC,YAAY;CACpD;AACJ;;AAGA,SAAS,kBAAkB,KAAuB;CAC9C,OAAO,gBAAgB,MAAM,MAAM,EAAE,SAAS,OAAO;AACzD;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAM,mBAAmB;AACzB,IAAM,oBAAoB,GAAG,iBAAiB;;AAwD9C,IAAM,gBAAgB;AAEtB,SAAS,iBAAiB,IAAY,OAAiB,SAAsC;CACzF,OAAO,KACH,sBAAsB,QAAQ,cAAc,MAAM,QAAQ,UAAU,GAAG,yGAE3E;AACJ;AAEA,SAAgB,eAAe,QAA0C;CACrE,MAAM,QAAQ,OAAO;CACrB,IAAI,CAAC,WAAW,KAAK,GAAG;EACpB,OAAO,KACH,+IAEJ;EACA;CACJ;CAKA,MAAM,WAAoB,SAAS,YAC/B,MAAM,WAAW,SAAS,SAAS,SAAS,EAAE,QAAQ,QAAQ,OAAO,IAAI,KAAA,CAAS;CACtF,MAAM,QAAQ,SAAiB,WAC3B,QAAQ,SAAS,SAAS,EAAE,OAAO,IAAI,KAAA,CAAS;CAEpD,MAAM,MAAM,sBAAsB,SAAS,MAAM;;;;;;;CAQjD,IAAI,uBAAuB;CAE3B,OAAO;EACH,MAAM,cAA6B;GAC/B,MAAM,IAAI,aAAa,0BAA0B,oCAAoC;GAErF,MAAM,IAAI,aAAa,YAAY,SAAS;6CACX,MAAM;;;;;;;;;;;;;;;aAetC;GAKD,MAAM,IAAI,aAAa,8BAA8B;;qBAE5C,MAAM;;aAEd;GAGD,MAAM,IAAI,aAAa,6BAA6B;;qBAE3C,MAAM;;aAEd;GAOD,MAAM,IAAI,aAAa,iCAAiC;;qBAE/C,MAAM;;aAEd;GAID,IAAI,MAFgB,IAAI,WAAW,KAAK,GAE7B;IACP,MAAM,IAAI,KAAK,uBAAuB,YAAY;KAC9C,MAAM,KACF,eAAe,MAAM;;2GAGrB,CAAC,0BAA0B,qBAAqB,CACpD;IACJ,CAAC;IAOD,MAAM,IAAI,KAAK,0CACX,KAAK,uBAAuB,UAAU,MAAM,CAAC,CAAC;IAElD,MAAM,IAAI,aAAa,YAAY,oBAAoB;iDACtB,iBAAiB;;;;;;;;sCAQ5B,MAAM;;;;;iBAK3B;IAID,MAAM,IAAI,KAAK,YAAY,iBAAiB,uBAAuB,YAAY;KAC3E,MAAM,KAAK,0BAA0B,kBAAkB,aAAa;KACpE,MAAM,KAAK;;iFAEkD,iBAAiB;4DACtC,kBAAkB,MAAM,iBAAiB;;;qBAGhF;IACL,CAAC;IACD,uBAAuB,YAAkC,MAAM,KAC3D,2BAA2B,kBAAkB,0BACjD,CAAC,CAAC,EAAE,YAAY;IAChB,IAAI,CAAC,sBACD,OAAO,KACH,aAAa,iBAAiB,qHAElC;IAGJ,OAAO,KAAK,yBAAyB;GACzC,OACI,OAAO,MACH,YAAY,MAAM,2HAEtB;EAER;EAEA,MAAM,OAAO,KAA6B;GACtC,MAAM,SAAS;IACX,IAAI;IACJ,KAAK,UAAU,IAAI,WAAW,IAAI;IAClC,IAAI,MAAM,YAAY;IACtB,IAAI;IACJ,IAAI,kBAAkB;GAC1B;GAIA,MAAM,UAAU,uBAAuB,0BAA0B,IAAI,KAAA;GACrE,IAAI,SAKA,QAAQ,MAJW,QAAQ,KACvB,UAAU,iBAAiB,sEAC3B,MACJ,EAAA,GACe,EAAE,EAAE,MAAoC;GAE3D,IAAI;IAOA,QAAQ,MANW,KACf,eAAe,MAAM;;oCAGrB,MACJ,EAAA,GACe,EAAE,EAAE,MAAiB;GACxC,SAAS,OAAO;IAIZ,IAAI,kBAAkB,KAAK,GAAG,OAAO;IACrC,MAAM;GACV;EACJ;EAEA,MAAM,MAAM,OAAe,UAAkB,OAAiD;GAC1F,IAAI,SAAS,MAAM,WAAW,GAAG,OAAO,CAAC;GAGzC,MAAM,aAAa,QACb,gBAAgB,MAAM,KAAK,GAAG,MAAM,IAAI,IAAI,GAAG,CAAC,CAAC,KAAK,IAAI,EAAE,KAC5D;GA6BN,OAAO,QAAgB,MAjBJ,KACf,UAAU,MAAM;;;;;;;sCAOM,MAAM;oEACwB,WAAW;;;;;+BAM/D;IAAC;IAAO;IAAU,GAAI,SAAS,CAAC;GAAE,CACtC,CAC2B,CAAC,CAAC,IAAI,QAAQ;EAC7C;EAEA,MAAM,SAAS,IAAY,OAAgC;GAQvD,IAAI,QAAQ,MAPO,KACf,UAAU,MAAM;;yBAEP,cAAc;gCAEvB;IAAC;IAAI,MAAM;IAAU,MAAM;GAAO,CACtC,CACgB,CAAC,CAAC,WAAW,GAAG,iBAAiB,IAAI,OAAO,SAAS;EACzE;EAEA,MAAM,KAAK,IAAY,OAAe,SAAsB,OAAgC;GAgBxF,IAAI,QAfS,UACP,MAAM,KACJ,UAAU,MAAM;;6BAEP,cAAc;oCAEvB;IAAC;IAAI,MAAM;IAAU,MAAM;IAAS,QAAQ,YAAY;IAAG;GAAK,CACpE,IACE,MAAM,KACJ,UAAU,MAAM;;6BAEP,cAAc;oCAEvB;IAAC;IAAI,MAAM;IAAU,MAAM;IAAS;GAAK,CAC7C,CACY,CAAC,CAAC,WAAW,GAAG,iBAAiB,IAAI,OAAO,SAAS;EACzE;EAEA,MAAM,UAAU,IAAY,OAAmC;GAO3D,OAAO,QAAQ,MANI,KACf,UAAU,MAAM;yBACP,cAAc;gCAEvB;IAAC;IAAI,MAAM;IAAU,MAAM;GAAO,CACtC,CACmB,CAAC,CAAC,SAAS;EAClC;EAEA,MAAM,YAAY,qBAA8C;GAM5D,MAAM,UAAU,KAAK,IAAI,GAAG,KAAK,MAAM,sBAAsB,GAAI,CAAC;GAElE,MAAM,UAAU,MAAM,KAClB,UAAU,MAAM;;;;;gCAMhB,CAAC,OAAO,CACZ;GAEA,MAAM,SAAS,MAAM,KACjB,UAAU,MAAM;;;;;gCAMhB,CAAC,OAAO,CACZ;GAEA,MAAM,SAAS,SAAS,UAAU,MAAM,QAAQ,UAAU;GAC1D,IAAI,QAAQ,GACR,OAAO,KACH,oBAAoB,MAAM,iDACtB,SAAS,UAAU,EAAE,cAAc,QAAQ,UAAU,EAAE,gBAC/D;GAEJ,OAAO;EACX;EAEA,MAAM,MAAM,IAAuC;GAE/C,MAAM,MAAM,YAAoB,MADb,KAAK,iBAAiB,MAAM,iBAAiB,CAAC,EAAE,CAAC,CAChC;GACpC,OAAO,MAAM,SAAS,GAAG,IAAI;EACjC;CACJ;AACJ"}