@pg-boss/dashboard 1.2.1 → 1.3.0

package/build/server/index.js

@@ -347,6 +347,38 @@ var WARNING_TYPE_OPTIONS = [{
 	value: type,
 	label: WARNING_TYPE_LABELS[type]
 }))];
+var BAM_STATUSES = [
+	"pending",
+	"in_progress",
+	"completed",
+	"failed"
+];
+/**
+* Validate a BAM status filter value
+*/
+function isValidBamStatus(value) {
+	if (value === null) return true;
+	return BAM_STATUSES.includes(value);
+}
+var BAM_STATUS_VARIANTS = {
+	pending: "gray",
+	in_progress: "primary",
+	completed: "success",
+	failed: "error"
+};
+var BAM_STATUS_LABELS = {
+	pending: "Pending",
+	in_progress: "In Progress",
+	completed: "Completed",
+	failed: "Failed"
+};
+var BAM_STATUS_OPTIONS = [{
+	value: null,
+	label: "All Statuses"
+}, ...BAM_STATUSES.map((status) => ({
+	value: status,
+	label: BAM_STATUS_LABELS[status]
+}))];
 /**
 * Format warning data for display
 */
@@ -840,6 +872,11 @@ var navigation = [
 		href: "/schedules",
 		icon: SchedulesIcon
 	},
+	{
+		name: "Migrations",
+		href: "/migrations",
+		icon: MigrationsIcon
+	},
 	{
 		name: "Warnings",
 		href: "/warnings",
@@ -916,6 +953,20 @@ function WarningIcon$1({ className }) {
 		})
 	});
 }
+function MigrationsIcon({ className }) {
+	return /* @__PURE__ */ jsx("svg", {
+		className,
+		fill: "none",
+		viewBox: "0 0 24 24",
+		strokeWidth: 1.5,
+		stroke: "currentColor",
+		children: /* @__PURE__ */ jsx("path", {
+			strokeLinecap: "round",
+			strokeLinejoin: "round",
+			d: "M7.5 21 3 16.5m0 0L7.5 12M3 16.5h13.5m0-13.5L21 7.5m0 0L16.5 12M21 7.5H7.5"
+		})
+	});
+}
 function DatabaseIcon({ className }) {
 	return /* @__PURE__ */ jsx("svg", {
 		className,
@@ -1208,11 +1259,11 @@ var dbContext = globalStore[TOKEN_KEY] ??= createContext();
 //#endregion
 //#region app/root.tsx
 var root_exports = /* @__PURE__ */ __exportAll({
-	ErrorBoundary: () => ErrorBoundary$11,
+	ErrorBoundary: () => ErrorBoundary$12,
 	Layout: () => Layout,
 	default: () => root_default,
 	links: () => links,
-	loader: () => loader$11,
+	loader: () => loader$12,
 	meta: () => meta
 });
 function MainContent({ children }) {
@@ -1288,7 +1339,7 @@ var themeScript = `
     link.href = 'data:image/svg+xml,' + encodeURIComponent(svg);
   })();
 `;
-async function loader$11({ context }) {
+async function loader$12({ context }) {
 	const { databases, currentDb } = context.get(dbContext);
 	return {
 		databases,
@@ -1321,7 +1372,7 @@ function Layout({ children }) {
 var root_default = UNSAFE_withComponentProps(function App() {
 	return /* @__PURE__ */ jsx(Outlet, {});
 });
-var ErrorBoundary$11 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary({ error }) {
+var ErrorBoundary$12 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary({ error }) {
 	let message = "Oops!";
 	let details = "An unexpected error occurred.";
 	let stack;
@@ -1538,10 +1589,13 @@ function createTableQueue(schema) {
       table_name text NOT NULL,
       deferred_count int NOT NULL default 0,
       queued_count int NOT NULL default 0,
+      ready_count int NOT NULL default 0,
       warning_queued int NOT NULL default 0,
       active_count int NOT NULL default 0,
+      failed_count int NOT NULL default 0,
       total_count int NOT NULL default 0,
       heartbeat_seconds int,
+      notify bool NOT NULL DEFAULT false,
       singletons_active text[],
       monitor_on timestamp with time zone,
       maintain_on timestamp with time zone,
@@ -1878,7 +1932,8 @@ function createQueueFunction(schema, noPartitioning = false) {
           dead_letter,
           partition,
           table_name,
-          heartbeat_seconds
+          heartbeat_seconds,
+          notify
         )
         VALUES (
           queue_name,
@@ -1894,7 +1949,8 @@ function createQueueFunction(schema, noPartitioning = false) {
           options->>'deadLetter',
           COALESCE((options->>'partition')::bool, ${QUEUE_DEFAULTS.partition}),
           tablename,
-          (options->>'heartbeatSeconds')::int
+          (options->>'heartbeatSeconds')::int,
+          COALESCE((options->>'notify')::bool, false)
         )
         ON CONFLICT DO NOTHING
         RETURNING created_on
@@ -1966,6 +2022,12 @@ function deleteQueueFunction(schema, noPartitioning = false) {
 function createQueue$1(schema, name, options, noAdvisoryLocks) {
 	return locked(schema, `SELECT ${schema}.create_queue('${name}', '${JSON.stringify(options)}'::jsonb)`, "create-queue", noAdvisoryLocks);
 }
+function notifyChannelSql(schema) {
+	return `('pgboss_' || left(encode(sha224('${schema}'::bytea), 'hex'), 24))`;
+}
+function notifyQueue(schema, name) {
+	return `SELECT pg_notify(${notifyChannelSql(schema)}, '${name}')`;
+}
 function deleteQueue(schema, name, noAdvisoryLocks) {
 	return locked(schema, `SELECT ${schema}.delete_queue('${name}')`, "delete-queue", noAdvisoryLocks);
 }
@@ -2054,6 +2116,7 @@ function updateQueue(schema, { deadLetter } = {}) {
       heartbeat_seconds = CASE WHEN o.data ? 'heartbeatSeconds'
         THEN (o.data->>'heartbeatSeconds')::int
         ELSE heartbeat_seconds END,
+      notify = COALESCE((o.data->>'notify')::bool, notify),
       ${deadLetter === void 0 ? "" : `dead_letter = CASE WHEN '${deadLetter}' IS DISTINCT FROM dead_letter THEN '${deadLetter}' ELSE dead_letter END,`}
       updated_on = now()
     FROM options o
@@ -2076,11 +2139,14 @@ function getQueues$1(schema, names) {
       q.deletion_seconds as "deleteAfterSeconds",
       q.partition,
       q.heartbeat_seconds as "heartbeatSeconds",
+      q.notify,
       q.dead_letter as "deadLetter",
       q.deferred_count as "deferredCount",
       q.warning_queued as "warningQueueSize",
       q.queued_count as "queuedCount",
+      q.ready_count as "readyCount",
       q.active_count as "activeCount",
+      q.failed_count as "failedCount",
       q.total_count as "totalCount",
       q.singletons_active as "singletonsActive",
       q.table_name as "table",
@@ -2404,6 +2470,54 @@ function completeJobs(schema, table, includeQueued) {
     SELECT COUNT(*) FROM completed
   `;
 }
+function completeJobsWithOutputs(schema, table) {
+	return `
+    WITH input AS (
+      SELECT * FROM json_to_recordset($2::json) AS x (id uuid, output jsonb)
+    ),
+    completed AS (
+      UPDATE ${schema}.${table} j
+      SET completed_on = now(),
+        state = '${JOB_STATES.completed}',
+        output = i.output
+      FROM input i
+      WHERE j.name = $1
+        AND j.id = i.id
+        AND j.state = '${JOB_STATES.active}'
+      RETURNING j.name, j.id, j.blocking
+    ),
+    decremented AS (
+      SELECT d.child_name, d.child_id, COUNT(*)::int AS n
+      FROM ${schema}.job_dependency d
+      JOIN completed c ON c.blocking
+        AND d.parent_name = c.name
+        AND d.parent_id = c.id
+      GROUP BY d.child_name, d.child_id
+    ),
+    ${lockedChildrenCte(schema)},
+    unblocked AS (
+      ${unblockChildrenUpdate(schema)}
+      RETURNING 1
+    )
+    SELECT COUNT(*) FROM completed
+  `;
+}
+function completeJobsWithOutputsDistributed(schema, table) {
+	return `
+    WITH input AS (
+      SELECT * FROM json_to_recordset($2::json) AS x (id uuid, output jsonb)
+    )
+    UPDATE ${schema}.${table} j
+    SET completed_on = now(),
+      state = '${JOB_STATES.completed}',
+      output = i.output
+    FROM input i
+    WHERE j.name = $1
+      AND j.id = i.id
+      AND j.state = '${JOB_STATES.active}'
+    RETURNING j.id, j.blocking
+  `;
+}
 function cancelJobs(schema, table) {
 	return `
     WITH results as (
@@ -2442,8 +2556,8 @@ function restoreJobs(schema, table) {
       AND id IN (SELECT UNNEST($2::uuid[]))
   `;
 }
-function insertJobs(schema, { table, name, returnId = true }) {
-	return `
+function insertJobs(schema, { table, name, returnId = true, notify = false }) {
+	const insert = `
     INSERT INTO ${schema}.${table} (
       id,
       name,
@@ -2526,7 +2640,31 @@ function insertJobs(schema, { table, name, returnId = true }) {
     ) j
     JOIN ${schema}.queue q ON q.name = '${name}'
     ON CONFLICT DO NOTHING
-    ${returnId ? "RETURNING id" : ""}
+    ${notify ? "RETURNING id, start_after" : returnId ? "RETURNING id" : ""}
+  `;
+	if (!notify) return insert;
+	const comparator = returnId ? ">= 0" : "< 0";
+	return `
+    WITH ins AS (
+      ${insert}
+    ),
+    notified AS (
+      SELECT pg_notify(${notifyChannelSql(schema)}, '${name}')
+      FROM ins WHERE start_after <= now() LIMIT 1
+    )
+    SELECT id FROM ins WHERE (SELECT count(*) FROM notified) ${comparator}
+  `;
+}
+function insertFlowJobs(schema, { table, name }, jobs) {
+	return `
+    WITH ins AS (
+      ${insertJobs(schema, {
+		table,
+		name,
+		returnId: true
+	}).replace("$1", () => serializeJsonParam(jobs))}
+    )
+    SELECT 1 / (CASE WHEN (SELECT count(*) FROM ins) = ${jobs.length} THEN 1 ELSE 0 END)
   `;
 }
 function failJobsById(schema, table) {
@@ -2558,7 +2696,12 @@ function touchJobs(schema, table) {
 }
 function failJobs(schema, table, where, output) {
 	return `
-    WITH deleted_jobs AS (
+    WITH ${failJobsBody(schema, table, where, output)}
+    SELECT COUNT(*) FROM results
+  `;
+}
+function failJobsBody(schema, table, where, output, forceTerminal = false) {
+	return `deleted_jobs AS (
       DELETE FROM ${schema}.${table}
       WHERE ${where}
       RETURNING *
@@ -2600,10 +2743,10 @@ function failJobs(schema, table, where, output) {
         name,
         priority,
         data,
-        CASE
+        ${forceTerminal ? `'${JOB_STATES.failed}'::${schema}.job_state` : `CASE
           WHEN retry_count < retry_limit THEN '${JOB_STATES.retry}'::${schema}.job_state
           ELSE '${JOB_STATES.failed}'::${schema}.job_state
-          END as state,
+          END`} as state,
         retry_limit,
         retry_count,
         retry_delay,
@@ -2627,7 +2770,7 @@ function failJobs(schema, table, where, output) {
         expire_seconds,
         deletion_seconds,
         created_on,
-        CASE WHEN retry_count < retry_limit THEN NULL ELSE now() END as completed_on,
+        ${forceTerminal ? "now()" : "CASE WHEN retry_count < retry_limit THEN NULL ELSE now() END"} as completed_on,
         keep_until,
         policy,
         ${output},
@@ -2726,7 +2869,23 @@ function failJobs(schema, table, where, output) {
       FROM results r
         JOIN ${schema}.queue q ON q.name = r.dead_letter
       WHERE state = '${JOB_STATES.failed}'
-    )
+    )`;
+}
+function failJobsByIdWithOutputs(schema, table) {
+	return `
+    WITH output_map AS (
+      SELECT * FROM json_to_recordset($2::json) AS x (id uuid, output jsonb)
+    ),
+    ${failJobsBody(schema, table, `name = $1 AND id IN (SELECT id FROM output_map) AND state < '${JOB_STATES.completed}'`, "(SELECT om.output FROM output_map om WHERE om.id = deleted_jobs.id)")}
+    SELECT COUNT(*) FROM results
+  `;
+}
+function deadLetterJobsByIdWithOutputs(schema, table) {
+	return `
+    WITH output_map AS (
+      SELECT * FROM json_to_recordset($2::json) AS x (id uuid, output jsonb)
+    ),
+    ${failJobsBody(schema, table, `name = $1 AND id IN (SELECT id FROM output_map) AND state < '${JOB_STATES.completed}'`, "(SELECT om.output FROM output_map om WHERE om.id = deleted_jobs.id)", true)}
     SELECT COUNT(*) FROM results
   `;
 }
@@ -2839,14 +2998,26 @@ function getQueueStats$1(schema, table, queues) {
 		text: `
     SELECT
         name,
-        (count(*) FILTER (WHERE start_after > now()))::int as "deferredCount",
-        (count(*) FILTER (WHERE state < '${JOB_STATES.active}'))::int as "queuedCount",
-        (count(*) FILTER (WHERE state = '${JOB_STATES.active}'))::int as "activeCount",
-        count(*)::int as "totalCount",
-        array_agg(singleton_key) FILTER (WHERE policy IN ('${QUEUE_POLICIES.singleton}','${QUEUE_POLICIES.stately}') AND state = '${JOB_STATES.active}') as "singletonsActive"
-      FROM ${schema}.${table}
-      WHERE name = ANY($1::text[])
-      GROUP BY 1
+        "deferredCount",
+        "queuedCount",
+        GREATEST("queuedCount" - "deferredCount", 0) as "readyCount",
+        "activeCount",
+        "failedCount",
+        "totalCount",
+        "singletonsActive"
+      FROM (
+        SELECT
+            name,
+            (count(*) FILTER (WHERE start_after > now()))::int as "deferredCount",
+            (count(*) FILTER (WHERE state < '${JOB_STATES.active}'))::int as "queuedCount",
+            (count(*) FILTER (WHERE state = '${JOB_STATES.active}'))::int as "activeCount",
+            (count(*) FILTER (WHERE state = '${JOB_STATES.failed}'))::int as "failedCount",
+            count(*)::int as "totalCount",
+            array_agg(singleton_key) FILTER (WHERE policy IN ('${QUEUE_POLICIES.singleton}','${QUEUE_POLICIES.stately}') AND state = '${JOB_STATES.active}') as "singletonsActive"
+          FROM ${schema}.${table}
+          WHERE name = ANY($1::text[])
+          GROUP BY 1
+      ) stats
   `,
 		values: [queues]
 	};
@@ -2857,7 +3028,9 @@ function cacheQueueStats(schema, table, queues, noAdvisoryLocks) {
     UPDATE ${schema}.queue SET
       deferred_count = COALESCE(stats."deferredCount", 0),
       queued_count = COALESCE(stats."queuedCount", 0),
+      ready_count = COALESCE(stats."readyCount", 0),
       active_count = COALESCE(stats."activeCount", 0),
+      failed_count = COALESCE(stats."failedCount", 0),
       total_count = COALESCE(stats."totalCount", 0),
       singletons_active = stats."singletonsActive"
     FROM (
@@ -2931,8 +3104,8 @@ function getJobById$1(schema, table) {
       AND id = $2
     `;
 }
-function insertDependencies(schema) {
-	return `
+function insertDependencies(schema, deps) {
+	const sql = `
     INSERT INTO ${schema}.job_dependency (child_name, child_id, parent_name, parent_id)
     SELECT child_name, child_id, parent_name, parent_id
     FROM json_to_recordset($1::json) AS x (
@@ -2943,6 +3116,7 @@ function insertDependencies(schema) {
     )
     ON CONFLICT DO NOTHING
   `;
+	return deps ? sql.replace("$1", () => serializeJsonParam(deps)) : sql;
 }
 function getDependencies(schema) {
 	return `
@@ -3018,7 +3192,7 @@ function getBamStatus(schema) {
     GROUP BY status
   `;
 }
-function getBamEntries(schema) {
+function getBamEntries$1(schema) {
 	return `
     SELECT id, name, version, status, queue, table_name as "table", command, error,
            created_on as "createdOn", started_on as "startedOn", completed_on as "completedOn"
@@ -3039,7 +3213,8 @@ var COMPATIBILITY_FLAGS = [
 	"noTablePartitioning",
 	"noDeferrableConstraints",
 	"noAdvisoryLocks",
-	"noCoveringIndexes"
+	"noCoveringIndexes",
+	"noListenNotify"
 ];
 var BACKEND_PROFILES = {
 	postgres: {
@@ -3054,7 +3229,8 @@ var BACKEND_PROFILES = {
 			noTablePartitioning: true,
 			noDeferrableConstraints: true,
 			noAdvisoryLocks: true,
-			noCoveringIndexes: true
+			noCoveringIndexes: true,
+			noListenNotify: true
 		}
 	},
 	yugabytedb: {
@@ -3078,6 +3254,7 @@ function assertObjectName(value, name = "Name") {
 }
 function validateQueueArgs(config = {}) {
 	assert(!("deadLetter" in config) || config.deadLetter === null || typeof config.deadLetter === "string", "deadLetter must be a string");
+	assert(!("notify" in config) || typeof config.notify === "boolean", "notify must be a boolean");
 	if (config.deadLetter) assertObjectName(config.deadLetter, "deadLetter");
 	validateRetryConfig(config);
 	validateExpirationConfig(config);
@@ -3257,6 +3434,7 @@ function checkWorkArgs(name, args) {
 	assert(!("includeMetadata" in options) || typeof options.includeMetadata === "boolean", "includeMetadata must be a boolean");
 	assert(!("priority" in options) || typeof options.priority === "boolean", "priority must be a boolean");
 	assert(!("localConcurrency" in options) || Number.isInteger(options.localConcurrency) && options.localConcurrency >= 1, "localConcurrency must be an integer >= 1");
+	assert(!("perJobResults" in options) || typeof options.perJobResults === "boolean", "perJobResults must be a boolean");
 	validatePriorityRangeConfig(options);
 	validateGroupConcurrencyConfig(options);
 	validateHeartbeatRefreshConfig(options);
@@ -3280,6 +3458,7 @@ function getConfig(value) {
 	config.supervise = "supervise" in config ? config.supervise : true;
 	config.migrate = "migrate" in config ? config.migrate : true;
 	config.createSchema = "createSchema" in config ? config.createSchema : true;
+	config.useListenNotify = "useListenNotify" in config ? config.useListenNotify : false;
 	resolveBackend(config);
 	applySchemaConfig(config);
 	applyOpsConfig(config);
@@ -3349,6 +3528,13 @@ function validateHeartbeatRefreshConfig(config) {
 function applyPollingInterval(config) {
 	assert(!("pollingIntervalSeconds" in config) || config.pollingIntervalSeconds >= POLICY.MIN_POLLING_INTERVAL_MS / 1e3, `configuration assert: pollingIntervalSeconds must be at least every ${POLICY.MIN_POLLING_INTERVAL_MS}ms`);
 	config.pollingInterval = "pollingIntervalSeconds" in config ? config.pollingIntervalSeconds * 1e3 : 2e3;
+	assert(!("notifyPollingIntervalSeconds" in config) || config.notifyPollingIntervalSeconds >= POLICY.MIN_POLLING_INTERVAL_MS / 1e3, `configuration assert: notifyPollingIntervalSeconds must be at least every ${POLICY.MIN_POLLING_INTERVAL_MS}ms`);
+	if ("notifyPollingIntervalSeconds" in config) {
+		config.notifyPollingInterval = config.notifyPollingIntervalSeconds * 1e3;
+		assert(config.notifyPollingInterval >= config.pollingInterval, "configuration assert: notifyPollingIntervalSeconds must be at least pollingIntervalSeconds");
+	} else config.notifyPollingInterval = Math.max(3e4, config.pollingInterval);
+	assert(!("burstWhenReadyExceeds" in config) || Number.isInteger(config.burstWhenReadyExceeds) && config.burstWhenReadyExceeds >= 1, "configuration assert: burstWhenReadyExceeds must be an integer >= 1");
+	assert(!("burstWhenBatchFull" in config) || typeof config.burstWhenBatchFull === "boolean", "configuration assert: burstWhenBatchFull must be a boolean");
 }
 function applyOpsConfig(config) {
 	assert(!("superviseIntervalSeconds" in config) || config.superviseIntervalSeconds >= 1, "configuration assert: superviseIntervalSeconds must be at least every second");
@@ -3382,6 +3568,21 @@ function applyBamConfig(config) {
 }
 //#endregion
 //#region ../../src/migrationStore.ts
+function formatJobTable(command, table) {
+	return command.replaceAll(".job", `.${table}`).replaceAll("job_i", `${table}_i`);
+}
+function inlineAsyncCommand(schema, asyncCommand, version, partitionTables) {
+	const nameMatch = asyncCommand.match(/job_table_run_async\(\s*'([^']+)'/);
+	const bodyMatch = asyncCommand.match(/\$\$([\s\S]*?)\$\$/);
+	const tableMatch = asyncCommand.match(/\$\$\s*,\s*'([^']+)'/);
+	assert(nameMatch && bodyMatch, `Unable to inline async migration command: ${asyncCommand}`);
+	const commandName = nameMatch[1];
+	const body = bodyMatch[1].trim();
+	return (tableMatch ? [tableMatch[1]] : ["job_common", ...partitionTables]).map((table) => {
+		const ddl = formatJobTable(body, table).replace(/(CREATE (?:UNIQUE )?INDEX CONCURRENTLY) /, "$1 IF NOT EXISTS ");
+		return `${`-- inlined from ${schema}.job_table_run_async (migration v${version}, command: ${commandName})`}\n${ddl}`;
+	});
+}
 function flatten(schema, commands, version, noAdvisoryLocks) {
 	commands.unshift(assertMigration(schema, version));
 	commands.push(setVersion(schema, version));
@@ -3399,11 +3600,13 @@ function next(schema, version, migrations, noAdvisoryLocks) {
 	assert(result, `Version ${version} not found.`);
 	return flatten(schema, result.install, result.version, noAdvisoryLocks);
 }
-function migrate(schema, version, migrations, noAdvisoryLocks) {
+function migrateCommands(schema, version, migrations, noAdvisoryLocks, options = {}) {
 	migrations = migrations || getAll(schema);
+	const concurrent = [];
 	const result = migrations.filter((i) => i.previous >= version).sort((a, b) => a.version - b.version).reduce((acc, migration) => {
 		acc.install = acc.install.concat(migration.install);
-		if (migration.async) {
+		if (migration.async) if (options.inlineAsync) for (const cmd of migration.async) concurrent.push(...inlineAsyncCommand(schema, cmd, migration.version, options.partitionTables || []));
+		else {
 			const bamCommands = migration.async.map((cmd) => cmd.replace(/\$VERSION\$/g, String(migration.version)));
 			acc.install = acc.install.concat(bamCommands);
 		}
@@ -3414,156 +3617,576 @@ function migrate(schema, version, migrations, noAdvisoryLocks) {
 		version
 	});
 	assert(result.install.length > 0, `Version ${version} not found.`);
-	return flatten(schema, result.install, result.version, noAdvisoryLocks);
+	return {
+		sql: flatten(schema, result.install, result.version, noAdvisoryLocks),
+		concurrent
+	};
 }
-function getAll(schema) {
-	return [
-		{
-			release: "11.1.0",
-			version: 26,
-			previous: 25,
-			install: [`
-        CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
-        RETURNS VOID AS
-        $$
-        DECLARE
-          tablename varchar := CASE WHEN options->>'partition' = 'true'
-                                THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
-                                ELSE 'job_common'
-                                END;
-          queue_created_on timestamptz;
-        BEGIN
+function migrate(schema, version, migrations, noAdvisoryLocks, options = {}) {
+	const { sql, concurrent } = migrateCommands(schema, version, migrations, noAdvisoryLocks, options);
+	return concurrent.length ? `${sql}\n${concurrent.join(";\n")};` : sql;
+}
+var createQueueFn = {
+	26: (schema) => `
+    CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
+    RETURNS VOID AS
+    $$
+    DECLARE
+      tablename varchar := CASE WHEN options->>'partition' = 'true'
+                            THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
+                            ELSE 'job_common'
+                            END;
+      queue_created_on timestamptz;
+    BEGIN
 
-          WITH q as (
-            INSERT INTO ${schema}.queue (
-              name,
-              policy,
-              retry_limit,
-              retry_delay,
-              retry_backoff,
-              retry_delay_max,
-              expire_seconds,
-              retention_seconds,
-              deletion_seconds,
-              warning_queued,
-              dead_letter,
-              partition,
-              table_name
-            )
-            VALUES (
-              queue_name,
-              options->>'policy',
-              COALESCE((options->>'retryLimit')::int, 2),
-              COALESCE((options->>'retryDelay')::int, 0),
-              COALESCE((options->>'retryBackoff')::bool, false),
-              (options->>'retryDelayMax')::int,
-              COALESCE((options->>'expireInSeconds')::int, 900),
-              COALESCE((options->>'retentionSeconds')::int, 1209600),
-              COALESCE((options->>'deleteAfterSeconds')::int, 604800),
-              COALESCE((options->>'warningQueueSize')::int, 0),
-              options->>'deadLetter',
-              COALESCE((options->>'partition')::bool, false),
-              tablename
-            )
-            ON CONFLICT DO NOTHING
-            RETURNING created_on
-          )
-          SELECT created_on into queue_created_on from q;
+      WITH q as (
+        INSERT INTO ${schema}.queue (
+          name,
+          policy,
+          retry_limit,
+          retry_delay,
+          retry_backoff,
+          retry_delay_max,
+          expire_seconds,
+          retention_seconds,
+          deletion_seconds,
+          warning_queued,
+          dead_letter,
+          partition,
+          table_name
+        )
+        VALUES (
+          queue_name,
+          options->>'policy',
+          COALESCE((options->>'retryLimit')::int, 2),
+          COALESCE((options->>'retryDelay')::int, 0),
+          COALESCE((options->>'retryBackoff')::bool, false),
+          (options->>'retryDelayMax')::int,
+          COALESCE((options->>'expireInSeconds')::int, 900),
+          COALESCE((options->>'retentionSeconds')::int, 1209600),
+          COALESCE((options->>'deleteAfterSeconds')::int, 604800),
+          COALESCE((options->>'warningQueueSize')::int, 0),
+          options->>'deadLetter',
+          COALESCE((options->>'partition')::bool, false),
+          tablename
+        )
+        ON CONFLICT DO NOTHING
+        RETURNING created_on
+      )
+      SELECT created_on into queue_created_on from q;
 
-          IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
-            RETURN;
-          END IF;
+      IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
+        RETURN;
+      END IF;
 
-          EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
+      EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
 
-          EXECUTE format('ALTER TABLE ${schema}.%1$I ADD PRIMARY KEY (name, id)', tablename);
-          EXECUTE format('ALTER TABLE ${schema}.%1$I ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED', tablename);
-          EXECUTE format('ALTER TABLE ${schema}.%1$I ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED', tablename);
+      EXECUTE format('ALTER TABLE ${schema}.%1$I ADD PRIMARY KEY (name, id)', tablename);
+      EXECUTE format('ALTER TABLE ${schema}.%1$I ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED', tablename);
+      EXECUTE format('ALTER TABLE ${schema}.%1$I ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED', tablename);
 
-          EXECUTE format('CREATE INDEX %1$s_i5 ON ${schema}.%1$I (name, start_after) INCLUDE (priority, created_on, id) WHERE state < ''active''', tablename);
-          EXECUTE format('CREATE UNIQUE INDEX %1$s_i4 ON ${schema}.%1$I (name, singleton_on, COALESCE(singleton_key, '''')) WHERE state <> ''cancelled'' AND singleton_on IS NOT NULL', tablename);
+      EXECUTE format('CREATE INDEX %1$s_i5 ON ${schema}.%1$I (name, start_after) INCLUDE (priority, created_on, id) WHERE state < ''active''', tablename);
+      EXECUTE format('CREATE UNIQUE INDEX %1$s_i4 ON ${schema}.%1$I (name, singleton_on, COALESCE(singleton_key, '''')) WHERE state <> ''cancelled'' AND singleton_on IS NOT NULL', tablename);
 
-          IF options->>'policy' = 'short' THEN
-            EXECUTE format('CREATE UNIQUE INDEX %1$s_i1 ON ${schema}.%1$I (name, COALESCE(singleton_key, '''')) WHERE state = ''created'' AND policy = ''short''', tablename);
-          ELSIF options->>'policy' = 'singleton' THEN
-            EXECUTE format('CREATE UNIQUE INDEX %1$s_i2 ON ${schema}.%1$I (name, COALESCE(singleton_key, '''')) WHERE state = ''active'' AND policy = ''singleton''', tablename);
-          ELSIF options->>'policy' = 'stately' THEN
-            EXECUTE format('CREATE UNIQUE INDEX %1$s_i3 ON ${schema}.%1$I (name, state, COALESCE(singleton_key, '''')) WHERE state <= ''active'' AND policy = ''stately''', tablename);
-          ELSIF options->>'policy' = 'exclusive' THEN
-            EXECUTE format('CREATE UNIQUE INDEX %1$s_i6 ON ${schema}.%1$I (name, COALESCE(singleton_key, '''')) WHERE state <= ''active'' AND policy = ''exclusive''', tablename);
-          END IF;
+      IF options->>'policy' = 'short' THEN
+        EXECUTE format('CREATE UNIQUE INDEX %1$s_i1 ON ${schema}.%1$I (name, COALESCE(singleton_key, '''')) WHERE state = ''created'' AND policy = ''short''', tablename);
+      ELSIF options->>'policy' = 'singleton' THEN
+        EXECUTE format('CREATE UNIQUE INDEX %1$s_i2 ON ${schema}.%1$I (name, COALESCE(singleton_key, '''')) WHERE state = ''active'' AND policy = ''singleton''', tablename);
+      ELSIF options->>'policy' = 'stately' THEN
+        EXECUTE format('CREATE UNIQUE INDEX %1$s_i3 ON ${schema}.%1$I (name, state, COALESCE(singleton_key, '''')) WHERE state <= ''active'' AND policy = ''stately''', tablename);
+      ELSIF options->>'policy' = 'exclusive' THEN
+        EXECUTE format('CREATE UNIQUE INDEX %1$s_i6 ON ${schema}.%1$I (name, COALESCE(singleton_key, '''')) WHERE state <= ''active'' AND policy = ''exclusive''', tablename);
+      END IF;
 
-          EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
-          EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
-        END;
-        $$
-        LANGUAGE plpgsql;
-        `, `CREATE UNIQUE INDEX job_i6 ON ${schema}.job_common (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'`],
-			uninstall: [`DROP INDEX ${schema}.job_i6`]
-		},
-		{
-			release: "12.6.0",
-			version: 27,
-			previous: 26,
-			install: [
-				`ALTER TABLE ${schema}.version ADD COLUMN IF NOT EXISTS bam_on timestamp with time zone`,
-				`
-        CREATE TABLE IF NOT EXISTS ${schema}.bam (
-          id uuid PRIMARY KEY default gen_random_uuid(),
-          name text NOT NULL,
-          version int NOT NULL,
-          status text NOT NULL DEFAULT 'pending',
-          queue text,
-          table_name text NOT NULL,
-          command text NOT NULL,
-          error text,
-          created_on timestamp with time zone NOT NULL DEFAULT now(),
-          started_on timestamp with time zone,
-          completed_on timestamp with time zone
+      EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
+      EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
+    END;
+    $$
+    LANGUAGE plpgsql;
+  `,
+	27: (schema) => `
+    CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
+    RETURNS VOID AS
+    $$
+    DECLARE
+      tablename varchar := CASE WHEN options->>'partition' = 'true'
+                            THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
+                            ELSE 'job_common'
+                            END;
+      queue_created_on timestamptz;
+    BEGIN
+
+      WITH q as (
+        INSERT INTO ${schema}.queue (
+          name,
+          policy,
+          retry_limit,
+          retry_delay,
+          retry_backoff,
+          retry_delay_max,
+          expire_seconds,
+          retention_seconds,
+          deletion_seconds,
+          warning_queued,
+          dead_letter,
+          partition,
+          table_name
         )
-        `,
-				`CREATE FUNCTION ${schema}.job_table_format(command text, table_name text)
-          RETURNS text AS
-          $$
-            SELECT format(
-              replace(
-                replace(command, '.job', '.%1$I'),
-                'job_i', '%1$s_i'
-              ),
-              table_name
-            );
-          $$
-          LANGUAGE sql IMMUTABLE;
-        `,
-				`
-        CREATE OR REPLACE FUNCTION ${schema}.job_table_run_async(command_name text, version int, command text, tbl_name text DEFAULT NULL, queue_name text DEFAULT NULL)
-        RETURNS VOID AS
-        $$
-        BEGIN
-          IF queue_name IS NOT NULL THEN
-            SELECT table_name INTO tbl_name FROM ${schema}.queue WHERE name = queue_name;
-          END IF;
+        VALUES (
+          queue_name,
+          options->>'policy',
+          COALESCE((options->>'retryLimit')::int, 2),
+          COALESCE((options->>'retryDelay')::int, 0),
+          COALESCE((options->>'retryBackoff')::bool, false),
+          (options->>'retryDelayMax')::int,
+          COALESCE((options->>'expireInSeconds')::int, 900),
+          COALESCE((options->>'retentionSeconds')::int, 1209600),
+          COALESCE((options->>'deleteAfterSeconds')::int, 604800),
+          COALESCE((options->>'warningQueueSize')::int, 0),
+          options->>'deadLetter',
+          COALESCE((options->>'partition')::bool, false),
+          tablename
+        )
+        ON CONFLICT DO NOTHING
+        RETURNING created_on
+      )
+      SELECT created_on into queue_created_on from q;
 
-          IF tbl_name IS NOT NULL THEN
-            INSERT INTO ${schema}.bam (name, version, status, queue, table_name, command)
-            VALUES (
-              command_name,
-              version,
-              'pending',
-              queue_name,
-              tbl_name,
-              ${schema}.job_table_format(command, tbl_name)
-            );
-            RETURN;
-          END IF;
+      IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
+        RETURN;
+      END IF;
 
-          INSERT INTO ${schema}.bam (name, version, status, queue, table_name, command)
-          SELECT
-            command_name,
-            version,
-            'pending',
-            NULL,
-            'job_common',
+      EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
+
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+
+      EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active'$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
+
+      IF options->>'policy' = 'short' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
+      ELSIF options->>'policy' = 'singleton' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
+      ELSIF options->>'policy' = 'stately' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
+      ELSIF options->>'policy' = 'exclusive' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
+      END IF;
+
+      EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
+      EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
+    END;
+    $$
+    LANGUAGE plpgsql;
+  `,
+	28: (schema) => `
+    CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
+    RETURNS VOID AS
+    $$
+    DECLARE
+      tablename varchar := CASE WHEN options->>'partition' = 'true'
+                            THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
+                            ELSE 'job_common'
+                            END;
+      queue_created_on timestamptz;
+    BEGIN
+
+      WITH q as (
+        INSERT INTO ${schema}.queue (
+          name,
+          policy,
+          retry_limit,
+          retry_delay,
+          retry_backoff,
+          retry_delay_max,
+          expire_seconds,
+          retention_seconds,
+          deletion_seconds,
+          warning_queued,
+          dead_letter,
+          partition,
+          table_name
+        )
+        VALUES (
+          queue_name,
+          options->>'policy',
+          COALESCE((options->>'retryLimit')::int, 2),
+          COALESCE((options->>'retryDelay')::int, 0),
+          COALESCE((options->>'retryBackoff')::bool, false),
+          (options->>'retryDelayMax')::int,
+          COALESCE((options->>'expireInSeconds')::int, 900),
+          COALESCE((options->>'retentionSeconds')::int, 1209600),
+          COALESCE((options->>'deleteAfterSeconds')::int, 604800),
+          COALESCE((options->>'warningQueueSize')::int, 0),
+          options->>'deadLetter',
+          COALESCE((options->>'partition')::bool, false),
+          tablename
+        )
+        ON CONFLICT DO NOTHING
+        RETURNING created_on
+      )
+      SELECT created_on into queue_created_on from q;
+
+      IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
+        RETURN;
+      END IF;
+
+      EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
+
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+
+      EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active'$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
+
+      IF options->>'policy' = 'short' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
+      ELSIF options->>'policy' = 'singleton' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
+      ELSIF options->>'policy' = 'stately' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
+      ELSIF options->>'policy' = 'exclusive' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
+      ELSIF options->>'policy' = 'key_strict_fifo' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i8 ON ${schema}.job (name, singleton_key) WHERE state IN ('active', 'retry', 'failed') AND policy = 'key_strict_fifo'$cmd$, tablename);
+        EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, tablename);
+      END IF;
+
+      EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
+      EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
+    END;
+    $$
+    LANGUAGE plpgsql;
+  `,
+	30: (schema) => `
+    CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
+    RETURNS VOID AS
+    $$
+    DECLARE
+      tablename varchar := CASE WHEN options->>'partition' = 'true'
+                            THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
+                            ELSE 'job_common'
+                            END;
+      queue_created_on timestamptz;
+    BEGIN
+
+      WITH q as (
+        INSERT INTO ${schema}.queue (
+          name,
+          policy,
+          retry_limit,
+          retry_delay,
+          retry_backoff,
+          retry_delay_max,
+          expire_seconds,
+          retention_seconds,
+          deletion_seconds,
+          warning_queued,
+          dead_letter,
+          partition,
+          table_name,
+          heartbeat_seconds
+        )
+        VALUES (
+          queue_name,
+          options->>'policy',
+          COALESCE((options->>'retryLimit')::int, 2),
+          COALESCE((options->>'retryDelay')::int, 0),
+          COALESCE((options->>'retryBackoff')::bool, false),
+          (options->>'retryDelayMax')::int,
+          COALESCE((options->>'expireInSeconds')::int, 900),
+          COALESCE((options->>'retentionSeconds')::int, 1209600),
+          COALESCE((options->>'deleteAfterSeconds')::int, 604800),
+          COALESCE((options->>'warningQueueSize')::int, 0),
+          options->>'deadLetter',
+          COALESCE((options->>'partition')::bool, false),
+          tablename,
+          (options->>'heartbeatSeconds')::int
+        )
+        ON CONFLICT DO NOTHING
+        RETURNING created_on
+      )
+      SELECT created_on into queue_created_on from q;
+
+      IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
+        RETURN;
+      END IF;
+
+      EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
+
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+
+      EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active'$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
+
+      IF options->>'policy' = 'short' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
+      ELSIF options->>'policy' = 'singleton' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
+      ELSIF options->>'policy' = 'stately' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
+      ELSIF options->>'policy' = 'exclusive' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
+      ELSIF options->>'policy' = 'key_strict_fifo' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i8 ON ${schema}.job (name, singleton_key) WHERE state IN ('active', 'retry', 'failed') AND policy = 'key_strict_fifo'$cmd$, tablename);
+        EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, tablename);
+      END IF;
+
+      EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
+      EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
+    END;
+    $$
+    LANGUAGE plpgsql;
+  `,
+	31: (schema) => `
+    CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
+    RETURNS VOID AS
+    $$
+    DECLARE
+      tablename varchar := CASE WHEN options->>'partition' = 'true'
+                            THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
+                            ELSE 'job_common'
+                            END;
+      queue_created_on timestamptz;
+    BEGIN
+
+      WITH q as (
+        INSERT INTO ${schema}.queue (
+          name,
+          policy,
+          retry_limit,
+          retry_delay,
+          retry_backoff,
+          retry_delay_max,
+          expire_seconds,
+          retention_seconds,
+          deletion_seconds,
+          warning_queued,
+          dead_letter,
+          partition,
+          table_name,
+          heartbeat_seconds
+        )
+        VALUES (
+          queue_name,
+          options->>'policy',
+          COALESCE((options->>'retryLimit')::int, 2),
+          COALESCE((options->>'retryDelay')::int, 0),
+          COALESCE((options->>'retryBackoff')::bool, false),
+          (options->>'retryDelayMax')::int,
+          COALESCE((options->>'expireInSeconds')::int, 900),
+          COALESCE((options->>'retentionSeconds')::int, 1209600),
+          COALESCE((options->>'deleteAfterSeconds')::int, 604800),
+          COALESCE((options->>'warningQueueSize')::int, 0),
+          options->>'deadLetter',
+          COALESCE((options->>'partition')::bool, false),
+          tablename,
+          (options->>'heartbeatSeconds')::int
+        )
+        ON CONFLICT DO NOTHING
+        RETURNING created_on
+      )
+      SELECT created_on into queue_created_on from q;
+
+      IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
+        RETURN;
+      END IF;
+
+      EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
+
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+
+      EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active' AND NOT blocked$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
+
+      IF options->>'policy' = 'short' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
+      ELSIF options->>'policy' = 'singleton' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
+      ELSIF options->>'policy' = 'stately' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
+      ELSIF options->>'policy' = 'exclusive' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
+      ELSIF options->>'policy' = 'key_strict_fifo' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i8 ON ${schema}.job (name, singleton_key) WHERE state IN ('active', 'retry', 'failed') AND policy = 'key_strict_fifo'$cmd$, tablename);
+        EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, tablename);
+      END IF;
+
+      EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
+      EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
+    END;
+    $$
+    LANGUAGE plpgsql;
+  `,
+	32: (schema) => `
+    CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
+    RETURNS VOID AS
+    $$
+    DECLARE
+      tablename varchar := CASE WHEN options->>'partition' = 'true'
+                            THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
+                            ELSE 'job_common'
+                            END;
+      queue_created_on timestamptz;
+    BEGIN
+
+      WITH q as (
+        INSERT INTO ${schema}.queue (
+          name,
+          policy,
+          retry_limit,
+          retry_delay,
+          retry_backoff,
+          retry_delay_max,
+          expire_seconds,
+          retention_seconds,
+          deletion_seconds,
+          warning_queued,
+          dead_letter,
+          partition,
+          table_name,
+          heartbeat_seconds,
+          notify
+        )
+        VALUES (
+          queue_name,
+          options->>'policy',
+          COALESCE((options->>'retryLimit')::int, 2),
+          COALESCE((options->>'retryDelay')::int, 0),
+          COALESCE((options->>'retryBackoff')::bool, false),
+          (options->>'retryDelayMax')::int,
+          COALESCE((options->>'expireInSeconds')::int, 900),
+          COALESCE((options->>'retentionSeconds')::int, 1209600),
+          COALESCE((options->>'deleteAfterSeconds')::int, 604800),
+          COALESCE((options->>'warningQueueSize')::int, 0),
+          options->>'deadLetter',
+          COALESCE((options->>'partition')::bool, false),
+          tablename,
+          (options->>'heartbeatSeconds')::int,
+          COALESCE((options->>'notify')::bool, false)
+        )
+        ON CONFLICT DO NOTHING
+        RETURNING created_on
+      )
+      SELECT created_on into queue_created_on from q;
+
+      IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
+        RETURN;
+      END IF;
+
+      EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
+
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+
+      EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active' AND NOT blocked$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
+      EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
+
+      IF options->>'policy' = 'short' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
+      ELSIF options->>'policy' = 'singleton' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
+      ELSIF options->>'policy' = 'stately' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
+      ELSIF options->>'policy' = 'exclusive' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
+      ELSIF options->>'policy' = 'key_strict_fifo' THEN
+        EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i8 ON ${schema}.job (name, singleton_key) WHERE state IN ('active', 'retry', 'failed') AND policy = 'key_strict_fifo'$cmd$, tablename);
+        EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, tablename);
+      END IF;
+
+      EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
+      EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
+    END;
+    $$
+    LANGUAGE plpgsql;
+  `
+};
+function getAll(schema) {
+	return [
+		{
+			release: "11.1.0",
+			version: 26,
+			previous: 25,
+			install: [createQueueFn[26](schema), `CREATE UNIQUE INDEX job_i6 ON ${schema}.job_common (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'`],
+			uninstall: [`DROP INDEX ${schema}.job_i6`]
+		},
+		{
+			release: "12.6.0",
+			version: 27,
+			previous: 26,
+			install: [
+				`ALTER TABLE ${schema}.version ADD COLUMN IF NOT EXISTS bam_on timestamp with time zone`,
+				`
+        CREATE TABLE IF NOT EXISTS ${schema}.bam (
+          id uuid PRIMARY KEY default gen_random_uuid(),
+          name text NOT NULL,
+          version int NOT NULL,
+          status text NOT NULL DEFAULT 'pending',
+          queue text,
+          table_name text NOT NULL,
+          command text NOT NULL,
+          error text,
+          created_on timestamp with time zone NOT NULL DEFAULT now(),
+          started_on timestamp with time zone,
+          completed_on timestamp with time zone
+        )
+        `,
+				`CREATE FUNCTION ${schema}.job_table_format(command text, table_name text)
+          RETURNS text AS
+          $$
+            SELECT format(
+              replace(
+                replace(command, '.job', '.%1$I'),
+                'job_i', '%1$s_i'
+              ),
+              table_name
+            );
+          $$
+          LANGUAGE sql IMMUTABLE;
+        `,
+				`
+        CREATE OR REPLACE FUNCTION ${schema}.job_table_run_async(command_name text, version int, command text, tbl_name text DEFAULT NULL, queue_name text DEFAULT NULL)
+        RETURNS VOID AS
+        $$
+        BEGIN
+          IF queue_name IS NOT NULL THEN
+            SELECT table_name INTO tbl_name FROM ${schema}.queue WHERE name = queue_name;
+          END IF;
+
+          IF tbl_name IS NOT NULL THEN
+            INSERT INTO ${schema}.bam (name, version, status, queue, table_name, command)
+            VALUES (
+              command_name,
+              version,
+              'pending',
+              queue_name,
+              tbl_name,
+              ${schema}.job_table_format(command, tbl_name)
+            );
+            RETURN;
+          END IF;
+
+          INSERT INTO ${schema}.bam (name, version, status, queue, table_name, command)
+          SELECT
+            command_name,
+            version,
+            'pending',
+            NULL,
+            'job_common',
             ${schema}.job_table_format(command, 'job_common')
           UNION ALL
           SELECT
@@ -3605,86 +4228,9 @@ function getAll(schema) {
         $$
         LANGUAGE plpgsql;
         `,
-				`ALTER TABLE ${schema}.job ADD COLUMN IF NOT EXISTS group_id text`,
-				`ALTER TABLE ${schema}.job ADD COLUMN IF NOT EXISTS group_tier text`,
-				`
-        CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
-        RETURNS VOID AS
-        $$
-        DECLARE
-          tablename varchar := CASE WHEN options->>'partition' = 'true'
-                                THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
-                                ELSE 'job_common'
-                                END;
-          queue_created_on timestamptz;
-        BEGIN
-
-          WITH q as (
-            INSERT INTO ${schema}.queue (
-              name,
-              policy,
-              retry_limit,
-              retry_delay,
-              retry_backoff,
-              retry_delay_max,
-              expire_seconds,
-              retention_seconds,
-              deletion_seconds,
-              warning_queued,
-              dead_letter,
-              partition,
-              table_name
-            )
-            VALUES (
-              queue_name,
-              options->>'policy',
-              COALESCE((options->>'retryLimit')::int, 2),
-              COALESCE((options->>'retryDelay')::int, 0),
-              COALESCE((options->>'retryBackoff')::bool, false),
-              (options->>'retryDelayMax')::int,
-              COALESCE((options->>'expireInSeconds')::int, 900),
-              COALESCE((options->>'retentionSeconds')::int, 1209600),
-              COALESCE((options->>'deleteAfterSeconds')::int, 604800),
-              COALESCE((options->>'warningQueueSize')::int, 0),
-              options->>'deadLetter',
-              COALESCE((options->>'partition')::bool, false),
-              tablename
-            )
-            ON CONFLICT DO NOTHING
-            RETURNING created_on
-          )
-          SELECT created_on into queue_created_on from q;
-
-          IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
-            RETURN;
-          END IF;
-
-          EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
-
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
-
-          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active'$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
-
-          IF options->>'policy' = 'short' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
-          ELSIF options->>'policy' = 'singleton' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
-          ELSIF options->>'policy' = 'stately' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
-          ELSIF options->>'policy' = 'exclusive' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
-          END IF;
-
-          EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
-          EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
-        END;
-        $$
-        LANGUAGE plpgsql;
-        `,
+				`ALTER TABLE ${schema}.job ADD COLUMN IF NOT EXISTS group_id text`,
+				`ALTER TABLE ${schema}.job ADD COLUMN IF NOT EXISTS group_tier text`,
+				createQueueFn[27](schema),
 				`ALTER INDEX IF EXISTS ${schema}.job_i1 RENAME TO job_common_i1`,
 				`ALTER INDEX IF EXISTS ${schema}.job_i2 RENAME TO job_common_i2`,
 				`ALTER INDEX IF EXISTS ${schema}.job_i3 RENAME TO job_common_i3`,
@@ -3708,83 +4254,7 @@ function getAll(schema) {
 				`ALTER INDEX ${schema}.job_common_i2 RENAME TO job_i2`,
 				`ALTER INDEX ${schema}.job_common_i1 RENAME TO job_i1`,
 				`SELECT ${schema}.job_table_run('DROP INDEX ${schema}.job_i7')`,
-				`
-        CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
-        RETURNS VOID AS
-        $$
-        DECLARE
-          tablename varchar := CASE WHEN options->>'partition' = 'true'
-                                THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
-                                ELSE 'job_common'
-                                END;
-          queue_created_on timestamptz;
-        BEGIN
-
-          WITH q as (
-            INSERT INTO ${schema}.queue (
-              name,
-              policy,
-              retry_limit,
-              retry_delay,
-              retry_backoff,
-              retry_delay_max,
-              expire_seconds,
-              retention_seconds,
-              deletion_seconds,
-              warning_queued,
-              dead_letter,
-              partition,
-              table_name
-            )
-            VALUES (
-              queue_name,
-              options->>'policy',
-              COALESCE((options->>'retryLimit')::int, 2),
-              COALESCE((options->>'retryDelay')::int, 0),
-              COALESCE((options->>'retryBackoff')::bool, false),
-              (options->>'retryDelayMax')::int,
-              COALESCE((options->>'expireInSeconds')::int, 900),
-              COALESCE((options->>'retentionSeconds')::int, 1209600),
-              COALESCE((options->>'deleteAfterSeconds')::int, 604800),
-              COALESCE((options->>'warningQueueSize')::int, 0),
-              options->>'deadLetter',
-              COALESCE((options->>'partition')::bool, false),
-              tablename
-            )
-            ON CONFLICT DO NOTHING
-            RETURNING created_on
-          )
-          SELECT created_on into queue_created_on from q;
-
-          IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
-            RETURN;
-          END IF;
-
-          EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
-
-          EXECUTE format('ALTER TABLE ${schema}.%1$I ADD PRIMARY KEY (name, id)', tablename);
-          EXECUTE format('ALTER TABLE ${schema}.%1$I ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED', tablename);
-          EXECUTE format('ALTER TABLE ${schema}.%1$I ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED', tablename);
-
-          EXECUTE format('CREATE INDEX %1$s_i5 ON ${schema}.%1$I (name, start_after) INCLUDE (priority, created_on, id) WHERE state < ''active''', tablename);
-          EXECUTE format('CREATE UNIQUE INDEX %1$s_i4 ON ${schema}.%1$I (name, singleton_on, COALESCE(singleton_key, '''')) WHERE state <> ''cancelled'' AND singleton_on IS NOT NULL', tablename);
-
-          IF options->>'policy' = 'short' THEN
-            EXECUTE format('CREATE UNIQUE INDEX %1$s_i1 ON ${schema}.%1$I (name, COALESCE(singleton_key, '''')) WHERE state = ''created'' AND policy = ''short''', tablename);
-          ELSIF options->>'policy' = 'singleton' THEN
-            EXECUTE format('CREATE UNIQUE INDEX %1$s_i2 ON ${schema}.%1$I (name, COALESCE(singleton_key, '''')) WHERE state = ''active'' AND policy = ''singleton''', tablename);
-          ELSIF options->>'policy' = 'stately' THEN
-            EXECUTE format('CREATE UNIQUE INDEX %1$s_i3 ON ${schema}.%1$I (name, state, COALESCE(singleton_key, '''')) WHERE state <= ''active'' AND policy = ''stately''', tablename);
-          ELSIF options->>'policy' = 'exclusive' THEN
-            EXECUTE format('CREATE UNIQUE INDEX %1$s_i6 ON ${schema}.%1$I (name, COALESCE(singleton_key, '''')) WHERE state <= ''active'' AND policy = ''exclusive''', tablename);
-          END IF;
-
-          EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
-          EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
-        END;
-        $$
-        LANGUAGE plpgsql;
-        `,
+				createQueueFn[26](schema),
 				`DROP FUNCTION ${schema}.job_table_run(text, text, text)`,
 				`DROP FUNCTION ${schema}.job_table_run_async(text, int, text, text, text)`,
 				`DROP FUNCTION ${schema}.job_table_format(text, text)`,
@@ -3798,87 +4268,7 @@ function getAll(schema) {
 			release: "12.10.0",
 			version: 28,
 			previous: 27,
-			install: [`SELECT ${schema}.job_table_run($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, 'job_common')`, `
-        CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
-        RETURNS VOID AS
-        $$
-        DECLARE
-          tablename varchar := CASE WHEN options->>'partition' = 'true'
-                                THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
-                                ELSE 'job_common'
-                                END;
-          queue_created_on timestamptz;
-        BEGIN
-
-          WITH q as (
-            INSERT INTO ${schema}.queue (
-              name,
-              policy,
-              retry_limit,
-              retry_delay,
-              retry_backoff,
-              retry_delay_max,
-              expire_seconds,
-              retention_seconds,
-              deletion_seconds,
-              warning_queued,
-              dead_letter,
-              partition,
-              table_name
-            )
-            VALUES (
-              queue_name,
-              options->>'policy',
-              COALESCE((options->>'retryLimit')::int, 2),
-              COALESCE((options->>'retryDelay')::int, 0),
-              COALESCE((options->>'retryBackoff')::bool, false),
-              (options->>'retryDelayMax')::int,
-              COALESCE((options->>'expireInSeconds')::int, 900),
-              COALESCE((options->>'retentionSeconds')::int, 1209600),
-              COALESCE((options->>'deleteAfterSeconds')::int, 604800),
-              COALESCE((options->>'warningQueueSize')::int, 0),
-              options->>'deadLetter',
-              COALESCE((options->>'partition')::bool, false),
-              tablename
-            )
-            ON CONFLICT DO NOTHING
-            RETURNING created_on
-          )
-          SELECT created_on into queue_created_on from q;
-
-          IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
-            RETURN;
-          END IF;
-
-          EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
-
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
-
-          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active'$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
-
-          IF options->>'policy' = 'short' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
-          ELSIF options->>'policy' = 'singleton' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
-          ELSIF options->>'policy' = 'stately' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
-          ELSIF options->>'policy' = 'exclusive' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
-          ELSIF options->>'policy' = 'key_strict_fifo' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i8 ON ${schema}.job (name, singleton_key) WHERE state IN ('active', 'retry', 'failed') AND policy = 'key_strict_fifo'$cmd$, tablename);
-            EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, tablename);
-          END IF;
-
-          EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
-          EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
-        END;
-        $$
-        LANGUAGE plpgsql;
-        `],
+			install: [`SELECT ${schema}.job_table_run($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, 'job_common')`, createQueueFn[28](schema)],
 			async: [`SELECT ${schema}.job_table_run_async(
           'key_strict_fifo_index',
           $VERSION$,
@@ -3889,84 +4279,7 @@ function getAll(schema) {
 			uninstall: [
 				`SELECT ${schema}.job_table_run('DROP INDEX IF EXISTS ${schema}.job_i8')`,
 				`SELECT ${schema}.job_table_run('ALTER TABLE ${schema}.job DROP CONSTRAINT IF EXISTS job_key_strict_fifo_singleton_key_check')`,
-				`
-        CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
-        RETURNS VOID AS
-        $$
-        DECLARE
-          tablename varchar := CASE WHEN options->>'partition' = 'true'
-                                THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
-                                ELSE 'job_common'
-                                END;
-          queue_created_on timestamptz;
-        BEGIN
-
-          WITH q as (
-            INSERT INTO ${schema}.queue (
-              name,
-              policy,
-              retry_limit,
-              retry_delay,
-              retry_backoff,
-              retry_delay_max,
-              expire_seconds,
-              retention_seconds,
-              deletion_seconds,
-              warning_queued,
-              dead_letter,
-              partition,
-              table_name
-            )
-            VALUES (
-              queue_name,
-              options->>'policy',
-              COALESCE((options->>'retryLimit')::int, 2),
-              COALESCE((options->>'retryDelay')::int, 0),
-              COALESCE((options->>'retryBackoff')::bool, false),
-              (options->>'retryDelayMax')::int,
-              COALESCE((options->>'expireInSeconds')::int, 900),
-              COALESCE((options->>'retentionSeconds')::int, 1209600),
-              COALESCE((options->>'deleteAfterSeconds')::int, 604800),
-              COALESCE((options->>'warningQueueSize')::int, 0),
-              options->>'deadLetter',
-              COALESCE((options->>'partition')::bool, false),
-              tablename
-            )
-            ON CONFLICT DO NOTHING
-            RETURNING created_on
-          )
-          SELECT created_on into queue_created_on from q;
-
-          IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
-            RETURN;
-          END IF;
-
-          EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
-
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
-
-          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active'$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
-
-          IF options->>'policy' = 'short' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
-          ELSIF options->>'policy' = 'singleton' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
-          ELSIF options->>'policy' = 'stately' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
-          ELSIF options->>'policy' = 'exclusive' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
-          END IF;
-
-          EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
-          EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
-        END;
-        $$
-        LANGUAGE plpgsql;
-        `
+				createQueueFn[27](schema)
 			]
 		},
 		{
@@ -3990,172 +4303,10 @@ function getAll(schema) {
 				`ALTER TABLE ${schema}.job ADD COLUMN heartbeat_on timestamp with time zone`,
 				`ALTER TABLE ${schema}.job ADD COLUMN heartbeat_seconds int`,
 				`ALTER TABLE ${schema}.queue ADD COLUMN heartbeat_seconds int`,
-				`
-        CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
-        RETURNS VOID AS
-        $$
-        DECLARE
-          tablename varchar := CASE WHEN options->>'partition' = 'true'
-                                THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
-                                ELSE 'job_common'
-                                END;
-          queue_created_on timestamptz;
-        BEGIN
-
-          WITH q as (
-            INSERT INTO ${schema}.queue (
-              name,
-              policy,
-              retry_limit,
-              retry_delay,
-              retry_backoff,
-              retry_delay_max,
-              expire_seconds,
-              retention_seconds,
-              deletion_seconds,
-              warning_queued,
-              dead_letter,
-              partition,
-              table_name,
-              heartbeat_seconds
-            )
-            VALUES (
-              queue_name,
-              options->>'policy',
-              COALESCE((options->>'retryLimit')::int, 2),
-              COALESCE((options->>'retryDelay')::int, 0),
-              COALESCE((options->>'retryBackoff')::bool, false),
-              (options->>'retryDelayMax')::int,
-              COALESCE((options->>'expireInSeconds')::int, 900),
-              COALESCE((options->>'retentionSeconds')::int, 1209600),
-              COALESCE((options->>'deleteAfterSeconds')::int, 604800),
-              COALESCE((options->>'warningQueueSize')::int, 0),
-              options->>'deadLetter',
-              COALESCE((options->>'partition')::bool, false),
-              tablename,
-              (options->>'heartbeatSeconds')::int
-            )
-            ON CONFLICT DO NOTHING
-            RETURNING created_on
-          )
-          SELECT created_on into queue_created_on from q;
-
-          IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
-            RETURN;
-          END IF;
-
-          EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
-
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
-
-          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active'$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
-
-          IF options->>'policy' = 'short' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
-          ELSIF options->>'policy' = 'singleton' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
-          ELSIF options->>'policy' = 'stately' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
-          ELSIF options->>'policy' = 'exclusive' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
-          ELSIF options->>'policy' = 'key_strict_fifo' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i8 ON ${schema}.job (name, singleton_key) WHERE state IN ('active', 'retry', 'failed') AND policy = 'key_strict_fifo'$cmd$, tablename);
-            EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, tablename);
-          END IF;
-
-          EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
-          EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
-        END;
-        $$
-        LANGUAGE plpgsql;
-        `
+				createQueueFn[30](schema)
 			],
 			uninstall: [
-				`
-        CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
-        RETURNS VOID AS
-        $$
-        DECLARE
-          tablename varchar := CASE WHEN options->>'partition' = 'true'
-                                THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
-                                ELSE 'job_common'
-                                END;
-          queue_created_on timestamptz;
-        BEGIN
-
-          WITH q as (
-            INSERT INTO ${schema}.queue (
-              name,
-              policy,
-              retry_limit,
-              retry_delay,
-              retry_backoff,
-              retry_delay_max,
-              expire_seconds,
-              retention_seconds,
-              deletion_seconds,
-              warning_queued,
-              dead_letter,
-              partition,
-              table_name
-            )
-            VALUES (
-              queue_name,
-              options->>'policy',
-              COALESCE((options->>'retryLimit')::int, 2),
-              COALESCE((options->>'retryDelay')::int, 0),
-              COALESCE((options->>'retryBackoff')::bool, false),
-              (options->>'retryDelayMax')::int,
-              COALESCE((options->>'expireInSeconds')::int, 900),
-              COALESCE((options->>'retentionSeconds')::int, 1209600),
-              COALESCE((options->>'deleteAfterSeconds')::int, 604800),
-              COALESCE((options->>'warningQueueSize')::int, 0),
-              options->>'deadLetter',
-              COALESCE((options->>'partition')::bool, false),
-              tablename
-            )
-            ON CONFLICT DO NOTHING
-            RETURNING created_on
-          )
-          SELECT created_on into queue_created_on from q;
-
-          IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
-            RETURN;
-          END IF;
-
-          EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
-
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
-
-          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active'$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
-
-          IF options->>'policy' = 'short' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
-          ELSIF options->>'policy' = 'singleton' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
-          ELSIF options->>'policy' = 'stately' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
-          ELSIF options->>'policy' = 'exclusive' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
-          ELSIF options->>'policy' = 'key_strict_fifo' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i8 ON ${schema}.job (name, singleton_key) WHERE state IN ('active', 'retry', 'failed') AND policy = 'key_strict_fifo'$cmd$, tablename);
-            EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, tablename);
-          END IF;
-
-          EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
-          EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
-        END;
-        $$
-        LANGUAGE plpgsql;
-        `,
+				createQueueFn[28](schema),
 				`ALTER TABLE ${schema}.queue DROP COLUMN heartbeat_seconds`,
 				`ALTER TABLE ${schema}.job DROP COLUMN heartbeat_seconds`,
 				`ALTER TABLE ${schema}.job DROP COLUMN heartbeat_on`
@@ -4181,182 +4332,35 @@ function getAll(schema) {
 				`CREATE INDEX IF NOT EXISTS job_dep_parent_idx ON ${schema}.job_dependency (parent_name, parent_id)`,
 				`SELECT ${schema}.job_table_run($cmd$DROP INDEX IF EXISTS ${schema}.job_i5$cmd$)`,
 				`SELECT ${schema}.job_table_run($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active' AND NOT blocked$cmd$)`,
-				`
-        CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
-        RETURNS VOID AS
-        $$
-        DECLARE
-          tablename varchar := CASE WHEN options->>'partition' = 'true'
-                                THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
-                                ELSE 'job_common'
-                                END;
-          queue_created_on timestamptz;
-        BEGIN
-
-          WITH q as (
-            INSERT INTO ${schema}.queue (
-              name,
-              policy,
-              retry_limit,
-              retry_delay,
-              retry_backoff,
-              retry_delay_max,
-              expire_seconds,
-              retention_seconds,
-              deletion_seconds,
-              warning_queued,
-              dead_letter,
-              partition,
-              table_name,
-              heartbeat_seconds
-            )
-            VALUES (
-              queue_name,
-              options->>'policy',
-              COALESCE((options->>'retryLimit')::int, 2),
-              COALESCE((options->>'retryDelay')::int, 0),
-              COALESCE((options->>'retryBackoff')::bool, false),
-              (options->>'retryDelayMax')::int,
-              COALESCE((options->>'expireInSeconds')::int, 900),
-              COALESCE((options->>'retentionSeconds')::int, 1209600),
-              COALESCE((options->>'deleteAfterSeconds')::int, 604800),
-              COALESCE((options->>'warningQueueSize')::int, 0),
-              options->>'deadLetter',
-              COALESCE((options->>'partition')::bool, false),
-              tablename,
-              (options->>'heartbeatSeconds')::int
-            )
-            ON CONFLICT DO NOTHING
-            RETURNING created_on
-          )
-          SELECT created_on into queue_created_on from q;
-
-          IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
-            RETURN;
-          END IF;
-
-          EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
-
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
-
-          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active' AND NOT blocked$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
-
-          IF options->>'policy' = 'short' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
-          ELSIF options->>'policy' = 'singleton' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
-          ELSIF options->>'policy' = 'stately' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
-          ELSIF options->>'policy' = 'exclusive' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
-          ELSIF options->>'policy' = 'key_strict_fifo' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i8 ON ${schema}.job (name, singleton_key) WHERE state IN ('active', 'retry', 'failed') AND policy = 'key_strict_fifo'$cmd$, tablename);
-            EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, tablename);
-          END IF;
-
-          EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
-          EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
-        END;
-        $$
-        LANGUAGE plpgsql;
-        `
+				createQueueFn[31](schema)
 			],
 			uninstall: [
 				`DROP INDEX IF EXISTS ${schema}.job_dep_parent_idx`,
 				`DROP TABLE IF EXISTS ${schema}.job_dependency`,
-				`
-        CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
-        RETURNS VOID AS
-        $$
-        DECLARE
-          tablename varchar := CASE WHEN options->>'partition' = 'true'
-                                THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
-                                ELSE 'job_common'
-                                END;
-          queue_created_on timestamptz;
-        BEGIN
-
-          WITH q as (
-            INSERT INTO ${schema}.queue (
-              name,
-              policy,
-              retry_limit,
-              retry_delay,
-              retry_backoff,
-              retry_delay_max,
-              expire_seconds,
-              retention_seconds,
-              deletion_seconds,
-              warning_queued,
-              dead_letter,
-              partition,
-              table_name,
-              heartbeat_seconds
-            )
-            VALUES (
-              queue_name,
-              options->>'policy',
-              COALESCE((options->>'retryLimit')::int, 2),
-              COALESCE((options->>'retryDelay')::int, 0),
-              COALESCE((options->>'retryBackoff')::bool, false),
-              (options->>'retryDelayMax')::int,
-              COALESCE((options->>'expireInSeconds')::int, 900),
-              COALESCE((options->>'retentionSeconds')::int, 1209600),
-              COALESCE((options->>'deleteAfterSeconds')::int, 604800),
-              COALESCE((options->>'warningQueueSize')::int, 0),
-              options->>'deadLetter',
-              COALESCE((options->>'partition')::bool, false),
-              tablename,
-              (options->>'heartbeatSeconds')::int
-            )
-            ON CONFLICT DO NOTHING
-            RETURNING created_on
-          )
-          SELECT created_on into queue_created_on from q;
-
-          IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
-            RETURN;
-          END IF;
-
-          EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
-
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
-
-          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active'$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
-          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
-
-          IF options->>'policy' = 'short' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
-          ELSIF options->>'policy' = 'singleton' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
-          ELSIF options->>'policy' = 'stately' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
-          ELSIF options->>'policy' = 'exclusive' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
-          ELSIF options->>'policy' = 'key_strict_fifo' THEN
-            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i8 ON ${schema}.job (name, singleton_key) WHERE state IN ('active', 'retry', 'failed') AND policy = 'key_strict_fifo'$cmd$, tablename);
-            EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, tablename);
-          END IF;
-
-          EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
-          EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
-        END;
-        $$
-        LANGUAGE plpgsql;
-        `,
+				createQueueFn[30](schema),
 				`SELECT ${schema}.job_table_run($cmd$DROP INDEX IF EXISTS ${schema}.job_i5$cmd$)`,
 				`SELECT ${schema}.job_table_run($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active'$cmd$)`,
 				`ALTER TABLE ${schema}.job DROP COLUMN pending_dependencies`,
 				`ALTER TABLE ${schema}.job DROP COLUMN blocking`,
 				`ALTER TABLE ${schema}.job DROP COLUMN blocked`
 			]
+		},
+		{
+			release: "12.21.0",
+			version: 32,
+			previous: 31,
+			install: [
+				`ALTER TABLE ${schema}.queue ADD COLUMN notify boolean NOT NULL DEFAULT false`,
+				createQueueFn[32](schema),
+				`ALTER TABLE ${schema}.queue ADD COLUMN failed_count int NOT NULL DEFAULT 0`,
+				`ALTER TABLE ${schema}.queue ADD COLUMN ready_count int NOT NULL DEFAULT 0`
+			],
+			uninstall: [
+				`ALTER TABLE ${schema}.queue DROP COLUMN ready_count`,
+				`ALTER TABLE ${schema}.queue DROP COLUMN failed_count`,
+				createQueueFn[31](schema),
+				`ALTER TABLE ${schema}.queue DROP COLUMN notify`
+			]
 		}
 	];
 }
@@ -4364,7 +4368,7 @@ function getAll(schema) {
 //#region ../../src/contractor.ts
 var schemaVersion = {
 	name: "pg-boss",
-	version: "12.20.0",
+	version: "12.21.0",
 	description: "Queueing jobs in Postgres from Node.js like a boss",
 	type: "module",
 	main: "./dist/index.js",
@@ -4372,18 +4376,18 @@ var schemaVersion = {
 	bin: { "pg-boss": "./dist/cli.js" },
 	engines: { "node": ">=22.12.0" },
 	dependencies: {
-		"cron-parser": "^5.5.0",
-		"pg": "^8.21.0",
+		"cron-parser": "^5.6.0",
+		"pg": "^8.22.0",
 		"serialize-error": "^13.0.1"
 	},
 	devDependencies: {
-		"@electric-sql/pglite": "^0.4.1",
+		"@electric-sql/pglite": "^0.5.3",
 		"@prisma/adapter-pg": "^7.8.0",
 		"@prisma/client": "^7.8.0",
 		"@tsconfig/node-ts": "^23.6.4",
 		"@tsconfig/node22": "^22.0.5",
-		"@types/luxon": "^3.7.1",
-		"@types/node": "^22.19.20",
+		"@types/luxon": "^3.7.2",
+		"@types/node": "^22.20.0",
 		"@types/pg": "^8.20.0",
 		"@vitest/coverage-v8": "^4.1.2",
 		"cli-testlab": "^6.0.1",
@@ -4403,23 +4407,24 @@ var schemaVersion = {
 		"build": "npm run clean && tsc --project tsconfig.build.json",
 		"clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
 		"prepublishOnly": "npm install && npm test && npm run build",
-		"pretest": "prisma generate --schema=test/prisma/schema.prisma",
+		"pretest": "prisma generate --schema=test/prisma/schema.prisma && npm run tsc",
 		"test": "eslint . && vitest run",
 		"test:distributed": "cross-env DISTRIBUTED=true npm test",
+		"test:ci": "npm run cover && cross-env DISTRIBUTED=true npm run cover && npm run test:pglite",
 		"test:cockroachdb": "cross-env DB_TYPE=cockroachdb COCKROACH_HOST=localhost npm test -- test/distributedDatabaseTest.ts",
 		"test:cockroachdb:full": "cross-env DB_TYPE=cockroachdb COCKROACH_HOST=localhost npm test -- --no-file-parallelism",
 		"test:yugabytedb:full": "cross-env DB_TYPE=yugabytedb YUGABYTE_HOST=localhost npm test -- --no-file-parallelism",
 		"test:citus:full": "cross-env DB_TYPE=citus CITUS_HOST=localhost npm test",
 		"test:pglite": "cross-env DB_TYPE=pglite npm test -- --no-file-parallelism",
 		"lint:fix": "eslint . --fix",
-		"precover": "prisma generate --schema=test/prisma/schema.prisma",
-		"cover": "vitest run --coverage",
+		"cover": "npm test -- --coverage",
 		"tsc": "tsc --noEmit",
+		"cli": "node ./dist/cli.js",
 		"readme": "node ./examples/readme.js",
-		"db:migrate": "node --import=tsx -e 'console.log(require(\"./src\").getMigrationPlans())'",
-		"db:construct": "node --import=tsx -e 'console.log(require(\"./src\").getConstructionPlans())'"
+		"docs": "npm run docs:dev --prefix docs",
+		"docs:readme": "node ./scripts/sync-readme.js"
 	},
-	pgboss: { "schema": 31 },
+	pgboss: { "schema": 32 },
 	repository: {
 		"type": "git",
 		"url": "git+https://github.com/timgit/pg-boss.git"
@@ -4445,8 +4450,11 @@ var Contractor = class {
 	static constructionPlans(schema = DEFAULT_SCHEMA, options = { createSchema: true }) {
 		return create(schema, schemaVersion, options);
 	}
-	static migrationPlans(schema = DEFAULT_SCHEMA, version = schemaVersion - 1) {
-		return migrate(schema, version);
+	static migrationPlans(schema = DEFAULT_SCHEMA, version = schemaVersion - 1, options = {}) {
+		return migrate(schema, version, void 0, void 0, {
+			inlineAsync: true,
+			partitionTables: options.partitionTables
+		});
 	}
 	static rollbackPlans(schema = DEFAULT_SCHEMA, version = schemaVersion) {
 		return rollback(schema, version);
@@ -4741,7 +4749,7 @@ var Worker = class {
 	fetch;
 	onFetch;
 	onError;
-	interval;
+	resolveInterval;
 	jobs = [];
 	createdOn = Date.now();
 	state = WORKER_STATES.created;
@@ -4757,7 +4765,7 @@ var Worker = class {
 	loopDelayPromise = null;
 	beenNotified = false;
 	runPromise = null;
-	constructor({ id, workId, name, options, interval, fetch, onFetch, onError }) {
+	constructor({ id, workId, name, options, resolveInterval, fetch, onFetch, onError }) {
 		this.id = id;
 		this.workId = workId;
 		this.name = name;
@@ -4765,7 +4773,7 @@ var Worker = class {
 		this.fetch = fetch;
 		this.onFetch = onFetch;
 		this.onError = onError;
-		this.interval = interval;
+		this.resolveInterval = resolveInterval;
 	}
 	start() {
 		this.runPromise = this.run();
@@ -4774,11 +4782,13 @@ var Worker = class {
 		this.state = WORKER_STATES.active;
 		while (!this.stopping) {
 			const started = Date.now();
+			let fetchedCount = 0;
 			try {
 				this.beenNotified = false;
 				const jobs = await this.fetch();
 				this.lastFetchedOn = Date.now();
 				if (jobs) {
+					fetchedCount = jobs.length;
 					this.jobs = jobs;
 					this.lastJobStartedOn = this.lastFetchedOn;
 					await this.onFetch(jobs);
@@ -4793,8 +4803,9 @@ var Worker = class {
 			}
 			const duration = Date.now() - started;
 			this.lastJobDuration = duration;
-			if (!this.stopping && !this.beenNotified && this.interval - duration > 100) {
-				this.loopDelayPromise = delay(this.interval - duration);
+			const interval = this.resolveInterval(fetchedCount);
+			if (!this.stopping && !this.beenNotified && interval - duration > 100) {
+				this.loopDelayPromise = delay(interval - duration);
 				await this.loopDelayPromise;
 				this.loopDelayPromise = null;
 			}
@@ -4927,7 +4938,7 @@ var NUMERIC_QUEUE_FIELDS = [
 	"activeCount",
 	"totalCount"
 ];
-var events$3 = {
+var events$4 = {
 	error: "error",
 	wip: "wip"
 };
@@ -4936,7 +4947,7 @@ function rethrowWriteError(err) {
 	throw err;
 }
 var Manager = class extends EventEmitter {
-	events = events$3;
+	events = events$4;
 	db;
 	config;
 	wipTs;
@@ -4945,6 +4956,7 @@ var Manager = class extends EventEmitter {
 	queueCacheInterval;
 	wipInterval;
 	timekeeper;
+	notifier;
 	queues;
 	pendingOffWorkCleanups;
 	#spies;
@@ -5013,19 +5025,136 @@ var Manager = class extends EventEmitter {
 		const spy = this.config.__test__enableSpies ? this.#spies.get(name) : void 0;
 		if (spy) for (const job of jobs) spy.addJob(job.id, name, job.data, "active");
 	}
-	#trackJobsCompleted(name, jobs, result) {
+	async #trackJobsCompleted(name, jobs, result, affected) {
 		const spy = this.config.__test__enableSpies ? this.#spies.get(name) : void 0;
-		if (spy) {
+		if (!spy) return;
+		if (affected === jobs.length) {
 			const output = jobs.length === 1 ? result : void 0;
 			for (const job of jobs) spy.addJob(job.id, name, job.data, "completed", output);
+			return;
+		}
+		for (const job of jobs) {
+			const persisted = await this.getJobById(name, job.id);
+			const state = persisted?.state;
+			if (state === "completed" || state === "failed" || state === "active" || state === "created") spy.addJob(job.id, name, job.data, state, persisted?.output);
+			else if (!persisted) spy.addJob(job.id, name, job.data, "completed", void 0);
 		}
 	}
-	#trackJobsFailed(name, jobs, err) {
+	async #trackJobsFailed(name, jobs, err) {
 		const spy = this.config.__test__enableSpies ? this.#spies.get(name) : void 0;
-		if (spy) for (const job of jobs) spy.addJob(job.id, name, job.data, "failed", {
-			message: err?.message,
-			stack: err?.stack
+		if (!spy) return;
+		for (const job of jobs) {
+			const persisted = await this.getJobById(name, job.id);
+			if (persisted?.state === "failed") spy.addJob(job.id, name, job.data, "failed", persisted.output ?? {
+				message: err?.message,
+				stack: err?.stack
+			});
+		}
+	}
+	#trackJobsSettled(name, completed, failed) {
+		const spy = this.config.__test__enableSpies ? this.#spies.get(name) : void 0;
+		if (!spy) return;
+		for (const { job, output } of completed) spy.addJob(job.id, name, job.data, "completed", output);
+		for (const { job, output } of failed) spy.addJob(job.id, name, job.data, "failed", serializeError(output));
+	}
+	async #settlePerJob(name, jobs, result) {
+		if (!Array.isArray(result)) {
+			const err = /* @__PURE__ */ new Error("perJobResults handler must resolve with an array of job results");
+			await this.fail(name, jobs.map((job) => job.id), err);
+			this.#trackJobsFailed(name, jobs, err);
+			return;
+		}
+		const batch = new Map(jobs.map((job) => [job.id, job]));
+		const disposition = /* @__PURE__ */ new Map();
+		for (const item of result) if (item && batch.has(item.id) && (item.status === "completed" || item.status === "failed" || item.status === "deadletter")) disposition.set(item.id, item);
+		const completed = [];
+		const failed = [];
+		const deadLettered = [];
+		for (const job of jobs) {
+			const item = disposition.get(job.id);
+			if (item?.status === "completed") completed.push({
+				job,
+				output: item.output
+			});
+			else if (item?.status === "failed") failed.push({
+				job,
+				output: item.output
+			});
+			else if (item?.status === "deadletter") deadLettered.push({
+				job,
+				output: item.output
+			});
+			else failed.push({
+				job,
+				output: /* @__PURE__ */ new Error("no disposition returned by handler")
+			});
+		}
+		if (completed.length > 0) await this.#completeWithOutputs(name, completed.map((c) => ({
+			id: c.job.id,
+			output: c.output
+		})));
+		if (failed.length > 0) await this.#failWithOutputs(name, failed.map((f) => ({
+			id: f.job.id,
+			output: f.output
+		})));
+		if (deadLettered.length > 0) await this.#failWithOutputs(name, deadLettered.map((d) => ({
+			id: d.job.id,
+			output: d.output
+		})), true);
+		this.#trackJobsSettled(name, completed, [...failed, ...deadLettered]);
+	}
+	async #completeWithOutputs(name, items) {
+		const { table } = await this.getQueueCache(name);
+		const payload = items.map((item) => ({
+			id: item.id,
+			output: this.mapCompletionDataArg(item.output)
+		}));
+		const ids = items.map((item) => item.id);
+		if (this.config.noMultiMutationCte) return this.withDistributedTransaction(this.db, async (tx) => {
+			const sql = completeJobsWithOutputsDistributed(this.config.schema, table);
+			const { rows } = await tx.executeSql(sql, [name, JSON.stringify(payload)]);
+			const blockingIds = rows.filter((row) => row.blocking).map((row) => row.id);
+			if (blockingIds.length > 0) await tx.executeSql(decrementDependents(this.config.schema), [name, blockingIds]);
+			return {
+				jobs: ids,
+				requested: ids.length,
+				affected: rows.length
+			};
 		});
+		const sql = completeJobsWithOutputs(this.config.schema, table);
+		const result = await this.db.executeSql(sql, [name, JSON.stringify(payload)]);
+		return this.mapCommandResponse(ids, result);
+	}
+	async #failWithOutputs(name, items, forceTerminal = false) {
+		const { table } = await this.getQueueCache(name);
+		const ids = items.map((item) => item.id);
+		if (this.config.noMultiMutationCte) {
+			const outputById = new Map(items.map((item) => [item.id, this.mapCompletionDataArg(item.output)]));
+			return this.withDistributedTransaction(this.db, async (tx) => {
+				const selectQuery = selectJobsToFailById(this.config.schema, table);
+				const { rows: jobs } = await tx.executeSql(selectQuery.text, [name, ids]);
+				if (jobs.length === 0) return {
+					jobs: ids,
+					requested: ids.length,
+					affected: 0
+				};
+				const deleteQuery = deleteJobsToFail(this.config.schema, table);
+				await tx.executeSql(deleteQuery.text, [name, ids]);
+				const count = await this.reinsertFailedJobs(tx, table, jobs, null, outputById, forceTerminal);
+				return {
+					jobs: ids,
+					requested: ids.length,
+					affected: count
+				};
+			});
+		}
+		const payload = items.map((item) => ({
+			id: item.id,
+			output: this.mapCompletionDataArg(item.output)
+		}));
+		const sql = forceTerminal ? deadLetterJobsByIdWithOutputs(this.config.schema, table) : failJobsByIdWithOutputs(this.config.schema, table);
+		const result = await this.db.executeSql(sql, [name, JSON.stringify(payload)]);
+		return this.mapCommandResponse(ids, result);
 	}
 	#storeLocalGroupConfig(name, localGroupConcurrency) {
 		const config = typeof localGroupConcurrency === "number" ? { default: localGroupConcurrency } : localGroupConcurrency;
@@ -5063,7 +5192,7 @@ var Manager = class extends EventEmitter {
 	#trackLocalGroupEnd(name, groupedJobs) {
 		for (const job of groupedJobs) if (job.groupId) this.#decrementLocalGroupCount(name, job.groupId);
 	}
-	async #processJobs(name, jobs, callback, worker, heartbeatRefreshSeconds) {
+	async #processJobs(name, jobs, callback, worker, heartbeatRefreshSeconds, perJobResults = false) {
 		const jobIds = jobs.map((job) => job.id);
 		const maxExpiration = jobs.reduce((acc, i) => Math.max(acc, i.expireInSeconds), 0);
 		const heartbeatSeconds = jobs.reduce((acc, j) => Math.max(acc, j.heartbeatSeconds || 0), 0);
@@ -5079,21 +5208,34 @@ var Manager = class extends EventEmitter {
 				try {
 					await this.touch(name, jobIds);
 				} catch (err) {
-					this.emit(events$3.error, err);
+					this.emit(events$4.error, err);
 				}
 			}, intervalMs);
 		}
+		let completedResult;
+		let completedAffected = 0;
+		let failedError;
+		let didFail = false;
 		try {
 			const result = await resolveWithinSeconds(callback(jobs), maxExpiration, `handler execution exceeded ${maxExpiration}s`, ac);
-			await this.complete(name, jobIds, jobIds.length === 1 ? result : void 0);
-			this.#trackJobsCompleted(name, jobs, result);
+			if (perJobResults) await this.#settlePerJob(name, jobs, result);
+			else {
+				const completion = await this.complete(name, jobIds, jobIds.length === 1 ? result : void 0);
+				completedResult = result;
+				completedAffected = completion.affected;
+			}
 		} catch (err) {
 			await this.fail(name, jobIds, err);
-			this.#trackJobsFailed(name, jobs, err);
+			failedError = err;
+			didFail = true;
 		} finally {
 			if (heartbeatTimer) clearInterval(heartbeatTimer);
 			if (worker) worker.abortController = null;
 		}
+		if (this.config.__test__enableSpies && this.#spies.has(name)) {
+			if (didFail) await this.#trackJobsFailed(name, jobs, failedError);
+			else if (!perJobResults) await this.#trackJobsCompleted(name, jobs, completedResult, completedAffected);
+		}
 	}
 	async start() {
 		this.stopped = false;
@@ -5103,7 +5245,7 @@ var Manager = class extends EventEmitter {
 			if (now - this.wipTs < 2e3) return;
 			const wip = this.getWipData();
 			if (wip.some((w) => w.count > 0)) {
-				this.emit(events$3.wip, wip);
+				this.emit(events$4.wip, wip);
 				this.wipTs = now;
 			}
 		}, 2e3);
@@ -5118,7 +5260,7 @@ var Manager = class extends EventEmitter {
 				return acc;
 			}, {});
 		} catch (error) {
-			emit && this.emit(events$3.error, {
+			emit && this.emit(events$4.error, {
 				...error,
 				message: error.message,
 				stack: error.stack
@@ -5153,9 +5295,15 @@ var Manager = class extends EventEmitter {
 	async work(name, ...args) {
 		const { options, callback } = checkWorkArgs(name, args);
 		if (this.stopped) throw new Error("Workers are disabled. pg-boss is stopped");
-		const { pollingInterval: interval, batchSize = 1, includeMetadata = false, priority = true, localConcurrency = 1, localGroupConcurrency, groupConcurrency, orderByCreatedOn = true, heartbeatRefreshSeconds, minPriority, maxPriority } = options;
+		const { pollingInterval: interval, notifyPollingInterval: notifyInterval, burstWhenReadyExceeds, burstWhenBatchFull = false, batchSize = 1, includeMetadata = false, priority = true, localConcurrency = 1, localGroupConcurrency, groupConcurrency, orderByCreatedOn = true, heartbeatRefreshSeconds, minPriority, maxPriority, perJobResults = false } = options;
 		if (localGroupConcurrency != null) this.#storeLocalGroupConfig(name, localGroupConcurrency);
 		const firstWorkerId = randomUUID({ disableEntropyCache: true });
+		const isNotifyActive = () => !!(this.notifier?.available && this.queues?.[name]?.notify);
+		const getReadyCount = () => this.queues?.[name]?.readyCount ?? 0;
+		const resolveInterval = (lastFetchCount) => {
+			if (lastFetchCount >= batchSize && (burstWhenReadyExceeds !== void 0 && getReadyCount() > burstWhenReadyExceeds || burstWhenBatchFull && batchSize > 1)) return 0;
+			return isNotifyActive() ? notifyInterval : interval;
+		};
 		const createWorker = (workerId, workId) => {
 			const fetch = () => {
 				const ignoreGroups = localGroupConcurrency != null ? this.#getGroupsAtLocalCapacity(name) : void 0;
@@ -5176,7 +5324,7 @@ var Manager = class extends EventEmitter {
 				this.emitWip(name);
 				this.#trackJobsActive(name, jobs);
 				const worker = this.workers.get(workerId);
-				if (localGroupConcurrency == null) await this.#processJobs(name, jobs, callback, worker, heartbeatRefreshSeconds);
+				if (localGroupConcurrency == null) await this.#processJobs(name, jobs, callback, worker, heartbeatRefreshSeconds, perJobResults);
 				else {
 					const { allowed, excess, groupedJobs } = this.#trackLocalGroupStart(name, jobs);
 					if (excess.length > 0) {
@@ -5184,7 +5332,7 @@ var Manager = class extends EventEmitter {
 						await this.restore(name, excessIds);
 					}
 					if (allowed.length > 0) try {
-						await this.#processJobs(name, allowed, callback, worker, heartbeatRefreshSeconds);
+						await this.#processJobs(name, allowed, callback, worker, heartbeatRefreshSeconds, perJobResults);
 					} finally {
 						this.#trackLocalGroupEnd(name, groupedJobs);
 					}
@@ -5192,7 +5340,7 @@ var Manager = class extends EventEmitter {
 				this.emitWip(name);
 			};
 			const onError = (error) => {
-				this.emit(events$3.error, {
+				this.emit(events$4.error, {
 					...error,
 					message: error.message,
 					stack: error.stack,
@@ -5205,7 +5353,7 @@ var Manager = class extends EventEmitter {
 				workId,
 				name,
 				options,
-				interval,
+				resolveInterval,
 				fetch,
 				onFetch,
 				onError
@@ -5231,7 +5379,7 @@ var Manager = class extends EventEmitter {
 		if (!INTERNAL_QUEUES[name]) {
 			const now = Date.now();
 			if (now - this.wipTs > 2e3) {
-				this.emit(events$3.wip, this.getWipData());
+				this.emit(events$4.wip, this.getWipData());
 				this.wipTs = now;
 			}
 		}
@@ -5267,6 +5415,15 @@ var Manager = class extends EventEmitter {
 	notifyWorker(workerId) {
 		this.workers.get(workerId)?.notify();
 	}
+	#notifyEnabled(queueNotify) {
+		return !!queueNotify && !this.config.noListenNotify;
+	}
+	notifyQueue(name) {
+		for (const worker of this.workers.values()) if (worker.name === name) worker.notify();
+	}
+	forceFetchLnWorkers() {
+		for (const worker of this.workers.values()) if (this.queues?.[worker.name]?.notify) worker.notify();
+	}
 	async subscribe(event, name) {
 		assert(event, "Missing required argument");
 		assert(name, "Missing required argument");
@@ -5349,12 +5506,13 @@ var Manager = class extends EventEmitter {
 			deadLetter
 		};
 		const db = wrapper || this.db;
-		const { table, policy } = await this.getQueueCache(name);
+		const { table, policy, notify } = await this.getQueueCache(name);
 		if (policy === QUEUE_POLICIES.key_strict_fifo && !singletonKey) throw new Error(`${QUEUE_POLICIES.key_strict_fifo} queues require a singletonKey`);
 		const sql = insertJobs(this.config.schema, {
 			table,
 			name,
-			returnId: true
+			returnId: true,
+			notify: this.#notifyEnabled(notify)
 		});
 		const { rows: try1 } = await db.executeSql(sql, [JSON.stringify([job])]);
 		if (try1.length === 1) {
@@ -5382,7 +5540,7 @@ var Manager = class extends EventEmitter {
 	}
 	async insert(name, jobs, options = {}) {
 		assert(Array.isArray(jobs), "jobs argument should be an array");
-		const { table, policy } = await this.getQueueCache(name);
+		const { table, policy, notify } = await this.getQueueCache(name);
 		if (policy === QUEUE_POLICIES.key_strict_fifo) {
 			for (const job of jobs) if (!job.singletonKey) throw new Error(`${QUEUE_POLICIES.key_strict_fifo} queues require a singletonKey`);
 		}
@@ -5396,7 +5554,8 @@ var Manager = class extends EventEmitter {
 		const sql = insertJobs(this.config.schema, {
 			table,
 			name,
-			returnId
+			returnId,
+			notify: this.#notifyEnabled(notify)
 		});
 		const { rows } = await db.executeSql(sql, [JSON.stringify(insertPayload)]);
 		if (rows.length) {
@@ -5443,7 +5602,7 @@ var Manager = class extends EventEmitter {
 		}
 		const statements = [];
 		for (const [queueName, queueJobs] of byQueue) {
-			const { table } = await this.getQueueCache(queueName);
+			const { table, notify } = await this.getQueueCache(queueName);
 			const insertPayload = queueJobs.map((j) => {
 				const dependencyCount = dependencyCountByRef.get(j.ref) ?? 0;
 				return {
@@ -5470,19 +5629,13 @@ var Manager = class extends EventEmitter {
 					pendingDependencies: dependencyCount || void 0
 				};
 			});
-			const insertSql = insertJobs(this.config.schema, {
+			statements.push(insertFlowJobs(this.config.schema, {
 				table,
-				name: queueName,
-				returnId: true
-			}).replace("$1", () => serializeJsonParam(insertPayload));
-			statements.push(`
-        WITH ins AS (
-          ${insertSql}
-        )
-        SELECT 1 / (CASE WHEN (SELECT count(*) FROM ins) = ${insertPayload.length} THEN 1 ELSE 0 END)
-      `);
+				name: queueName
+			}, insertPayload));
+			if (this.#notifyEnabled(notify)) statements.push(notifyQueue(this.config.schema, queueName));
 		}
-		if (depRows.length > 0) statements.push(insertDependencies(this.config.schema).replace("$1", () => serializeJsonParam(depRows)));
+		if (depRows.length > 0) statements.push(insertDependencies(this.config.schema, depRows));
 		const db = options.db ?? this.db;
 		const sql = options.db ? statements.join(";\n") : transaction(statements);
 		try {
@@ -5632,16 +5785,17 @@ var Manager = class extends EventEmitter {
 			return this.reinsertFailedJobs(tx, table, jobs, outputData);
 		});
 	}
-	async reinsertFailedJobs(tx, table, jobs, outputData) {
+	async reinsertFailedJobs(tx, table, jobs, outputData, outputById, forceTerminal = false) {
 		const insertSql = insertRetryJob(this.config.schema, table);
 		const dlqSql = insertDeadLetterJob(this.config.schema);
 		let count = 0;
 		for (const job of jobs) {
+			const jobOutput = outputById ? outputById.get(job.id) ?? null : outputData;
 			const retryCount = Number(job.retry_count);
 			const retryLimit = Number(job.retry_limit);
 			const retryDelay = Number(job.retry_delay);
 			const retryDelayMax = job.retry_delay_max != null ? Number(job.retry_delay_max) : null;
-			const canRetry = retryCount < retryLimit;
+			const canRetry = !forceTerminal && retryCount < retryLimit;
 			let retried = false;
 			if (canRetry) {
 				let startAfter = job.start_after;
@@ -5675,7 +5829,7 @@ var Manager = class extends EventEmitter {
 					null,
 					job.keep_until,
 					job.policy,
-					outputData,
+					jobOutput,
 					job.dead_letter,
 					null,
 					job.heartbeat_seconds,
@@ -5709,7 +5863,7 @@ var Manager = class extends EventEmitter {
 					/* @__PURE__ */ new Date(),
 					job.keep_until,
 					job.policy,
-					outputData,
+					jobOutput,
 					job.dead_letter,
 					null,
 					job.heartbeat_seconds,
@@ -5720,7 +5874,7 @@ var Manager = class extends EventEmitter {
 				if (job.dead_letter) await tx.executeSql(dlqSql, [
 					job.dead_letter,
 					job.data,
-					outputData
+					jobOutput
 				]);
 			}
 			count++;
@@ -5880,7 +6034,9 @@ var Manager = class extends EventEmitter {
 		return Object.assign(queue, stats || {
 			deferredCount: 0,
 			queuedCount: 0,
+			readyCount: 0,
 			activeCount: 0,
+			failedCount: 0,
 			totalCount: 0
 		});
 	}
@@ -5943,7 +6099,7 @@ var Manager = class extends EventEmitter {
 };
 //#endregion
 //#region ../../src/boss.ts
-var events$2 = {
+var events$3 = {
 	error: "error",
 	warning: "warning"
 };
@@ -5969,7 +6125,7 @@ var Boss = class extends EventEmitter {
 	#db;
 	#config;
 	#manager;
-	events = events$2;
+	events = events$3;
 	constructor(db, manager, config) {
 		super();
 		this.#db = db;
@@ -6004,8 +6160,8 @@ var Boss = class extends EventEmitter {
 			db: this.#db,
 			schema: this.#config.schema,
 			persistWarnings: this.#config.persistWarnings,
-			warningEvent: events$2.warning,
-			errorEvent: events$2.error
+			warningEvent: events$3.warning,
+			errorEvent: events$3.error
 		};
 	}
 	async #executeQuery(query) {
@@ -6034,7 +6190,7 @@ var Boss = class extends EventEmitter {
 			!this.#stopped && await this.supervise(queues);
 			!this.#stopped && await this.#maintainWarnings();
 		} catch (err) {
-			this.emit(events$2.error, err);
+			this.emit(events$3.error, err);
 		} finally {
 			this.#maintaining = false;
 		}
@@ -6112,7 +6268,7 @@ var Boss = class extends EventEmitter {
 };
 //#endregion
 //#region ../../src/bam.ts
-var events$1 = {
+var events$2 = {
 	error: "error",
 	bam: "bam"
 };
@@ -6122,7 +6278,7 @@ var Bam = class extends EventEmitter {
 	#pollInterval;
 	#db;
 	#config;
-	events = events$1;
+	events = events$2;
 	constructor(db, config) {
 		super();
 		this.#db = db;
@@ -6158,7 +6314,7 @@ var Bam = class extends EventEmitter {
 			const { rows } = await this.#db.executeSql(sql);
 			if (rows.length === 1) await this.#processCommands();
 		} catch (err) {
-			this.emit(events$1.error, err);
+			this.emit(events$2.error, err);
 		} finally {
 			this.#working = false;
 		}
@@ -6167,7 +6323,7 @@ var Bam = class extends EventEmitter {
 		if (this.#stopped) return;
 		const entry = await this.#getNextCommand();
 		if (!entry || this.#stopped) return;
-		this.emit(events$1.bam, {
+		this.emit(events$2.bam, {
 			id: entry.id,
 			name: entry.name,
 			status: "in_progress",
@@ -6178,7 +6334,7 @@ var Bam = class extends EventEmitter {
 			await this.#db.executeSql(entry.command);
 			if (this.#stopped) return;
 			await this.#markCompleted(entry.id);
-			this.emit(events$1.bam, {
+			this.emit(events$2.bam, {
 				id: entry.id,
 				name: entry.name,
 				status: "completed",
@@ -6188,8 +6344,8 @@ var Bam = class extends EventEmitter {
 		} catch (err) {
 			if (this.#stopped) return;
 			await this.#markFailed(entry.id, err);
-			this.emit(events$1.error, err);
-			this.emit(events$1.bam, {
+			this.emit(events$2.error, err);
+			this.emit(events$2.bam, {
 				id: entry.id,
 				name: entry.name,
 				status: "failed",
@@ -6214,6 +6370,76 @@ var Bam = class extends EventEmitter {
 	}
 };
 //#endregion
+//#region ../../src/notifier.ts
+var events$1 = {
+	error: "error",
+	warning: "warning"
+};
+var WARNING_TYPE = "listen_notify_unavailable";
+var Notifier = class extends EventEmitter {
+	events = events$1;
+	#db;
+	#manager;
+	#config;
+	#handle = null;
+	#stopped = true;
+	constructor(db, manager, config) {
+		super();
+		this.#db = db;
+		this.#manager = manager;
+		this.#config = config;
+	}
+	get available() {
+		return this.#handle !== null;
+	}
+	async start() {
+		if (!this.#stopped) return;
+		this.#stopped = false;
+		if (this.#config.noListenNotify) {
+			this.emit(events$1.warning, {
+				message: `useListenNotify is not supported on the ${this.#config.backend} backend. Continuing with polling only.`,
+				data: {
+					type: WARNING_TYPE,
+					backend: this.#config.backend
+				}
+			});
+			return;
+		}
+		if (typeof this.#db.listen !== "function") {
+			this.emit(events$1.warning, {
+				message: "useListenNotify is enabled but the database connection does not support LISTEN/NOTIFY. Continuing with polling only.",
+				data: { type: WARNING_TYPE }
+			});
+			return;
+		}
+		try {
+			const { rows } = await this.#db.executeSql(`SELECT ${notifyChannelSql(this.#config.schema)} AS channel`);
+			const channel = rows[0].channel;
+			this.#handle = await this.#db.listen(channel, (payload) => this.#manager.notifyQueue(payload), () => this.#manager.forceFetchLnWorkers());
+		} catch (err) {
+			this.emit(events$1.warning, {
+				message: "Failed to start LISTEN/NOTIFY listener. Continuing with polling only.",
+				data: {
+					type: WARNING_TYPE,
+					error: err?.message
+				}
+			});
+		}
+	}
+	async stop() {
+		if (this.#stopped) return;
+		this.#stopped = true;
+		if (this.#handle) {
+			try {
+				await this.#handle.close();
+			} catch (err) {
+				this.emit(events$1.error, err);
+			}
+			this.#handle = null;
+		}
+	}
+};
+//#endregion
 //#region ../../src/db.ts
 var Db = class extends EventEmitter {
 	pool;
@@ -6245,6 +6471,63 @@ var Db = class extends EventEmitter {
 		assert(this.opened, "Database not opened. Call open() before executing SQL.");
 		return await this.pool.query(text, values);
 	}
+	async listen(channel, onNotification, onReconnect) {
+		assert(this.opened, "Database not opened. Call open() before listening.");
+		let closed = false;
+		let client = null;
+		let reconnectTimer = null;
+		let attempt = 0;
+		const scheduleReconnect = () => {
+			if (closed || reconnectTimer) return;
+			const backoff = Math.min(3e4, 1e3 * 2 ** Math.min(attempt, 5));
+			attempt++;
+			reconnectTimer = setTimeout(() => {
+				reconnectTimer = null;
+				connect().catch(() => scheduleReconnect());
+			}, backoff);
+		};
+		const connect = async () => {
+			if (closed) return;
+			const next = new pg.Client(this.config);
+			next.on("error", (error) => {
+				this.emit("error", error);
+				if (!closed) {
+					next.removeAllListeners();
+					next.end().catch(() => {});
+					if (client === next) client = null;
+					scheduleReconnect();
+				}
+			});
+			next.on("notification", (msg) => {
+				if (msg.payload !== void 0) onNotification(msg.payload);
+			});
+			client = next;
+			try {
+				await next.connect();
+				await next.query(`LISTEN "${channel}"`);
+			} catch (err) {
+				next.removeAllListeners();
+				await next.end().catch(() => {});
+				if (client === next) client = null;
+				throw err;
+			}
+			attempt = 0;
+			onReconnect();
+		};
+		await connect();
+		return { close: async () => {
+			closed = true;
+			if (reconnectTimer) {
+				clearTimeout(reconnectTimer);
+				reconnectTimer = null;
+			}
+			if (client) {
+				client.removeAllListeners();
+				await client.end().catch(() => {});
+				client = null;
+			}
+		} };
+	}
 	async withTransaction(fn) {
 		assert(this.opened, "Database not opened. Call open() before executing SQL.");
 		const client = await this.pool.connect();
@@ -6282,6 +6565,7 @@ var PgBoss = class extends EventEmitter {
 	#manager;
 	#timekeeper;
 	#bam;
+	#notifier;
 	constructor(value) {
 		super();
 		this.#stoppingOn = null;
@@ -6297,15 +6581,19 @@ var PgBoss = class extends EventEmitter {
 		const timekeeper = new Timekeeper(db, manager, config);
 		manager.timekeeper = timekeeper;
 		const bam = new Bam(db, config);
+		const notifier = new Notifier(db, manager, config);
+		manager.notifier = notifier;
 		this.#promoteEvents(manager);
 		this.#promoteEvents(boss);
 		this.#promoteEvents(timekeeper);
 		this.#promoteEvents(bam);
+		this.#promoteEvents(notifier);
 		this.#boss = boss;
 		this.#contractor = contractor;
 		this.#manager = manager;
 		this.#timekeeper = timekeeper;
 		this.#bam = bam;
+		this.#notifier = notifier;
 	}
 	#promoteEvents(emitter) {
 		for (const event of Object.values(emitter?.events)) emitter.on(event, (arg) => this.emit(event, arg));
@@ -6319,6 +6607,7 @@ var PgBoss = class extends EventEmitter {
 			if (this.#config.migrate) await this.#contractor.start();
 			else await this.#contractor.check();
 			await this.#manager.start();
+			if (this.#config.useListenNotify) await this.#notifier.start();
 			if (this.#config.supervise) await this.#boss.start();
 			if (this.#config.schedule) await this.#timekeeper.start();
 			if (this.#config.migrate) await this.#bam.start();
@@ -6348,6 +6637,7 @@ var PgBoss = class extends EventEmitter {
 		let { close = true, graceful = true, timeout = 3e4 } = options;
 		timeout = Math.max(timeout, 1e3);
 		this.#stoppingOn = Date.now();
+		await this.#notifier.stop();
 		await this.#manager.stop();
 		await this.#timekeeper.stop();
 		await this.#boss.stop();
@@ -6514,7 +6804,7 @@ var PgBoss = class extends EventEmitter {
 		return rows;
 	}
 	async getBamEntries() {
-		const sql = getBamEntries(this.#config.schema);
+		const sql = getBamEntries$1(this.#config.schema);
 		const { rows } = await this.#db.executeSql(sql);
 		return rows;
 	}
@@ -6609,7 +6899,9 @@ var QUEUE_COLUMNS = `
   deletion_seconds as "deleteAfterSeconds",
   deferred_count as "deferredCount",
   queued_count as "queuedCount",
+  GREATEST(queued_count - deferred_count, 0) as "readyCount",
   active_count as "activeCount",
+  failed_count as "failedCount",
   total_count as "totalCount",
   warning_queued as "warningQueueSize",
   singletons_active as "singletonsActive",
@@ -6862,19 +7154,81 @@ async function getWarningCount(dbUrl, schema, type) {
 		throw err;
 	}
 }
+async function getBamEntries(dbUrl, schema, options = {}) {
+	const s = validateIdentifier(schema);
+	const { status = null, limit = 200, offset = 0 } = options;
+	const sql = `
+    SELECT
+      id,
+      name,
+      version,
+      status,
+      queue,
+      table_name as "table",
+      command,
+      error,
+      created_on as "createdOn",
+      started_on as "startedOn",
+      completed_on as "completedOn"
+    FROM ${s}.bam
+    WHERE ($1::text IS NULL OR status = $1)
+    ORDER BY version DESC, created_on DESC
+    LIMIT $2 OFFSET $3
+  `;
+	try {
+		return await query(dbUrl, sql, [
+			status,
+			limit,
+			offset
+		]);
+	} catch (err) {
+		if (err && typeof err === "object" && "code" in err && err.code === "42P01") return [];
+		throw err;
+	}
+}
+async function getBamCount(dbUrl, schema, status) {
+	const sql = `
+    SELECT COUNT(*)::int as count
+    FROM ${validateIdentifier(schema)}.bam
+    WHERE ($1::text IS NULL OR status = $1)
+  `;
+	try {
+		return (await queryOne(dbUrl, sql, [status ?? null]))?.count ?? 0;
+	} catch (err) {
+		if (err && typeof err === "object" && "code" in err && err.code === "42P01") return 0;
+		throw err;
+	}
+}
+async function getBamStatusSummary(dbUrl, schema) {
+	const sql = `
+    SELECT status, count(*)::int as count, max(created_on) as "lastCreatedOn"
+    FROM ${validateIdentifier(schema)}.bam
+    GROUP BY status
+  `;
+	try {
+		return await query(dbUrl, sql);
+	} catch (err) {
+		if (err && typeof err === "object" && "code" in err && err.code === "42P01") return [];
+		throw err;
+	}
+}
 async function getQueueStats(dbUrl, schema) {
 	return await queryOne(dbUrl, `
     SELECT
       COALESCE(SUM(deferred_count), 0)::int as "totalDeferred",
       COALESCE(SUM(queued_count), 0)::int as "totalQueued",
+      COALESCE(SUM(GREATEST(queued_count - deferred_count, 0)), 0)::int as "totalReady",
       COALESCE(SUM(active_count), 0)::int as "totalActive",
+      COALESCE(SUM(failed_count), 0)::int as "totalFailed",
       COALESCE(SUM(total_count), 0)::int as "totalJobs",
       COUNT(*)::int as "queueCount"
     FROM ${validateIdentifier(schema)}.queue
   `) ?? {
 		totalDeferred: 0,
 		totalQueued: 0,
+		totalReady: 0,
 		totalActive: 0,
+		totalFailed: 0,
 		totalJobs: 0,
 		queueCount: 0
 	};
@@ -6975,9 +7329,21 @@ var statCards = [
 	{
 		name: "Queued Jobs",
 		key: "totalQueued",
-		hint: "waiting to process",
+		hint: "incl. deferred",
+		accent: "neutral"
+	},
+	{
+		name: "Deferred",
+		key: "totalDeferred",
+		hint: "scheduled for later",
 		accent: "neutral"
 	},
+	{
+		name: "Ready",
+		key: "totalReady",
+		hint: "ready to process",
+		accent: "primary"
+	},
 	{
 		name: "Active",
 		key: "totalActive",
@@ -6985,9 +7351,9 @@ var statCards = [
 		accent: "primary"
 	},
 	{
-		name: "Deferred",
-		key: "totalDeferred",
-		hint: "scheduled for later",
+		name: "Failed",
+		key: "totalFailed",
+		hint: "recent failures",
 		accent: "neutral"
 	},
 	{
@@ -7199,34 +7565,45 @@ function ErrorCard({ title, message = "Please check your database connection and
 //#endregion
 //#region app/routes/_index.tsx
 var _index_exports = /* @__PURE__ */ __exportAll({
-	ErrorBoundary: () => ErrorBoundary$10,
+	ErrorBoundary: () => ErrorBoundary$11,
 	default: () => _index_default,
-	loader: () => loader$10
+	loader: () => loader$11
 });
-async function loader$10({ context }) {
+async function loader$11({ context }) {
 	const { DB_URL, SCHEMA } = context.get(dbContext);
-	const [warnings, stats, topQueues, totalQueues, problemQueuesCount] = await Promise.all([
+	const [warnings, stats, topQueues, totalQueues, problemQueuesCount, bamSummary] = await Promise.all([
 		getWarnings(DB_URL, SCHEMA, { limit: 5 }),
 		getQueueStats(DB_URL, SCHEMA),
 		getTopQueues(DB_URL, SCHEMA, 5),
 		getQueueCount(DB_URL, SCHEMA),
-		getProblemQueuesCount(DB_URL, SCHEMA)
+		getProblemQueuesCount(DB_URL, SCHEMA),
+		getBamStatusSummary(DB_URL, SCHEMA)
 	]);
 	return {
 		stats,
 		warnings,
 		topQueues,
+		migrations: bamSummary.reduce((acc, row) => {
+			if (row.status === "pending") acc.pending += row.count;
+			else if (row.status === "in_progress") acc.inProgress += row.count;
+			else if (row.status === "failed") acc.failed += row.count;
+			return acc;
+		}, {
+			pending: 0,
+			inProgress: 0,
+			failed: 0
+		}),
 		queueStats: {
 			totalQueues,
 			problemQueues: problemQueuesCount
 		}
 	};
 }
-var ErrorBoundary$10 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
+var ErrorBoundary$11 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
 	return /* @__PURE__ */ jsx(ErrorCard, { title: "Failed to load dashboard" });
 });
 var _index_default = UNSAFE_withComponentProps(function Overview({ loaderData }) {
-	const { stats, warnings, topQueues } = loaderData;
+	const { stats, warnings, topQueues, migrations } = loaderData;
 	return /* @__PURE__ */ jsxs("div", { children: [
 		/* @__PURE__ */ jsx(PageHeader, {
 			title: "Overview",
@@ -7241,9 +7618,10 @@ var _index_default = UNSAFE_withComponentProps(function Overview({ loaderData })
 			})
 		}),
 		/* @__PURE__ */ jsx("div", {
-			className: "grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-4 mb-4",
+			className: "grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-6 mb-4",
 			children: /* @__PURE__ */ jsx(StatsCards, { stats })
 		}),
+		/* @__PURE__ */ jsx(MigrationsBanner, { migrations }),
 		/* @__PURE__ */ jsxs("div", {
 			className: "grid grid-cols-1 lg:grid-cols-[1.5fr_1fr] gap-4",
 			children: [/* @__PURE__ */ jsxs(Card, { children: [/* @__PURE__ */ jsxs(CardHeader, { children: [/* @__PURE__ */ jsx(CardTitle, { children: "Top Queues" }), /* @__PURE__ */ jsx(DbLink, {
@@ -7312,6 +7690,37 @@ var _index_default = UNSAFE_withComponentProps(function Overview({ loaderData })
 		})
 	] });
 });
+function MigrationsBanner({ migrations }) {
+	const { pending, inProgress, failed } = migrations;
+	if (pending === 0 && inProgress === 0 && failed === 0) return null;
+	const parts = [];
+	if (pending > 0) parts.push(`${pending.toLocaleString()} pending`);
+	if (inProgress > 0) parts.push(`${inProgress.toLocaleString()} in progress`);
+	if (failed > 0) parts.push(`${failed.toLocaleString()} failed`);
+	return /* @__PURE__ */ jsx(DbLink, {
+		to: "/migrations",
+		className: "block mb-4",
+		children: /* @__PURE__ */ jsxs(Card, {
+			className: "flex items-center gap-3 px-4 py-3 hover:bg-[var(--surface-hover)]",
+			children: [
+				/* @__PURE__ */ jsx(Badge, {
+					variant: failed > 0 ? "error" : "warning",
+					size: "sm",
+					dot: true,
+					children: "Async migrations"
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "text-sm text-[var(--text-secondary)]",
+					children: parts.join(" · ")
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "ml-auto text-sm font-medium text-primary-600 dark:text-primary-400",
+					children: "View"
+				})
+			]
+		})
+	});
+}
 function QueueStatusBadge({ queue }) {
 	if ((queue.warningQueueSize ?? 0) > 0 && queue.queuedCount > (queue.warningQueueSize ?? 0)) return /* @__PURE__ */ jsx(Badge, {
 		variant: "error",
@@ -7826,10 +8235,10 @@ function SearchIcon$1({ className }) {
 //#endregion
 //#region app/routes/jobs.tsx
 var jobs_exports = /* @__PURE__ */ __exportAll({
-	ErrorBoundary: () => ErrorBoundary$9,
+	ErrorBoundary: () => ErrorBoundary$10,
 	buildSearchParams: () => buildSearchParams,
 	default: () => jobs_default,
-	loader: () => loader$9,
+	loader: () => loader$10,
 	parseFiltersFromUrl: () => parseFiltersFromUrl
 });
 function parseFiltersFromUrl(searchParams) {
@@ -7866,7 +8275,7 @@ function parseFiltersFromUrl(searchParams) {
 		shouldRunCount
 	};
 }
-async function loader$9({ request, context }) {
+async function loader$10({ request, context }) {
 	const { DB_URL, SCHEMA } = context.get(dbContext);
 	const url = new URL(request.url);
 	const parsed = parseFiltersFromUrl(url.searchParams);
@@ -7914,7 +8323,7 @@ async function loader$9({ request, context }) {
 		hasPrevPage
 	};
 }
-var ErrorBoundary$9 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
+var ErrorBoundary$10 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
 	return /* @__PURE__ */ jsx(ErrorCard, { title: "Failed to load jobs" });
 });
 function buildSearchParams(filters) {
@@ -8094,11 +8503,11 @@ function Chip({ label, onRemove }) {
 //#endregion
 //#region app/routes/queues._index.tsx
 var queues__index_exports = /* @__PURE__ */ __exportAll({
-	ErrorBoundary: () => ErrorBoundary$8,
+	ErrorBoundary: () => ErrorBoundary$9,
 	default: () => queues__index_default,
-	loader: () => loader$8
+	loader: () => loader$9
 });
-async function loader$8({ request, context }) {
+async function loader$9({ request, context }) {
 	const { DB_URL, SCHEMA } = context.get(dbContext);
 	const url = new URL(request.url);
 	const page = parsePageNumber(url.searchParams.get("page"));
@@ -8131,7 +8540,7 @@ async function loader$8({ request, context }) {
 		search
 	};
 }
-var ErrorBoundary$8 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
+var ErrorBoundary$9 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
 	return /* @__PURE__ */ jsx("div", {
 		className: "p-6",
 		children: /* @__PURE__ */ jsx(Card, { children: /* @__PURE__ */ jsxs(CardContent, {
@@ -8297,13 +8706,21 @@ var queues__index_default = UNSAFE_withComponentProps(function QueuesIndex({ loa
 						className: "text-right",
 						children: "Queued"
 					}),
+					/* @__PURE__ */ jsx(TableHead, {
+						className: "text-right",
+						children: "Deferred"
+					}),
+					/* @__PURE__ */ jsx(TableHead, {
+						className: "text-right",
+						children: "Ready"
+					}),
 					/* @__PURE__ */ jsx(TableHead, {
 						className: "text-right",
 						children: "Active"
 					}),
 					/* @__PURE__ */ jsx(TableHead, {
 						className: "text-right",
-						children: "Deferred"
+						children: "Failed"
 					}),
 					/* @__PURE__ */ jsx(TableHead, {
 						className: "text-right",
@@ -8313,7 +8730,7 @@ var queues__index_default = UNSAFE_withComponentProps(function QueuesIndex({ loa
 					/* @__PURE__ */ jsx(TableHead, { children: "Status" })
 				] }) }), /* @__PURE__ */ jsx(TableBody, { children: queues.length === 0 ? /* @__PURE__ */ jsx(TableRow, { children: /* @__PURE__ */ jsx(TableCell, {
 					className: "text-center text-[var(--text-tertiary)] py-8",
-					colSpan: 9,
+					colSpan: 11,
 					children: "No queues found"
 				}) }) : queues.map((queue) => {
 					const hasBacklog = (queue.warningQueueSize ?? 0) > 0 && queue.queuedCount > (queue.warningQueueSize ?? 0);
@@ -8336,13 +8753,21 @@ var queues__index_default = UNSAFE_withComponentProps(function QueuesIndex({ loa
 							className: "text-right pgb-num text-[var(--text-primary)]",
 							children: queue.queuedCount.toLocaleString()
 						}),
+						/* @__PURE__ */ jsx(TableCell, {
+							className: "text-right pgb-num text-[var(--text-primary)]",
+							children: queue.deferredCount.toLocaleString()
+						}),
+						/* @__PURE__ */ jsx(TableCell, {
+							className: "text-right pgb-num text-[var(--text-primary)]",
+							children: queue.readyCount.toLocaleString()
+						}),
 						/* @__PURE__ */ jsx(TableCell, {
 							className: "text-right pgb-num text-[var(--text-primary)]",
 							children: queue.activeCount.toLocaleString()
 						}),
 						/* @__PURE__ */ jsx(TableCell, {
 							className: "text-right pgb-num text-[var(--text-primary)]",
-							children: queue.deferredCount.toLocaleString()
+							children: queue.failedCount.toLocaleString()
 						}),
 						/* @__PURE__ */ jsx(TableCell, {
 							className: "text-right pgb-num text-[var(--text-primary)]",
@@ -8520,12 +8945,12 @@ var SelectContent = ({ children }) => /* @__PURE__ */ jsx(Fragment, { children }
 //#endregion
 //#region app/routes/queues.create.tsx
 var queues_create_exports = /* @__PURE__ */ __exportAll({
-	ErrorBoundary: () => ErrorBoundary$7,
+	ErrorBoundary: () => ErrorBoundary$8,
 	action: () => action$5,
 	default: () => queues_create_default,
-	loader: () => loader$7
+	loader: () => loader$8
 });
-async function loader$7({ context }) {
+async function loader$8({ context }) {
 	const { DB_URL, SCHEMA } = context.get(dbContext);
 	return { queues: await getQueues(DB_URL, SCHEMA) };
 }
@@ -8593,7 +9018,7 @@ async function action$5({ request, context }) {
 	const dbParam = new URL(request.url).searchParams.get("db");
 	return redirect(dbParam ? `/queues/${encodeURIComponent(queueName.trim())}?db=${encodeURIComponent(dbParam)}` : `/queues/${encodeURIComponent(queueName.trim())}`);
 }
-var ErrorBoundary$7 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
+var ErrorBoundary$8 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
 	return /* @__PURE__ */ jsx(ErrorCard, {
 		title: "Failed to load queue creation page",
 		backTo: {
@@ -9041,12 +9466,12 @@ DialogDescription.displayName = "DialogDescription";
 //#endregion
 //#region app/routes/queues.$name.tsx
 var queues_$name_exports = /* @__PURE__ */ __exportAll({
-	ErrorBoundary: () => ErrorBoundary$6,
+	ErrorBoundary: () => ErrorBoundary$7,
 	action: () => action$4,
 	default: () => queues_$name_default,
-	loader: () => loader$6
+	loader: () => loader$7
 });
-async function loader$6({ params, request, context }) {
+async function loader$7({ params, request, context }) {
 	const { DB_URL, SCHEMA } = context.get(dbContext);
 	const url = new URL(request.url);
 	const stateParam = url.searchParams.get("state");
@@ -9119,7 +9544,7 @@ async function action$4({ params, request, context }) {
 		message
 	};
 }
-var ErrorBoundary$6 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
+var ErrorBoundary$7 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
 	return /* @__PURE__ */ jsx(ErrorCard, {
 		title: "Failed to load queue",
 		backTo: {
@@ -9178,13 +9603,23 @@ var queues_$name_default = UNSAFE_withComponentProps(function QueueDetail({ load
 				]
 			}),
 			/* @__PURE__ */ jsxs("div", {
-				className: "grid grid-cols-2 sm:grid-cols-4 gap-4",
+				className: "grid grid-cols-2 sm:grid-cols-3 lg:grid-cols-6 gap-4",
 				children: [
 					/* @__PURE__ */ jsx(StatCard, {
 						label: "Queued",
 						value: queue.queuedCount.toLocaleString(),
 						accent: overThreshold ? "error" : "neutral",
-						hint: overThreshold ? "over threshold" : "within threshold"
+						hint: overThreshold ? "over threshold" : "incl. deferred"
+					}),
+					/* @__PURE__ */ jsx(StatCard, {
+						label: "Deferred",
+						value: queue.deferredCount.toLocaleString()
+					}),
+					/* @__PURE__ */ jsx(StatCard, {
+						label: "Ready",
+						value: queue.readyCount.toLocaleString(),
+						accent: "primary",
+						hint: "ready to process"
 					}),
 					/* @__PURE__ */ jsx(StatCard, {
 						label: "Active",
@@ -9192,8 +9627,9 @@ var queues_$name_default = UNSAFE_withComponentProps(function QueueDetail({ load
 						accent: "primary"
 					}),
 					/* @__PURE__ */ jsx(StatCard, {
-						label: "Deferred",
-						value: queue.deferredCount.toLocaleString()
+						label: "Failed",
+						value: queue.failedCount.toLocaleString(),
+						hint: "recent failures"
 					}),
 					/* @__PURE__ */ jsx(StatCard, {
 						label: "Total",
@@ -9539,12 +9975,12 @@ function ConfirmDialog({ title, description, confirmLabel, confirmVariant = "pri
 //#endregion
 //#region app/routes/queues.$name.jobs.$jobId.tsx
 var queues_$name_jobs_$jobId_exports = /* @__PURE__ */ __exportAll({
-	ErrorBoundary: () => ErrorBoundary$5,
+	ErrorBoundary: () => ErrorBoundary$6,
 	action: () => action$3,
 	default: () => queues_$name_jobs_$jobId_default,
-	loader: () => loader$5
+	loader: () => loader$6
 });
-async function loader$5({ params, context }) {
+async function loader$6({ params, context }) {
 	const { DB_URL, SCHEMA } = context.get(dbContext);
 	const job = await getJobById(DB_URL, SCHEMA, params.name, params.jobId);
 	if (!job) throw new Response("Job not found", { status: 404 });
@@ -9598,7 +10034,7 @@ async function action$3({ params, request, context }) {
 		message
 	};
 }
-var ErrorBoundary$5 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
+var ErrorBoundary$6 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
 	return /* @__PURE__ */ jsx(ErrorCard, {
 		title: "Failed to load job",
 		backTo: {
@@ -9851,11 +10287,11 @@ function ConfigItem({ label, value, mono = false }) {
 //#endregion
 //#region app/routes/schedules.tsx
 var schedules_exports = /* @__PURE__ */ __exportAll({
-	ErrorBoundary: () => ErrorBoundary$4,
+	ErrorBoundary: () => ErrorBoundary$5,
 	default: () => schedules_default,
-	loader: () => loader$4
+	loader: () => loader$5
 });
-async function loader$4({ request, context }) {
+async function loader$5({ request, context }) {
 	const { DB_URL, SCHEMA } = context.get(dbContext);
 	const page = parsePageNumber(new URL(request.url).searchParams.get("page"));
 	const limit = 20;
@@ -9873,7 +10309,7 @@ async function loader$4({ request, context }) {
 		hasPrevPage: page > 1
 	};
 }
-var ErrorBoundary$4 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
+var ErrorBoundary$5 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
 	return /* @__PURE__ */ jsx(ErrorCard, { title: "Failed to load schedules" });
 });
 function cronHuman(cron) {
@@ -9983,12 +10419,12 @@ var schedules_default = UNSAFE_withComponentProps(function Schedules({ loaderDat
 //#endregion
 //#region app/routes/schedules.$name.$key.tsx
 var schedules_$name_$key_exports = /* @__PURE__ */ __exportAll({
-	ErrorBoundary: () => ErrorBoundary$3,
+	ErrorBoundary: () => ErrorBoundary$4,
 	action: () => action$2,
 	default: () => schedules_$name_$key_default,
-	loader: () => loader$3
+	loader: () => loader$4
 });
-async function loader$3({ params, context }) {
+async function loader$4({ params, context }) {
 	const { DB_URL, SCHEMA } = context.get(dbContext);
 	const key = params.key === "__default__" ? "" : params.key;
 	const schedule = await getSchedule(DB_URL, SCHEMA, params.name, key);
@@ -10006,7 +10442,7 @@ async function action$2({ params, request, context }) {
 	}
 	return { error: "Invalid action" };
 }
-var ErrorBoundary$3 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
+var ErrorBoundary$4 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
 	return /* @__PURE__ */ jsx(ErrorCard, {
 		title: "Failed to load schedule",
 		backTo: {
@@ -10166,12 +10602,12 @@ var schedules_$name_$key_default = UNSAFE_withComponentProps(function ScheduleDe
 //#endregion
 //#region app/routes/schedules.new.tsx
 var schedules_new_exports = /* @__PURE__ */ __exportAll({
-	ErrorBoundary: () => ErrorBoundary$2,
+	ErrorBoundary: () => ErrorBoundary$3,
 	action: () => action$1,
 	default: () => schedules_new_default,
-	loader: () => loader$2
+	loader: () => loader$3
 });
-async function loader$2({ context }) {
+async function loader$3({ context }) {
 	const { DB_URL, SCHEMA } = context.get(dbContext);
 	return { queues: await getQueues(DB_URL, SCHEMA) };
 }
@@ -10224,7 +10660,7 @@ async function action$1({ request, context }) {
 	const dbParam = new URL(request.url).searchParams.get("db");
 	return redirect(dbParam ? `/schedules?db=${encodeURIComponent(dbParam)}` : `/schedules`);
 }
-var ErrorBoundary$2 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
+var ErrorBoundary$3 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
 	return /* @__PURE__ */ jsx(ErrorCard, {
 		title: "Failed to load schedule creation",
 		backTo: {
@@ -10490,12 +10926,12 @@ var schedules_new_default = UNSAFE_withComponentProps(function CreateSchedule({
 //#endregion
 //#region app/routes/send.tsx
 var send_exports = /* @__PURE__ */ __exportAll({
-	ErrorBoundary: () => ErrorBoundary$1,
+	ErrorBoundary: () => ErrorBoundary$2,
 	action: () => action,
 	default: () => send_default,
-	loader: () => loader$1
+	loader: () => loader$2
 });
-async function loader$1({ context }) {
+async function loader$2({ context }) {
 	const { DB_URL, SCHEMA } = context.get(dbContext);
 	return { queues: await getQueues(DB_URL, SCHEMA) };
 }
@@ -10545,7 +10981,7 @@ async function action({ request, context }) {
 	const dbParam = new URL(request.url).searchParams.get("db");
 	return redirect(dbParam ? `/queues/${encodeURIComponent(queueName.trim())}?db=${encodeURIComponent(dbParam)}` : `/queues/${encodeURIComponent(queueName.trim())}`);
 }
-var ErrorBoundary$1 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
+var ErrorBoundary$2 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
 	return /* @__PURE__ */ jsx(ErrorCard, {
 		title: "Failed to load job sending page",
 		backTo: {
@@ -10777,6 +11213,182 @@ var send_default = UNSAFE_withComponentProps(function SendJob({ loaderData }) {
 	});
 });
 //#endregion
+//#region app/routes/migrations.tsx
+var migrations_exports = /* @__PURE__ */ __exportAll({
+	ErrorBoundary: () => ErrorBoundary$1,
+	default: () => migrations_default,
+	loader: () => loader$1
+});
+var PAGE_SIZE = 50;
+var STATUS_ACCENT = {
+	pending: "warning",
+	in_progress: "primary",
+	completed: "success",
+	failed: "error"
+};
+async function loader$1({ request, context }) {
+	const { DB_URL, SCHEMA } = context.get(dbContext);
+	const url = new URL(request.url);
+	const statusParam = url.searchParams.get("status");
+	const statusFilter = isValidBamStatus(statusParam) ? statusParam : null;
+	const page = parsePageNumber(url.searchParams.get("page"));
+	const offset = (page - 1) * PAGE_SIZE;
+	const [entries, totalCount, summary] = await Promise.all([
+		getBamEntries(DB_URL, SCHEMA, {
+			status: statusFilter,
+			limit: PAGE_SIZE,
+			offset
+		}),
+		getBamCount(DB_URL, SCHEMA, statusFilter),
+		getBamStatusSummary(DB_URL, SCHEMA)
+	]);
+	return {
+		entries,
+		summary,
+		statusFilter,
+		page,
+		totalPages: Math.ceil(totalCount / PAGE_SIZE)
+	};
+}
+var ErrorBoundary$1 = UNSAFE_withErrorBoundaryProps(function ErrorBoundary() {
+	return /* @__PURE__ */ jsx(ErrorCard, {
+		title: "Failed to load migrations",
+		backTo: {
+			href: "/",
+			label: "Back to Dashboard"
+		}
+	});
+});
+var migrations_default = UNSAFE_withComponentProps(function Migrations({ loaderData }) {
+	const { entries, summary, statusFilter, page, totalPages } = loaderData;
+	const [searchParams, setSearchParams] = useSearchParams();
+	const counts = countByStatus(summary);
+	const handleFilterChange = (key, value) => {
+		const params = new URLSearchParams(searchParams);
+		if (value) params.set(key, value);
+		else params.delete(key);
+		params.delete("page");
+		setSearchParams(params);
+	};
+	const handlePageChange = (newPage) => {
+		const params = new URLSearchParams(searchParams);
+		params.set("page", newPage.toString());
+		setSearchParams(params);
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		className: "space-y-4",
+		children: [
+			/* @__PURE__ */ jsx(PageHeader, {
+				title: "Migrations",
+				subtitle: "Background async migrations (BAM) — schema changes such as concurrent index builds that run outside the install transaction"
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "grid grid-cols-2 gap-4 lg:grid-cols-4",
+				children: BAM_STATUSES.map((status) => /* @__PURE__ */ jsx(StatCard, {
+					label: BAM_STATUS_LABELS[status],
+					value: counts[status].toLocaleString(),
+					accent: counts[status] > 0 ? STATUS_ACCENT[status] : "neutral"
+				}, status))
+			}),
+			/* @__PURE__ */ jsxs(Card, { children: [
+				/* @__PURE__ */ jsxs(CardHeader, { children: [/* @__PURE__ */ jsx(CardTitle, { children: "Migration commands" }), /* @__PURE__ */ jsx(FilterSelect, {
+					value: statusFilter,
+					options: BAM_STATUS_OPTIONS,
+					onChange: (value) => handleFilterChange("status", value)
+				})] }),
+				/* @__PURE__ */ jsx(CardContent, {
+					className: "p-0",
+					children: /* @__PURE__ */ jsxs(Table, { children: [/* @__PURE__ */ jsx(TableHeader, { children: /* @__PURE__ */ jsxs(TableRow, { children: [
+						/* @__PURE__ */ jsx(TableHead, { children: "Name" }),
+						/* @__PURE__ */ jsx(TableHead, {
+							className: "text-right",
+							children: "Ver"
+						}),
+						/* @__PURE__ */ jsx(TableHead, { children: "Status" }),
+						/* @__PURE__ */ jsx(TableHead, { children: "Table" }),
+						/* @__PURE__ */ jsx(TableHead, { children: "Created" }),
+						/* @__PURE__ */ jsx(TableHead, { children: "Started" }),
+						/* @__PURE__ */ jsx(TableHead, { children: "Completed" }),
+						/* @__PURE__ */ jsx(TableHead, { children: "Command / Error" })
+					] }) }), /* @__PURE__ */ jsx(TableBody, { children: entries.length === 0 ? /* @__PURE__ */ jsx(TableRow, { children: /* @__PURE__ */ jsx(TableCell, {
+						className: "text-center text-[var(--text-tertiary)] py-8",
+						colSpan: 8,
+						children: statusFilter ? `No ${BAM_STATUS_LABELS[statusFilter].toLowerCase()} migrations found` : "No async migrations recorded."
+					}) }) : entries.map((entry) => /* @__PURE__ */ jsxs(TableRow, { children: [
+						/* @__PURE__ */ jsx(TableCell, {
+							className: "text-[var(--text-primary)] font-medium",
+							children: entry.name
+						}),
+						/* @__PURE__ */ jsx(TableCell, {
+							className: "text-right pgb-num text-[var(--text-tertiary)]",
+							children: entry.version
+						}),
+						/* @__PURE__ */ jsx(TableCell, { children: /* @__PURE__ */ jsx(Badge, {
+							variant: BAM_STATUS_VARIANTS[entry.status],
+							size: "sm",
+							dot: true,
+							children: BAM_STATUS_LABELS[entry.status]
+						}) }),
+						/* @__PURE__ */ jsxs(TableCell, {
+							className: "font-mono text-xs text-[var(--text-secondary)] whitespace-nowrap",
+							children: [entry.table, entry.queue ? /* @__PURE__ */ jsxs("span", {
+								className: "text-[var(--text-tertiary)]",
+								children: [" · ", entry.queue]
+							}) : null]
+						}),
+						/* @__PURE__ */ jsx(TableCell, {
+							className: "pgb-num text-[var(--text-tertiary)] whitespace-nowrap",
+							children: formatTimestamp(entry.createdOn)
+						}),
+						/* @__PURE__ */ jsx(TableCell, {
+							className: "pgb-num text-[var(--text-tertiary)] whitespace-nowrap",
+							children: formatTimestamp(entry.startedOn)
+						}),
+						/* @__PURE__ */ jsx(TableCell, {
+							className: "pgb-num text-[var(--text-tertiary)] whitespace-nowrap",
+							children: formatTimestamp(entry.completedOn)
+						}),
+						/* @__PURE__ */ jsxs(TableCell, {
+							className: "max-w-md",
+							children: [entry.error ? /* @__PURE__ */ jsx("p", {
+								className: "mb-1 font-mono text-xs text-[var(--error-600)] break-words whitespace-pre-wrap",
+								children: entry.error
+							}) : null, /* @__PURE__ */ jsxs("details", { children: [/* @__PURE__ */ jsx("summary", {
+								className: "cursor-pointer text-xs text-[var(--text-tertiary)] select-none",
+								children: "View command"
+							}), /* @__PURE__ */ jsx("pre", {
+								className: "mt-1 overflow-x-auto rounded bg-[var(--surface-sunken)] p-2 font-mono text-xs text-[var(--text-secondary)] whitespace-pre-wrap",
+								children: entry.command
+							})] })]
+						})
+					] }, entry.id)) })] })
+				}),
+				/* @__PURE__ */ jsx(Pagination, {
+					page,
+					totalPages,
+					hasNextPage: page < totalPages,
+					hasPrevPage: page > 1,
+					onPageChange: handlePageChange
+				})
+			] })
+		]
+	});
+});
+function formatTimestamp(value) {
+	if (!value) return "—";
+	return formatDateWithSeconds(new Date(value));
+}
+function countByStatus(summary) {
+	const counts = {
+		pending: 0,
+		in_progress: 0,
+		completed: 0,
+		failed: 0
+	};
+	for (const row of summary) if (row.status in counts) counts[row.status] += row.count;
+	return counts;
+}
+//#endregion
 //#region app/routes/warnings.tsx
 var warnings_exports = /* @__PURE__ */ __exportAll({
 	ErrorBoundary: () => ErrorBoundary,
@@ -10888,8 +11500,8 @@ function WarningTypeBadge({ type }) {
 //#region \0virtual:react-router/server-manifest
 var server_manifest_default = {
 	"entry": {
-		"module": "/assets/entry.client-DL_oPh96.js",
-		"imports": ["/assets/jsx-runtime-BgbGXvsu.js", "/assets/react-dom-QnGHOQwT.js"],
+		"module": "/assets/entry.client-CqyjuPDB.js",
+		"imports": ["/assets/jsx-runtime-RQyiN6Nr.js", "/assets/react-dom-D_m_Zgd3.js"],
 		"css": []
 	},
 	"routes": {
@@ -10906,16 +11518,16 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/root-Df70GAY3.js",
+			"module": "/assets/root-qxoeL6W3.js",
 			"imports": [
-				"/assets/jsx-runtime-BgbGXvsu.js",
-				"/assets/react-dom-QnGHOQwT.js",
-				"/assets/db-link-BWWnHM0k.js",
-				"/assets/MenuTrigger-BhalG0aG.js",
-				"/assets/createLucideIcon-DVP_i62f.js",
-				"/assets/useOpenInteractionType-D3JsvupP.js"
+				"/assets/jsx-runtime-RQyiN6Nr.js",
+				"/assets/react-dom-D_m_Zgd3.js",
+				"/assets/db-link-BajQ1v8I.js",
+				"/assets/createLucideIcon-C-LI4enx.js",
+				"/assets/MenuTrigger-BNvpjhsQ.js",
+				"/assets/useOpenInteractionType-BQ1arb0B.js"
 			],
-			"css": ["/assets/root-C0MdPLOa.css"],
+			"css": ["/assets/root-B0MB8jZH.css"],
 			"clientActionModule": void 0,
 			"clientLoaderModule": void 0,
 			"clientMiddlewareModule": void 0,
@@ -10934,15 +11546,15 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/_index-D1-nZ7Th.js",
+			"module": "/assets/_index-DqpFaaQw.js",
 			"imports": [
-				"/assets/jsx-runtime-BgbGXvsu.js",
-				"/assets/db-link-BWWnHM0k.js",
-				"/assets/error-card-B0ANyjh3.js",
-				"/assets/badge-DCQvSdiR.js",
-				"/assets/button-BxLcuaPM.js",
-				"/assets/stat-card-DLtQnscf.js",
-				"/assets/table-DqqzSNik.js"
+				"/assets/jsx-runtime-RQyiN6Nr.js",
+				"/assets/db-link-BajQ1v8I.js",
+				"/assets/stat-card-dyg1wY5p.js",
+				"/assets/button-9NpSS9Ow.js",
+				"/assets/badge-CMnQO7Lq.js",
+				"/assets/table-Cz7ujmH_.js",
+				"/assets/error-card-BH7i86fH.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -10963,24 +11575,24 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/jobs-D0a6Lwq0.js",
+			"module": "/assets/jobs-CAd_qqLH.js",
 			"imports": [
-				"/assets/jsx-runtime-BgbGXvsu.js",
-				"/assets/db-link-BWWnHM0k.js",
-				"/assets/error-card-B0ANyjh3.js",
-				"/assets/badge-DCQvSdiR.js",
-				"/assets/button-BxLcuaPM.js",
-				"/assets/filter-select--qLjbs9m.js",
-				"/assets/pagination-Bzx8wbXG.js",
-				"/assets/table-DqqzSNik.js",
-				"/assets/MenuTrigger-BhalG0aG.js",
-				"/assets/useOpenInteractionType-D3JsvupP.js",
-				"/assets/createLucideIcon-DVP_i62f.js",
-				"/assets/check-Ch42cXMT.js",
-				"/assets/chevron-down-Byq-CYG9.js",
-				"/assets/chevron-right-CKAGD7DJ.js",
-				"/assets/x-BPKZwOn9.js",
-				"/assets/react-dom-QnGHOQwT.js"
+				"/assets/jsx-runtime-RQyiN6Nr.js",
+				"/assets/db-link-BajQ1v8I.js",
+				"/assets/createLucideIcon-C-LI4enx.js",
+				"/assets/check-7jwc5sb1.js",
+				"/assets/chevron-down-BFFjfYD4.js",
+				"/assets/chevron-right-DGk5QFJF.js",
+				"/assets/x-AhXI_F1j.js",
+				"/assets/MenuTrigger-BNvpjhsQ.js",
+				"/assets/useOpenInteractionType-BQ1arb0B.js",
+				"/assets/button-9NpSS9Ow.js",
+				"/assets/badge-CMnQO7Lq.js",
+				"/assets/table-Cz7ujmH_.js",
+				"/assets/error-card-BH7i86fH.js",
+				"/assets/pagination-C-ohiBmY.js",
+				"/assets/filter-select-Bn_oSiip.js",
+				"/assets/react-dom-D_m_Zgd3.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -11001,14 +11613,14 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/queues._index-D8903DTa.js",
+			"module": "/assets/queues._index-8YriSqbQ.js",
 			"imports": [
-				"/assets/jsx-runtime-BgbGXvsu.js",
-				"/assets/db-link-BWWnHM0k.js",
-				"/assets/badge-DCQvSdiR.js",
-				"/assets/button-BxLcuaPM.js",
-				"/assets/filter-select--qLjbs9m.js",
-				"/assets/table-DqqzSNik.js"
+				"/assets/jsx-runtime-RQyiN6Nr.js",
+				"/assets/db-link-BajQ1v8I.js",
+				"/assets/button-9NpSS9Ow.js",
+				"/assets/badge-CMnQO7Lq.js",
+				"/assets/table-Cz7ujmH_.js",
+				"/assets/filter-select-Bn_oSiip.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -11029,14 +11641,14 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/queues.create-CMqQVLup.js",
+			"module": "/assets/queues.create-DsY0Sc19.js",
 			"imports": [
-				"/assets/jsx-runtime-BgbGXvsu.js",
-				"/assets/db-link-BWWnHM0k.js",
-				"/assets/error-card-B0ANyjh3.js",
-				"/assets/button-BxLcuaPM.js",
-				"/assets/chevron-down-Byq-CYG9.js",
-				"/assets/createLucideIcon-DVP_i62f.js"
+				"/assets/jsx-runtime-RQyiN6Nr.js",
+				"/assets/db-link-BajQ1v8I.js",
+				"/assets/chevron-down-BFFjfYD4.js",
+				"/assets/button-9NpSS9Ow.js",
+				"/assets/error-card-BH7i86fH.js",
+				"/assets/createLucideIcon-C-LI4enx.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -11057,25 +11669,25 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/queues._name-BVt_4pav.js",
+			"module": "/assets/queues._name-Cb17IB2u.js",
 			"imports": [
-				"/assets/jsx-runtime-BgbGXvsu.js",
-				"/assets/db-link-BWWnHM0k.js",
-				"/assets/error-card-B0ANyjh3.js",
-				"/assets/badge-DCQvSdiR.js",
-				"/assets/button-BxLcuaPM.js",
-				"/assets/dialog-Bik519zD.js",
-				"/assets/filter-select--qLjbs9m.js",
-				"/assets/pagination-Bzx8wbXG.js",
-				"/assets/stat-card-DLtQnscf.js",
-				"/assets/table-DqqzSNik.js",
-				"/assets/MenuTrigger-BhalG0aG.js",
-				"/assets/createLucideIcon-DVP_i62f.js",
-				"/assets/chevron-down-Byq-CYG9.js",
-				"/assets/chevron-right-CKAGD7DJ.js",
-				"/assets/useOpenInteractionType-D3JsvupP.js",
-				"/assets/x-BPKZwOn9.js",
-				"/assets/react-dom-QnGHOQwT.js"
+				"/assets/jsx-runtime-RQyiN6Nr.js",
+				"/assets/db-link-BajQ1v8I.js",
+				"/assets/createLucideIcon-C-LI4enx.js",
+				"/assets/chevron-down-BFFjfYD4.js",
+				"/assets/chevron-right-DGk5QFJF.js",
+				"/assets/MenuTrigger-BNvpjhsQ.js",
+				"/assets/dialog-D-oczDM2.js",
+				"/assets/stat-card-dyg1wY5p.js",
+				"/assets/button-9NpSS9Ow.js",
+				"/assets/badge-CMnQO7Lq.js",
+				"/assets/table-Cz7ujmH_.js",
+				"/assets/error-card-BH7i86fH.js",
+				"/assets/pagination-C-ohiBmY.js",
+				"/assets/filter-select-Bn_oSiip.js",
+				"/assets/react-dom-D_m_Zgd3.js",
+				"/assets/useOpenInteractionType-BQ1arb0B.js",
+				"/assets/x-AhXI_F1j.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -11096,19 +11708,19 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/queues._name.jobs._jobId-BkG9y75k.js",
+			"module": "/assets/queues._name.jobs._jobId-Bkv8POBj.js",
 			"imports": [
-				"/assets/jsx-runtime-BgbGXvsu.js",
-				"/assets/db-link-BWWnHM0k.js",
-				"/assets/error-card-B0ANyjh3.js",
-				"/assets/badge-DCQvSdiR.js",
-				"/assets/button-BxLcuaPM.js",
-				"/assets/dialog-Bik519zD.js",
-				"/assets/createLucideIcon-DVP_i62f.js",
-				"/assets/check-Ch42cXMT.js",
-				"/assets/useOpenInteractionType-D3JsvupP.js",
-				"/assets/x-BPKZwOn9.js",
-				"/assets/react-dom-QnGHOQwT.js"
+				"/assets/jsx-runtime-RQyiN6Nr.js",
+				"/assets/db-link-BajQ1v8I.js",
+				"/assets/createLucideIcon-C-LI4enx.js",
+				"/assets/check-7jwc5sb1.js",
+				"/assets/dialog-D-oczDM2.js",
+				"/assets/button-9NpSS9Ow.js",
+				"/assets/badge-CMnQO7Lq.js",
+				"/assets/error-card-BH7i86fH.js",
+				"/assets/x-AhXI_F1j.js",
+				"/assets/useOpenInteractionType-BQ1arb0B.js",
+				"/assets/react-dom-D_m_Zgd3.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -11129,15 +11741,15 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/schedules-DPXQoaEE.js",
+			"module": "/assets/schedules-iYfIJxOD.js",
 			"imports": [
-				"/assets/jsx-runtime-BgbGXvsu.js",
-				"/assets/db-link-BWWnHM0k.js",
-				"/assets/error-card-B0ANyjh3.js",
-				"/assets/badge-DCQvSdiR.js",
-				"/assets/button-BxLcuaPM.js",
-				"/assets/pagination-Bzx8wbXG.js",
-				"/assets/table-DqqzSNik.js"
+				"/assets/jsx-runtime-RQyiN6Nr.js",
+				"/assets/db-link-BajQ1v8I.js",
+				"/assets/button-9NpSS9Ow.js",
+				"/assets/badge-CMnQO7Lq.js",
+				"/assets/table-Cz7ujmH_.js",
+				"/assets/error-card-BH7i86fH.js",
+				"/assets/pagination-C-ohiBmY.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -11158,17 +11770,17 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/schedules._name._key-B_luxy1w.js",
+			"module": "/assets/schedules._name._key-CJVu73XY.js",
 			"imports": [
-				"/assets/jsx-runtime-BgbGXvsu.js",
-				"/assets/db-link-BWWnHM0k.js",
-				"/assets/error-card-B0ANyjh3.js",
-				"/assets/button-BxLcuaPM.js",
-				"/assets/dialog-Bik519zD.js",
-				"/assets/useOpenInteractionType-D3JsvupP.js",
-				"/assets/x-BPKZwOn9.js",
-				"/assets/react-dom-QnGHOQwT.js",
-				"/assets/createLucideIcon-DVP_i62f.js"
+				"/assets/jsx-runtime-RQyiN6Nr.js",
+				"/assets/db-link-BajQ1v8I.js",
+				"/assets/dialog-D-oczDM2.js",
+				"/assets/button-9NpSS9Ow.js",
+				"/assets/error-card-BH7i86fH.js",
+				"/assets/x-AhXI_F1j.js",
+				"/assets/useOpenInteractionType-BQ1arb0B.js",
+				"/assets/createLucideIcon-C-LI4enx.js",
+				"/assets/react-dom-D_m_Zgd3.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -11189,12 +11801,12 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/schedules.new-BQV7GWzs.js",
+			"module": "/assets/schedules.new-Cq0Mxa7G.js",
 			"imports": [
-				"/assets/jsx-runtime-BgbGXvsu.js",
-				"/assets/db-link-BWWnHM0k.js",
-				"/assets/error-card-B0ANyjh3.js",
-				"/assets/button-BxLcuaPM.js"
+				"/assets/jsx-runtime-RQyiN6Nr.js",
+				"/assets/db-link-BajQ1v8I.js",
+				"/assets/button-9NpSS9Ow.js",
+				"/assets/error-card-BH7i86fH.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -11215,12 +11827,43 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/send-DJBsfnx_.js",
+			"module": "/assets/send-8X9ZisG-.js",
+			"imports": [
+				"/assets/jsx-runtime-RQyiN6Nr.js",
+				"/assets/db-link-BajQ1v8I.js",
+				"/assets/button-9NpSS9Ow.js",
+				"/assets/error-card-BH7i86fH.js"
+			],
+			"css": [],
+			"clientActionModule": void 0,
+			"clientLoaderModule": void 0,
+			"clientMiddlewareModule": void 0,
+			"hydrateFallbackModule": void 0
+		},
+		"routes/migrations": {
+			"id": "routes/migrations",
+			"parentId": "root",
+			"path": "migrations",
+			"index": void 0,
+			"caseSensitive": void 0,
+			"hasAction": false,
+			"hasLoader": true,
+			"hasClientAction": false,
+			"hasClientLoader": false,
+			"hasClientMiddleware": false,
+			"hasDefaultExport": true,
+			"hasErrorBoundary": true,
+			"module": "/assets/migrations-D5l0n4Jn.js",
 			"imports": [
-				"/assets/jsx-runtime-BgbGXvsu.js",
-				"/assets/db-link-BWWnHM0k.js",
-				"/assets/error-card-B0ANyjh3.js",
-				"/assets/button-BxLcuaPM.js"
+				"/assets/jsx-runtime-RQyiN6Nr.js",
+				"/assets/db-link-BajQ1v8I.js",
+				"/assets/stat-card-dyg1wY5p.js",
+				"/assets/button-9NpSS9Ow.js",
+				"/assets/badge-CMnQO7Lq.js",
+				"/assets/table-Cz7ujmH_.js",
+				"/assets/error-card-BH7i86fH.js",
+				"/assets/pagination-C-ohiBmY.js",
+				"/assets/filter-select-Bn_oSiip.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -11241,16 +11884,16 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/warnings-CHKaRfIW.js",
+			"module": "/assets/warnings-C1R_RzIe.js",
 			"imports": [
-				"/assets/jsx-runtime-BgbGXvsu.js",
-				"/assets/db-link-BWWnHM0k.js",
-				"/assets/error-card-B0ANyjh3.js",
-				"/assets/badge-DCQvSdiR.js",
-				"/assets/button-BxLcuaPM.js",
-				"/assets/filter-select--qLjbs9m.js",
-				"/assets/pagination-Bzx8wbXG.js",
-				"/assets/table-DqqzSNik.js"
+				"/assets/jsx-runtime-RQyiN6Nr.js",
+				"/assets/db-link-BajQ1v8I.js",
+				"/assets/button-9NpSS9Ow.js",
+				"/assets/badge-CMnQO7Lq.js",
+				"/assets/table-Cz7ujmH_.js",
+				"/assets/error-card-BH7i86fH.js",
+				"/assets/pagination-C-ohiBmY.js",
+				"/assets/filter-select-Bn_oSiip.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -11259,8 +11902,8 @@ var server_manifest_default = {
 			"hydrateFallbackModule": void 0
 		}
 	},
-	"url": "/assets/manifest-ef81a0f9.js",
-	"version": "ef81a0f9",
+	"url": "/assets/manifest-27e8e133.js",
+	"version": "27e8e133",
 	"sri": void 0
 };
 //#endregion
@@ -11366,6 +12009,14 @@ var routes = {
 		caseSensitive: void 0,
 		module: send_exports
 	},
+	"routes/migrations": {
+		id: "routes/migrations",
+		parentId: "root",
+		path: "migrations",
+		index: void 0,
+		caseSensitive: void 0,
+		module: migrations_exports
+	},
 	"routes/warnings": {
 		id: "routes/warnings",
 		parentId: "root",