@pg-boss/dashboard 1.2.0 → 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;
@@ -1434,6 +1485,7 @@ if (typeof process !== "undefined") {
 }
 //#endregion
 //#region ../../src/plans.ts
+var PG_ERROR = { divisionByZero: "22012" };
 var DEFAULT_SCHEMA = "pgboss";
 var MIGRATE_RACE_MESSAGE = "division by zero";
 var CREATE_RACE_MESSAGE = "already exists";
@@ -1469,6 +1521,10 @@ var QUEUE_DEFAULTS = {
 };
 var COMMON_JOB_TABLE = "job_common";
 function create(schema, version, options) {
+	const noPartitioning = options?.noTablePartitioning ?? false;
+	const noDeferrable = options?.noDeferrableConstraints ?? false;
+	const noLocks = options?.noAdvisoryLocks ?? false;
+	const noCovering = options?.noCoveringIndexes ?? false;
 	return locked(schema, [
 		options?.createSchema ? createSchema(schema) : "",
 		createEnumJobState(schema),
@@ -1477,18 +1533,20 @@ function create(schema, version, options) {
 		createTableSchedule(schema),
 		createTableSubscription(schema),
 		createTableBam(schema),
-		jobTableFormatFunction(schema),
-		jobTableRunFunction(schema),
-		jobTableRunAsyncFunction(schema),
-		createTableJob(schema),
+		noPartitioning ? "" : jobTableFormatFunction(schema),
+		noPartitioning ? "" : jobTableRunFunction(schema),
+		noPartitioning ? "" : jobTableRunAsyncFunction(schema),
+		createTableJob(schema, noPartitioning),
 		createPrimaryKeyJob(schema),
-		createTableJobCommon(schema),
+		noPartitioning ? createTableJobIndexes(schema, noDeferrable, noCovering) : createTableJobCommon(schema),
 		createTableWarning(schema),
 		createIndexWarning(schema),
-		createQueueFunction(schema),
-		deleteQueueFunction(schema),
+		createTableJobDependency(schema),
+		createIndexJobDependencyParent(schema),
+		createQueueFunction(schema, noPartitioning),
+		deleteQueueFunction(schema, noPartitioning),
 		insertVersion(schema, version)
-	]);
+	], void 0, noLocks);
 }
 function createSchema(schema) {
 	return `CREATE SCHEMA IF NOT EXISTS ${schema}`;
@@ -1531,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,
@@ -1601,6 +1662,20 @@ function createTableWarning(schema) {
 function createIndexWarning(schema) {
 	return `CREATE INDEX warning_i1 ON ${schema}.warning (created_on DESC)`;
 }
+function createTableJobDependency(schema) {
+	return `
+    CREATE TABLE ${schema}.job_dependency (
+      child_name text NOT NULL,
+      child_id uuid NOT NULL,
+      parent_name text NOT NULL,
+      parent_id uuid NOT NULL,
+      PRIMARY KEY (child_name, child_id, parent_name, parent_id)
+    )
+  `;
+}
+function createIndexJobDependencyParent(schema) {
+	return `CREATE INDEX IF NOT EXISTS job_dep_parent_idx ON ${schema}.job_dependency (parent_name, parent_id)`;
+}
 function jobTableFormatFunction(schema) {
 	return `
     CREATE FUNCTION ${schema}.job_table_format(command text, table_name text)
@@ -1691,7 +1766,8 @@ function jobTableRunAsyncFunction(schema) {
     LANGUAGE plpgsql;
   `;
 }
-function createTableJob(schema) {
+function createTableJob(schema, noPartitioning = false) {
+	const partitionClause = noPartitioning ? "" : "PARTITION BY LIST (name)";
 	return `
     CREATE TABLE ${schema}.job (
       id uuid not null default gen_random_uuid(),
@@ -1719,8 +1795,11 @@ function createTableJob(schema) {
       dead_letter text,
       policy text,
       heartbeat_on timestamp with time zone,
-      heartbeat_seconds int
-    ) PARTITION BY LIST (name)
+      heartbeat_seconds int,
+      blocked boolean not null default false,
+      blocking boolean not null default false,
+      pending_dependencies int not null default 0
+    ) ${partitionClause}
   `;
 }
 var JOB_COLUMNS_MIN = "id, name, data, expire_seconds as \"expireInSeconds\", heartbeat_seconds as \"heartbeatSeconds\", group_id as \"groupId\", group_tier as \"groupTier\"";
@@ -1743,6 +1822,9 @@ var JOB_COLUMNS_ALL = `${JOB_COLUMNS_MIN},
   completed_on as "completedOn",
   keep_until as "keepUntil",
   dead_letter as "deadLetter",
+  blocked,
+  blocking,
+  pending_dependencies as "pendingDependencies",
   output
 `;
 function createTableJobCommon(schema) {
@@ -1765,7 +1847,64 @@ function createTableJobCommon(schema) {
     ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.${COMMON_JOB_TABLE} DEFAULT;
   `;
 }
-function createQueueFunction(schema) {
+function createTableJobIndexes(schema, noDeferrableConstraints = false, noCoveringIndex = false) {
+	return `
+    ${createQueueForeignKeyJob(schema, noDeferrableConstraints)};
+    ${createQueueForeignKeyJobDeadLetter(schema, noDeferrableConstraints)};
+    ${createIndexJobPolicyShort(schema)};
+    ${createIndexJobPolicySingleton(schema)};
+    ${createIndexJobPolicyStately(schema)};
+    ${createIndexJobPolicyExclusive(schema)};
+    ${createIndexJobPolicyKeyStrictFifo(schema)};
+    ${createCheckConstraintKeyStrictFifo(schema)};
+    ${createIndexJobThrottle(schema)};
+    ${createIndexJobFetch(schema, noCoveringIndex)};
+    ${createIndexJobGroupConcurrency(schema)};
+  `;
+}
+function createQueueFunction(schema, noPartitioning = false) {
+	if (noPartitioning) return `
+      CREATE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
+      RETURNS VOID AS
+      $$
+      BEGIN
+        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, ${QUEUE_DEFAULTS.retry_limit}),
+          COALESCE((options->>'retryDelay')::int, ${QUEUE_DEFAULTS.retry_delay}),
+          COALESCE((options->>'retryBackoff')::bool, ${QUEUE_DEFAULTS.retry_backoff}),
+          (options->>'retryDelayMax')::int,
+          COALESCE((options->>'expireInSeconds')::int, ${QUEUE_DEFAULTS.expire_seconds}),
+          COALESCE((options->>'retentionSeconds')::int, ${QUEUE_DEFAULTS.retention_seconds}),
+          COALESCE((options->>'deleteAfterSeconds')::int, ${QUEUE_DEFAULTS.deletion_seconds}),
+          COALESCE((options->>'warningQueueSize')::int, ${QUEUE_DEFAULTS.warning_queued}),
+          options->>'deadLetter',
+          false,
+          'job',
+          (options->>'heartbeatSeconds')::int
+        )
+        ON CONFLICT DO NOTHING;
+      END;
+      $$
+      LANGUAGE plpgsql;
+    `;
 	return `
     CREATE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
     RETURNS VOID AS
@@ -1793,7 +1932,8 @@ function createQueueFunction(schema) {
           dead_letter,
           partition,
           table_name,
-          heartbeat_seconds
+          heartbeat_seconds,
+          notify
         )
         VALUES (
           queue_name,
@@ -1809,7 +1949,8 @@ function createQueueFunction(schema) {
           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
@@ -1850,15 +1991,8 @@ function createQueueFunction(schema) {
     LANGUAGE plpgsql;
   `;
 }
-function deleteQueueFunction(schema) {
-	return `
-    CREATE FUNCTION ${schema}.delete_queue(queue_name text)
-    RETURNS VOID AS
-    $$
-    DECLARE
-      v_table varchar;
-      v_partition bool;
-    BEGIN
+function deleteQueueFunction(schema, noPartitioning = false) {
+	const deleteJobsSql = noPartitioning ? `DELETE FROM ${schema}.job WHERE name = queue_name;` : `
       SELECT table_name, partition
       FROM ${schema}.queue
       WHERE name = queue_name
@@ -1869,27 +2003,42 @@ function deleteQueueFunction(schema) {
       ELSE
         EXECUTE format('DELETE FROM ${schema}.%I WHERE name = %L', v_table, queue_name);
       END IF;
-
+    `;
+	return `
+    CREATE FUNCTION ${schema}.delete_queue(queue_name text)
+    RETURNS VOID AS
+    $$${noPartitioning ? "" : `
+    DECLARE
+      v_table varchar;
+      v_partition bool;`}
+    BEGIN
+      ${deleteJobsSql}
       DELETE FROM ${schema}.queue WHERE name = queue_name;
     END;
     $$
     LANGUAGE plpgsql;
   `;
 }
-function createQueue$1(schema, name, options) {
-	return locked(schema, `SELECT ${schema}.create_queue('${name}', '${JSON.stringify(options)}'::jsonb)`, "create-queue");
+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 deleteQueue(schema, name) {
-	return locked(schema, `SELECT ${schema}.delete_queue('${name}')`, "delete-queue");
+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);
 }
 function createPrimaryKeyJob(schema) {
 	return `ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)`;
 }
-function createQueueForeignKeyJob(schema) {
-	return `ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED`;
+function createQueueForeignKeyJob(schema, noPartitioning = false) {
+	return `ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT${noPartitioning ? "" : " DEFERRABLE INITIALLY DEFERRED"}`;
 }
-function createQueueForeignKeyJobDeadLetter(schema) {
-	return `ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED`;
+function createQueueForeignKeyJobDeadLetter(schema, noPartitioning = false) {
+	return `ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT${noPartitioning ? "" : " DEFERRABLE INITIALLY DEFERRED"}`;
 }
 function createIndexJobPolicyShort(schema) {
 	return `CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = '${JOB_STATES.created}' AND policy = '${QUEUE_POLICIES.short}'`;
@@ -1903,8 +2052,8 @@ function createIndexJobPolicyStately(schema) {
 function createIndexJobThrottle(schema) {
 	return `CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> '${JOB_STATES.cancelled}' AND singleton_on IS NOT NULL`;
 }
-function createIndexJobFetch(schema) {
-	return `CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < '${JOB_STATES.active}'`;
+function createIndexJobFetch(schema, noCoveringIndex = false) {
+	return `CREATE INDEX job_i5 ON ${schema}.job (name, start_after) ${noCoveringIndex ? "" : "INCLUDE (priority, created_on, id) "}WHERE state < '${JOB_STATES.active}' AND NOT blocked`;
 }
 function createIndexJobPolicyExclusive(schema) {
 	return `CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= '${JOB_STATES.active}' AND policy = '${QUEUE_POLICIES.exclusive}'`;
@@ -1967,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
@@ -1989,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",
@@ -2159,7 +2312,23 @@ function buildFetchParams(options) {
 		maxPriorityParam
 	};
 }
-function fetchNextJob(options) {
+/**
+* Builds the fetch query for claiming jobs from the queue.
+*
+* With SKIP LOCKED (noSkipLocked=false, the default), uses SELECT FOR UPDATE SKIP
+* LOCKED, which lets multiple workers efficiently fetch different jobs simultaneously.
+*
+* With noSkipLocked=true, omits FOR UPDATE SKIP LOCKED and adds an additional state
+* check in the WHERE clause. This pattern works better with distributed databases like
+* CockroachDB where SKIP LOCKED has performance issues and can unexpectedly skip
+* unlocked rows.
+*
+* Trade-off when noSkipLocked is set: under high contention, workers may receive fewer
+* jobs per fetch as concurrent updates to the same rows will result in some workers
+* getting empty results. This is acceptable for job queues where processing time
+* exceeds fetch time.
+*/
+function fetchNextJob(options, noSkipLocked = false) {
 	const { schema, table, name, policy, limit, includeMetadata, priority = true, orderByCreatedOn = true, ignoreStartAfter = false, groupConcurrency, minPriority, maxPriority } = options;
 	const singletonFetch = limit > 1 && (policy === QUEUE_POLICIES.singleton || policy === QUEUE_POLICIES.stately);
 	const hasIgnoreSingletons = options.ignoreSingletons != null && options.ignoreSingletons.length > 0;
@@ -2180,9 +2349,11 @@ function fetchNextJob(options) {
         WHERE name = '${name}' AND state = '${JOB_STATES.active}' AND group_id IS NOT NULL
         GROUP BY group_id
       ), ` : "";
+	const lockClause = noSkipLocked ? "" : "FOR UPDATE OF j SKIP LOCKED";
 	const whereConditions = [
 		`j.name = '${name}'`,
 		`j.state < '${JOB_STATES.active}'`,
+		"NOT j.blocked",
 		!ignoreStartAfter ? "j.start_after < now()" : "",
 		hasIgnoreSingletons ? `j.singleton_key <> ALL(${params.ignoreSingletonsParam})` : "",
 		hasIgnoreGroups ? `(j.group_id IS NULL OR j.group_id <> ALL(${params.ignoreGroupsParam}))` : "",
@@ -2200,7 +2371,7 @@ function fetchNextJob(options) {
         WHERE ${whereConditions}
         ORDER BY ${priority ? "j.priority desc, " : ""}${orderByCreatedOn ? "j.created_on, " : ""}j.id
         LIMIT ${limit}
-        FOR UPDATE OF j SKIP LOCKED
+        ${lockClause}
       )`;
 	const singletonCte = singletonFetch ? `, singleton_ranking AS (
         SELECT id, ${hasGroupConcurrency ? "group_id, group_tier, " : ""}
@@ -2225,6 +2396,7 @@ function fetchNextJob(options) {
           OR (active_cnt + group_rn) <= ${hasTiers ? `COALESCE((${params.tiersParam} ->> group_tier)::int, ${params.defaultGroupLimitParam})` : params.defaultGroupLimitParam}
       )` : "";
 	const finalCte = hasGroupConcurrency ? "group_filtered" : singletonFetch ? "singleton_ranking" : "next";
+	const distributedStateCheck = noSkipLocked ? `AND j.state < '${JOB_STATES.active}'` : "";
 	return {
 		text: `
       WITH
@@ -2240,25 +2412,110 @@ function fetchNextJob(options) {
       FROM ${finalCte}
       WHERE name = '${name}' AND j.id = ${finalCte}.id
       ${singletonFetch && !hasGroupConcurrency ? "AND singleton_rn = 1" : ""}
+      ${distributedStateCheck}
       RETURNING j.${includeMetadata ? JOB_COLUMNS_ALL : JOB_COLUMNS_MIN}
     `,
 		values: params.values
 	};
 }
-function completeJobs(schema, table, includeQueued) {
-	const stateFilter = includeQueued ? `state < '${JOB_STATES.completed}'` : `state = '${JOB_STATES.active}'`;
-	return `
-    WITH results AS (
-      UPDATE ${schema}.${table}
+function completeJobsUpdate(schema, table, includeQueued) {
+	return `UPDATE ${schema}.${table}
       SET completed_on = now(),
         state = '${JOB_STATES.completed}',
-        output = $3::jsonb
+        output = $3::jsonb,
+        blocked = ${includeQueued ? "false" : "blocked"},
+        pending_dependencies = ${includeQueued ? "0" : "pending_dependencies"}
       WHERE name = $1
         AND id IN (SELECT UNNEST($2::uuid[]))
-        AND ${stateFilter}
-      RETURNING *
+        AND ${includeQueued ? `state < '${JOB_STATES.completed}'` : `state = '${JOB_STATES.active}'`}`;
+}
+function lockedChildrenCte(schema) {
+	return `locked_children AS (
+      SELECT j.name, j.id, d.n
+      FROM ${schema}.job j
+      JOIN decremented d ON d.child_name = j.name
+        AND d.child_id = j.id
+      WHERE j.blocked
+      ORDER BY j.name, j.id
+      FOR UPDATE OF j
+    )`;
+}
+function unblockChildrenUpdate(schema) {
+	return `UPDATE ${schema}.job j
+      SET pending_dependencies = GREATEST(j.pending_dependencies - lc.n, 0),
+          blocked = GREATEST(j.pending_dependencies - lc.n, 0) > 0
+      FROM locked_children lc
+      WHERE j.name = lc.name
+        AND j.id = lc.id`;
+}
+function completeJobs(schema, table, includeQueued) {
+	return `
+    WITH completed AS (
+      ${completeJobsUpdate(schema, table, includeQueued)}
+      RETURNING name, id, 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 results
+    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) {
@@ -2299,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,
@@ -2320,7 +2577,10 @@ function insertJobs(schema, { table, name, returnId = true }) {
       retry_delay_max,
       policy,
       dead_letter,
-      heartbeat_seconds
+      heartbeat_seconds,
+      blocked,
+      blocking,
+      pending_dependencies
     )
     SELECT
       COALESCE(id, gen_random_uuid()) as id,
@@ -2330,7 +2590,7 @@ function insertJobs(schema, { table, name, returnId = true }) {
       j.start_after,
       "singletonKey",
       CASE
-        WHEN "singletonSeconds" IS NOT NULL THEN 'epoch'::timestamp + '1s'::interval * ("singletonSeconds" * floor(( date_part('epoch', now()) + COALESCE("singletonOffset",0)) / "singletonSeconds" ))
+        WHEN "singletonSeconds" IS NOT NULL THEN 'epoch'::timestamp + '1s'::interval * ("singletonSeconds"::float8 * floor(( date_part('epoch', now()) + COALESCE("singletonOffset",0)::float8) / "singletonSeconds"::float8 ))
         ELSE NULL
         END as singleton_on,
       "groupId" as group_id,
@@ -2344,7 +2604,10 @@ function insertJobs(schema, { table, name, returnId = true }) {
       COALESCE("retryDelayMax", q.retry_delay_max) as retry_delay_max,
       q.policy,
       COALESCE("deadLetter", q.dead_letter) as dead_letter,
-      COALESCE("heartbeatSeconds", q.heartbeat_seconds) as heartbeat_seconds
+      COALESCE("heartbeatSeconds", q.heartbeat_seconds) as heartbeat_seconds,
+      COALESCE(blocked, false) as blocked,
+      COALESCE(blocking, false) as blocking,
+      COALESCE("pendingDependencies", 0) as pending_dependencies
     FROM (
       SELECT *,
         CASE
@@ -2369,27 +2632,54 @@ function insertJobs(schema, { table, name, returnId = true }) {
         "deleteAfterSeconds" integer,
         "retentionSeconds" integer,
         "deadLetter" text,
-        "heartbeatSeconds" integer
+        "heartbeatSeconds" integer,
+        blocked boolean,
+        blocking boolean,
+        "pendingDependencies" integer
       )
     ) 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) {
 	return failJobs(schema, table, `name = $1 AND id IN (SELECT UNNEST($2::uuid[])) AND state < '${JOB_STATES.completed}'`, "$3::jsonb");
 }
-function failJobsByTimeout(schema, table, queues) {
+function failJobsByTimeout(schema, table, queues, noAdvisoryLocks) {
 	return locked(schema, failJobs(schema, table, `state = '${JOB_STATES.active}'
             AND (started_on + expire_seconds * interval '1s') < now()
-            AND name = ANY(${serializeArrayParam(queues)})`, "'{ \"value\": { \"message\": \"job timed out\" } }'::jsonb"), table + "failJobsByTimeout");
+            AND name = ANY(${serializeArrayParam(queues)})`, "'{ \"value\": { \"message\": \"job timed out\" } }'::jsonb"), table + "failJobsByTimeout", noAdvisoryLocks);
 }
-function failJobsByHeartbeat(schema, table, queues) {
+function failJobsByHeartbeat(schema, table, queues, noAdvisoryLocks) {
 	return locked(schema, failJobs(schema, table, `state = '${JOB_STATES.active}'
             AND heartbeat_seconds IS NOT NULL
             AND (heartbeat_on + heartbeat_seconds * interval '1s') < now()
-            AND name = ANY(${serializeArrayParam(queues)})`, "'{ \"value\": { \"message\": \"job heartbeat timeout\" } }'::jsonb"), table + "failJobsByHeartbeat");
+            AND name = ANY(${serializeArrayParam(queues)})`, "'{ \"value\": { \"message\": \"job heartbeat timeout\" } }'::jsonb"), table + "failJobsByHeartbeat", noAdvisoryLocks);
 }
 function touchJobs(schema, table) {
 	return `
@@ -2406,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 *
@@ -2438,17 +2733,20 @@ function failJobs(schema, table, where, output) {
         output,
         dead_letter,
         heartbeat_on,
-        heartbeat_seconds
+        heartbeat_seconds,
+        blocked,
+        blocking,
+        pending_dependencies
       )
       SELECT
         id,
         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,
@@ -2472,13 +2770,16 @@ 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},
         dead_letter,
         NULL as heartbeat_on,
-        heartbeat_seconds
+        heartbeat_seconds,
+        blocked,
+        blocking,
+        pending_dependencies
       FROM deleted_jobs
       ON CONFLICT DO NOTHING
       RETURNING *
@@ -2510,7 +2811,10 @@ function failJobs(schema, table, where, output) {
         output,
         dead_letter,
         heartbeat_on,
-        heartbeat_seconds
+        heartbeat_seconds,
+        blocked,
+        blocking,
+        pending_dependencies
       )
       SELECT
         id,
@@ -2538,7 +2842,10 @@ function failJobs(schema, table, where, output) {
         ${output},
         dead_letter,
         NULL as heartbeat_on,
-        heartbeat_seconds
+        heartbeat_seconds,
+        blocked,
+        blocking,
+        pending_dependencies
       FROM deleted_jobs
       WHERE id NOT IN (SELECT id from retried_jobs)
       RETURNING *
@@ -2562,11 +2869,105 @@ 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
   `;
 }
-function deletion(schema, table, queues) {
+function selectJobsToFailById(schema, table) {
+	return {
+		text: `SELECT * FROM ${schema}.${table} WHERE name = $1 AND id IN (SELECT UNNEST($2::uuid[])) AND state < '${JOB_STATES.completed}'`,
+		values: []
+	};
+}
+function deleteJobsToFail(schema, table) {
+	return {
+		text: `DELETE FROM ${schema}.${table} WHERE name = $1 AND id IN (SELECT UNNEST($2::uuid[]))`,
+		values: []
+	};
+}
+function selectJobsToFailByTimeout(schema, table, queues) {
+	return {
+		text: `SELECT * FROM ${schema}.${table}
+      WHERE state = '${JOB_STATES.active}'
+        AND (started_on + expire_seconds * interval '1s') < now()
+        AND name = ANY(${serializeArrayParam(queues)})`,
+		values: []
+	};
+}
+function selectJobsToFailByHeartbeat(schema, table, queues) {
+	return {
+		text: `SELECT * FROM ${schema}.${table}
+      WHERE state = '${JOB_STATES.active}'
+        AND heartbeat_seconds IS NOT NULL
+        AND (heartbeat_on + heartbeat_seconds * interval '1s') < now()
+        AND name = ANY(${serializeArrayParam(queues)})`,
+		values: []
+	};
+}
+function deleteJobsByIds(schema, table) {
+	return {
+		text: `DELETE FROM ${schema}.${table} WHERE id IN (SELECT UNNEST($1::uuid[]))`,
+		values: []
+	};
+}
+function completeJobsDistributed(schema, table, includeQueued) {
+	return `
+    ${completeJobsUpdate(schema, table, includeQueued)}
+    RETURNING id, blocking
+  `;
+}
+function decrementDependents(schema) {
+	return `
+    WITH decremented AS (
+      SELECT d.child_name, d.child_id, COUNT(*)::int AS n
+      FROM ${schema}.job_dependency d
+      WHERE d.parent_name = $1
+        AND d.parent_id IN (SELECT UNNEST($2::uuid[]))
+      GROUP BY d.child_name, d.child_id
+    ),
+    ${lockedChildrenCte(schema)}
+    ${unblockChildrenUpdate(schema)}
+  `;
+}
+function insertRetryJob(schema, table) {
+	return `
+    INSERT INTO ${schema}.${table} (
+      id, name, priority, data, state, retry_limit, retry_count, retry_delay,
+      retry_backoff, retry_delay_max, start_after, started_on, singleton_key, singleton_on,
+      group_id, group_tier, expire_seconds, deletion_seconds, created_on, completed_on,
+      keep_until, policy, output, dead_letter,
+      heartbeat_on, heartbeat_seconds, blocked, blocking, pending_dependencies
+    ) VALUES (
+      $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24,
+      $25, $26, $27, $28, $29
+    ) ON CONFLICT DO NOTHING
+    RETURNING id
+  `;
+}
+function insertDeadLetterJob(schema) {
+	return `
+    INSERT INTO ${schema}.job (name, data, output, retry_limit, retry_backoff, retry_delay, keep_until, deletion_seconds)
+    SELECT $1, $2, $3, q.retry_limit, q.retry_backoff, q.retry_delay, now() + q.retention_seconds * interval '1s', q.deletion_seconds
+    FROM ${schema}.queue q WHERE q.name = $1
+  `;
+}
+function deletion(schema, table, queues, noAdvisoryLocks) {
 	return locked(schema, `
     DELETE FROM ${schema}.${table}
     WHERE name = ANY(${serializeArrayParam(queues)})
@@ -2576,7 +2977,7 @@ function deletion(schema, table, queues) {
         OR
         (state < '${JOB_STATES.active}' AND keep_until < now())
       )
-  `, table + "deletion");
+  `, table + "deletion", noAdvisoryLocks);
 }
 function retryJobs(schema, table) {
 	return `
@@ -2597,25 +2998,39 @@ 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]
 	};
 }
-function cacheQueueStats(schema, table, queues) {
+function cacheQueueStats(schema, table, queues, noAdvisoryLocks) {
 	return locked(schema, `
     WITH stats AS (${getQueueStats$1(schema, table, queues).text.replace("$1::text[]", serializeArrayParam(queues))})
     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 (
@@ -2628,22 +3043,27 @@ function cacheQueueStats(schema, table, queues) {
       queue.name,
       queue.queued_count as "queuedCount",
       queue.warning_queued as "warningQueueSize"
-  `, "queue-stats");
+  `, "queue-stats", noAdvisoryLocks);
 }
 function serializeArrayParam(values) {
 	return `ARRAY[${values.map((v) => `'${v.replace(SINGLE_QUOTE_REGEX, "''")}'`).join(",")}]::text[]`;
 }
-function locked(schema, query, key) {
-	const sql = Array.isArray(query) ? query.join(";\n") : query;
+function serializeJsonParam(value) {
+	return `'${JSON.stringify(value).replace(SINGLE_QUOTE_REGEX, "''")}'`;
+}
+function transaction(query) {
 	return `
     BEGIN;
     SET LOCAL lock_timeout = 30000;
     SET LOCAL idle_in_transaction_session_timeout = 30000;
-    ${advisoryLock(schema, key)};
-    ${sql};
+    ${Array.isArray(query) ? query.join(";\n") : query};
     COMMIT;
   `;
 }
+function locked(schema, query, key, noAdvisoryLocks) {
+	const statements = Array.isArray(query) ? query : [query];
+	return transaction(noAdvisoryLocks ? statements : [advisoryLock(schema, key), ...statements]);
+}
 function advisoryLock(schema, key) {
 	return `SELECT pg_advisory_xact_lock(
       ('x' || encode(sha224((current_database() || '.pgboss.${schema}${key || ""}')::bytea), 'hex'))::bit(64)::bigint
@@ -2684,6 +3104,49 @@ function getJobById$1(schema, table) {
       AND id = $2
     `;
 }
+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 (
+      child_name text,
+      child_id uuid,
+      parent_name text,
+      parent_id uuid
+    )
+    ON CONFLICT DO NOTHING
+  `;
+	return deps ? sql.replace("$1", () => serializeJsonParam(deps)) : sql;
+}
+function getDependencies(schema) {
+	return `
+    SELECT parent_name as "parentName", parent_id as "parentId"
+    FROM ${schema}.job_dependency
+    WHERE child_name = $1 AND child_id = $2
+  `;
+}
+function getDependents(schema) {
+	return `
+    SELECT child_name as "childName", child_id as "childId"
+    FROM ${schema}.job_dependency
+    WHERE parent_name = $1 AND parent_id = $2
+  `;
+}
+function cleanupDependencies(schema, table, queues, noAdvisoryLocks) {
+	return locked(schema, `
+    DELETE FROM ${schema}.job_dependency
+    WHERE (child_name = ANY(${serializeArrayParam(queues)})
+      AND NOT EXISTS (
+        SELECT 1 FROM ${schema}.${table} j
+        WHERE j.name = child_name AND j.id = child_id
+      ))
+    OR (parent_name = ANY(${serializeArrayParam(queues)})
+      AND NOT EXISTS (
+        SELECT 1 FROM ${schema}.${table} j
+        WHERE j.name = parent_name AND j.id = parent_id
+      ))
+  `, table + "cleanupDependencies", noAdvisoryLocks);
+}
 function getBlockedKeys(schema, table) {
 	return `
     SELECT DISTINCT singleton_key as "singletonKey"
@@ -2729,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"
@@ -2744,11 +3207,54 @@ var POLICY = {
 	MIN_POLLING_INTERVAL_MS: 500,
 	MAX_RETENTION_DAYS: 365
 };
+var COMPATIBILITY_FLAGS = [
+	"noSkipLocked",
+	"noMultiMutationCte",
+	"noTablePartitioning",
+	"noDeferrableConstraints",
+	"noAdvisoryLocks",
+	"noCoveringIndexes",
+	"noListenNotify"
+];
+var BACKEND_PROFILES = {
+	postgres: {
+		kind: "standard",
+		flags: {}
+	},
+	cockroachdb: {
+		kind: "distributed",
+		flags: {
+			noSkipLocked: true,
+			noMultiMutationCte: true,
+			noTablePartitioning: true,
+			noDeferrableConstraints: true,
+			noAdvisoryLocks: true,
+			noCoveringIndexes: true,
+			noListenNotify: true
+		}
+	},
+	yugabytedb: {
+		kind: "distributed",
+		flags: {
+			noAdvisoryLocks: true,
+			noTablePartitioning: true
+		}
+	},
+	citus: {
+		kind: "distributed",
+		flags: {}
+	},
+	pglite: {
+		kind: "embedded",
+		flags: {}
+	}
+};
 function assertObjectName(value, name = "Name") {
 	assert(/^[\w.\-/]+$/.test(value), `${name} can only contain alphanumeric characters, underscores, hyphens, periods, or forward slashes`);
 }
 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);
@@ -2796,6 +3302,82 @@ function validateGroupConfig(config) {
 	assert(typeof config.group.id === "string" && config.group.id.length > 0, "group.id must be a non-empty string");
 	assert(!("tier" in config.group) || typeof config.group.tier === "string" && config.group.tier.length > 0, "group.tier must be a non-empty string if provided");
 }
+function validateFlowJobs(jobs) {
+	assert(Array.isArray(jobs), "flow requires an array of jobs");
+	assert(jobs.length >= 2, "flow requires at least 2 jobs");
+	const refs = /* @__PURE__ */ new Set();
+	for (const job of jobs) {
+		assert(typeof job.ref === "string" && job.ref.length > 0, "each flow job must have a non-empty ref");
+		assert(!refs.has(job.ref), `duplicate ref: "${job.ref}"`);
+		refs.add(job.ref);
+		assert(typeof job.name === "string" && job.name.length > 0, "each flow job must have a non-empty name");
+		assertObjectName(job.name);
+	}
+	assert(jobs.some((j) => j.dependsOn && j.dependsOn.length > 0), "flow requires at least one job with dependsOn");
+	for (const job of jobs) {
+		if (!job.dependsOn) continue;
+		assert(Array.isArray(job.dependsOn), `dependsOn for ref "${job.ref}" must be an array`);
+		for (const dep of job.dependsOn) {
+			assert(typeof dep === "string" && dep.length > 0, "dependsOn entries must be non-empty strings");
+			assert(dep !== job.ref, `job "${job.ref}" cannot depend on itself`);
+			assert(refs.has(dep), `dependsOn ref "${dep}" not found in flow`);
+		}
+	}
+	const inDegree = /* @__PURE__ */ new Map();
+	const edges = /* @__PURE__ */ new Map();
+	for (const job of jobs) {
+		inDegree.set(job.ref, 0);
+		edges.set(job.ref, []);
+	}
+	for (const job of jobs) {
+		if (!job.dependsOn) continue;
+		for (const dep of job.dependsOn) {
+			edges.get(dep).push(job.ref);
+			inDegree.set(job.ref, inDegree.get(job.ref) + 1);
+		}
+	}
+	const queue = [];
+	for (const [ref, deg] of inDegree) if (deg === 0) queue.push(ref);
+	let visited = 0;
+	while (queue.length > 0) {
+		const current = queue.shift();
+		visited++;
+		for (const child of edges.get(current)) {
+			const newDeg = inDegree.get(child) - 1;
+			inDegree.set(child, newDeg);
+			if (newDeg === 0) queue.push(child);
+		}
+	}
+	if (visited !== jobs.length) assert(false, `flow contains a dependency cycle: ${findDependencyCycle(edges).join(" -> ")}`);
+}
+function findDependencyCycle(edges) {
+	const visiting = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const path = [];
+	function visit(ref) {
+		if (visiting.has(ref)) {
+			const start = path.indexOf(ref);
+			return [...path.slice(start), ref];
+		}
+		if (visited.has(ref)) return null;
+		visiting.add(ref);
+		path.push(ref);
+		for (const child of edges.get(ref) || []) {
+			const cycle = visit(child);
+			if (cycle) return cycle;
+		}
+		path.pop();
+		visiting.delete(ref);
+		visited.add(ref);
+		return null;
+	}
+	let cycle = null;
+	for (const ref of edges.keys()) {
+		cycle = visit(ref);
+		if (cycle) break;
+	}
+	return cycle;
+}
 function validateGroupConcurrencyValue(value, optionName) {
 	if (typeof value === "number") {
 		assert(Number.isInteger(value) && value >= 1, `${optionName} must be an integer >= 1`);
@@ -2852,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);
@@ -2875,6 +3458,8 @@ 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);
 	applyScheduleConfig(config);
@@ -2892,6 +3477,17 @@ function validateWarningConfig(config) {
 	assert(!("warningRetentionDays" in config) || Number.isInteger(config.warningRetentionDays) && config.warningRetentionDays >= 1, "configuration assert: warningRetentionDays must be an integer >= 1");
 	assert(!("warningRetentionDays" in config) || config.warningRetentionDays <= POLICY.MAX_RETENTION_DAYS, `configuration assert: warningRetentionDays cannot exceed ${POLICY.MAX_RETENTION_DAYS} days`);
 }
+function resolveBackend(config) {
+	const backend = "backend" in config ? config.backend : "postgres";
+	assert(backend in BACKEND_PROFILES, `configuration assert: backend must be one of ${Object.keys(BACKEND_PROFILES).join(", ")}`);
+	config.backend = backend;
+	const { flags } = BACKEND_PROFILES[backend];
+	for (const flag of COMPATIBILITY_FLAGS) config[flag] = flags[flag] ?? false;
+	if (config.__test__distributed) {
+		config.noSkipLocked = true;
+		config.noMultiMutationCte = true;
+	}
+}
 function assertPostgresObjectName(name) {
 	assert(typeof name === "string", "Name must be a string");
 	assert(name.length <= 50, "Name cannot exceed 50 characters");
@@ -2932,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");
@@ -2965,28 +3568,45 @@ function applyBamConfig(config) {
 }
 //#endregion
 //#region ../../src/migrationStore.ts
-function flatten(schema, commands, version) {
+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));
-	return locked(schema, commands);
+	return locked(schema, commands, void 0, noAdvisoryLocks);
 }
-function rollback(schema, version, migrations) {
+function rollback(schema, version, migrations, noAdvisoryLocks) {
 	migrations = migrations || getAll(schema);
 	const result = migrations.find((i) => i.version === version);
 	assert(result, `Version ${version} not found.`);
-	return flatten(schema, result.uninstall || [], result.previous);
+	return flatten(schema, result.uninstall || [], result.previous, noAdvisoryLocks);
 }
-function next(schema, version, migrations) {
+function next(schema, version, migrations, noAdvisoryLocks) {
 	migrations = migrations || getAll(schema);
 	const result = migrations.find((i) => i.previous === version);
 	assert(result, `Version ${version} not found.`);
-	return flatten(schema, result.install, result.version);
+	return flatten(schema, result.install, result.version, noAdvisoryLocks);
 }
-function migrate(schema, version, migrations) {
+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);
 		}
@@ -2997,100 +3617,520 @@ function migrate(schema, version, migrations) {
 		version
 	});
 	assert(result.install.length > 0, `Version ${version} not found.`);
-	return flatten(schema, result.install, result.version);
+	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
-
-          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;
+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
 
-          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`,
-				`
+      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;
+  `,
+	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
+        )
+        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;
+  `,
+	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,
@@ -3190,84 +4230,7 @@ function getAll(schema) {
         `,
 				`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;
-        `,
+				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`,
@@ -3291,177 +4254,21 @@ 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)`,
-				`DROP TABLE ${schema}.bam`,
-				`ALTER TABLE ${schema}.version DROP COLUMN bam_on`,
-				`ALTER TABLE ${schema}.job DROP COLUMN group_tier`,
-				`ALTER TABLE ${schema}.job DROP COLUMN group_id`
-			]
-		},
-		{
-			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;
-        `],
+				`DROP TABLE ${schema}.bam`,
+				`ALTER TABLE ${schema}.version DROP COLUMN bam_on`,
+				`ALTER TABLE ${schema}.job DROP COLUMN group_tier`,
+				`ALTER TABLE ${schema}.job DROP COLUMN group_id`
+			]
+		},
+		{
+			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')`, createQueueFn[28](schema)],
 			async: [`SELECT ${schema}.job_table_run_async(
           'key_strict_fifo_index',
           $VERSION$,
@@ -3472,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)
 			]
 		},
 		{
@@ -3573,176 +4303,64 @@ 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`
 			]
+		},
+		{
+			release: "12.19.0",
+			version: 31,
+			previous: 30,
+			install: [
+				`ALTER TABLE ${schema}.job ADD COLUMN blocked boolean NOT NULL DEFAULT false`,
+				`ALTER TABLE ${schema}.job ADD COLUMN blocking boolean NOT NULL DEFAULT false`,
+				`ALTER TABLE ${schema}.job ADD COLUMN pending_dependencies int NOT NULL DEFAULT 0`,
+				`
+        CREATE TABLE IF NOT EXISTS ${schema}.job_dependency (
+          child_name text NOT NULL,
+          child_id uuid NOT NULL,
+          parent_name text NOT NULL,
+          parent_id uuid NOT NULL,
+          PRIMARY KEY (child_name, child_id, parent_name, parent_id)
+        )
+        `,
+				`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$)`,
+				createQueueFn[31](schema)
+			],
+			uninstall: [
+				`DROP INDEX IF EXISTS ${schema}.job_dep_parent_idx`,
+				`DROP TABLE IF EXISTS ${schema}.job_dependency`,
+				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`
+			]
 		}
 	];
 }
@@ -3750,7 +4368,7 @@ function getAll(schema) {
 //#region ../../src/contractor.ts
 var schemaVersion = {
 	name: "pg-boss",
-	version: "12.18.3",
+	version: "12.21.0",
 	description: "Queueing jobs in Postgres from Node.js like a boss",
 	type: "module",
 	main: "./dist/index.js",
@@ -3758,20 +4376,22 @@ 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.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",
+		"cross-env": "^10.1.0",
 		"drizzle-orm": "^1.0.0-beta.22",
 		"eslint": "^9.39.4",
 		"knex": "^3.2.10",
@@ -3787,17 +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": 30 },
+	pgboss: { "schema": 32 },
 	repository: {
 		"type": "git",
 		"url": "git+https://github.com/timgit/pg-boss.git"
@@ -3823,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);
@@ -3864,18 +4494,18 @@ var Contractor = class {
 	}
 	async migrate(version) {
 		try {
-			const commands = migrate(this.config.schema, version, this.migrations);
+			const commands = migrate(this.config.schema, version, this.migrations, this.config.noAdvisoryLocks);
 			await this.db.executeSql(commands);
 		} catch (err) {
 			assert(err.message.includes(MIGRATE_RACE_MESSAGE), err);
 		}
 	}
 	async next(version) {
-		const commands = next(this.config.schema, version, this.migrations);
+		const commands = next(this.config.schema, version, this.migrations, this.config.noAdvisoryLocks);
 		await this.db.executeSql(commands);
 	}
 	async rollback(version) {
-		const commands = rollback(this.config.schema, version, this.migrations);
+		const commands = rollback(this.config.schema, version, this.migrations, this.config.noAdvisoryLocks);
 		await this.db.executeSql(commands);
 	}
 };
@@ -4119,7 +4749,7 @@ var Worker = class {
 	fetch;
 	onFetch;
 	onError;
-	interval;
+	resolveInterval;
 	jobs = [];
 	createdOn = Date.now();
 	state = WORKER_STATES.created;
@@ -4135,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;
@@ -4143,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();
@@ -4152,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);
@@ -4171,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;
 			}
@@ -4280,12 +4913,41 @@ var INTERNAL_QUEUES = Object.values(QUEUES).reduce((acc, i) => ({
 	...acc,
 	[i]: i
 }), {});
-var events$3 = {
+var NUMERIC_METADATA_FIELDS = [
+	"priority",
+	"retryLimit",
+	"retryCount",
+	"retryDelay",
+	"retryDelayMax",
+	"expireInSeconds",
+	"heartbeatSeconds",
+	"deleteAfterSeconds",
+	"pendingDependencies"
+];
+var NUMERIC_QUEUE_FIELDS = [
+	"retryLimit",
+	"retryDelay",
+	"retryDelayMax",
+	"expireInSeconds",
+	"retentionSeconds",
+	"deleteAfterSeconds",
+	"heartbeatSeconds",
+	"deferredCount",
+	"warningQueueSize",
+	"queuedCount",
+	"activeCount",
+	"totalCount"
+];
+var events$4 = {
 	error: "error",
 	wip: "wip"
 };
+function rethrowWriteError(err) {
+	if (err?.code === PG_ERROR.divisionByZero) throw new Error("one or more jobs could not be created. This usually means a job id was duplicated, collided with an existing job, or was rejected by a queue policy (short, singleton, stately, or exclusive).", { cause: err });
+	throw err;
+}
 var Manager = class extends EventEmitter {
-	events = events$3;
+	events = events$4;
 	db;
 	config;
 	wipTs;
@@ -4294,6 +4956,7 @@ var Manager = class extends EventEmitter {
 	queueCacheInterval;
 	wipInterval;
 	timekeeper;
+	notifier;
 	queues;
 	pendingOffWorkCleanups;
 	#spies;
@@ -4362,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);
+		}
+	}
+	async #trackJobsFailed(name, jobs, err) {
+		const spy = this.config.__test__enableSpies ? this.#spies.get(name) : void 0;
+		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
+			});
 		}
 	}
-	#trackJobsFailed(name, jobs, err) {
+	#trackJobsSettled(name, completed, failed) {
 		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, 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;
@@ -4412,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);
@@ -4428,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;
@@ -4452,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);
@@ -4467,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
@@ -4502,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;
@@ -4525,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) {
@@ -4533,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);
 					}
@@ -4541,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,
@@ -4554,7 +5353,7 @@ var Manager = class extends EventEmitter {
 				workId,
 				name,
 				options,
-				interval,
+				resolveInterval,
 				fetch,
 				onFetch,
 				onError
@@ -4580,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;
 			}
 		}
@@ -4616,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");
@@ -4698,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) {
@@ -4731,25 +5540,111 @@ 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`);
 		}
+		const insertPayload = jobs.map((j) => {
+			const { blocked, blocking, pendingDependencies, ...rest } = j;
+			return rest;
+		});
 		const db = this.assertDb(options);
 		const spy = this.config.__test__enableSpies ? this.#spies.get(name) : void 0;
 		const returnId = !!spy || !!options.returnId;
 		const sql = insertJobs(this.config.schema, {
 			table,
 			name,
-			returnId
+			returnId,
+			notify: this.#notifyEnabled(notify)
 		});
-		const { rows } = await db.executeSql(sql, [JSON.stringify(jobs)]);
+		const { rows } = await db.executeSql(sql, [JSON.stringify(insertPayload)]);
 		if (rows.length) {
 			if (spy) for (let i = 0; i < rows.length; i++) spy.addJob(rows[i].id, name, jobs[i].data || {}, "created");
 			return rows.map((i) => i.id);
 		}
 		return null;
 	}
+	async flow(jobs, options = {}) {
+		validateFlowJobs(jobs);
+		const flowJobs = jobs.map((job) => ({
+			...job,
+			options: checkSendArgs([{
+				name: job.name,
+				data: job.data,
+				options: job.options
+			}]).options
+		}));
+		const refToId = {};
+		for (const job of flowJobs) refToId[job.ref] = job.options?.id ?? randomUUID();
+		const refToJob = new Map(flowJobs.map((job) => [job.ref, job]));
+		const dependencyCountByRef = /* @__PURE__ */ new Map();
+		const parentRefs = /* @__PURE__ */ new Set();
+		const depRows = [];
+		for (const job of flowJobs) {
+			const dependsOn = [...new Set(job.dependsOn ?? [])];
+			dependencyCountByRef.set(job.ref, dependsOn.length);
+			for (const depRef of dependsOn) {
+				const parentJob = refToJob.get(depRef);
+				parentRefs.add(depRef);
+				depRows.push({
+					child_name: job.name,
+					child_id: refToId[job.ref],
+					parent_name: parentJob.name,
+					parent_id: refToId[depRef]
+				});
+			}
+		}
+		const byQueue = /* @__PURE__ */ new Map();
+		for (const job of flowJobs) {
+			const group = byQueue.get(job.name) || [];
+			group.push(job);
+			byQueue.set(job.name, group);
+		}
+		const statements = [];
+		for (const [queueName, queueJobs] of byQueue) {
+			const { table, notify } = await this.getQueueCache(queueName);
+			const insertPayload = queueJobs.map((j) => {
+				const dependencyCount = dependencyCountByRef.get(j.ref) ?? 0;
+				return {
+					id: refToId[j.ref],
+					name: queueName,
+					data: j.data ?? null,
+					priority: j.options?.priority,
+					startAfter: j.options?.startAfter,
+					singletonKey: j.options?.singletonKey ?? void 0,
+					singletonSeconds: j.options?.singletonSeconds,
+					groupId: j.options?.group?.id ?? void 0,
+					groupTier: j.options?.group?.tier ?? void 0,
+					expireInSeconds: j.options?.expireInSeconds,
+					deleteAfterSeconds: j.options?.deleteAfterSeconds,
+					retentionSeconds: j.options?.retentionSeconds,
+					retryLimit: j.options?.retryLimit,
+					retryDelay: j.options?.retryDelay,
+					retryBackoff: j.options?.retryBackoff,
+					retryDelayMax: j.options?.retryDelayMax,
+					heartbeatSeconds: j.options?.heartbeatSeconds,
+					deadLetter: j.options?.deadLetter ?? void 0,
+					blocked: dependencyCount > 0 || void 0,
+					blocking: parentRefs.has(j.ref) || void 0,
+					pendingDependencies: dependencyCount || void 0
+				};
+			});
+			statements.push(insertFlowJobs(this.config.schema, {
+				table,
+				name: queueName
+			}, insertPayload));
+			if (this.#notifyEnabled(notify)) statements.push(notifyQueue(this.config.schema, queueName));
+		}
+		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 {
+			await db.executeSql(sql);
+		} catch (err) {
+			rethrowWriteError(err);
+		}
+		return refToId;
+	}
 	getDebounceStartAfter(singletonSeconds, clockOffset) {
 		const debounceInterval = singletonSeconds * 1e3;
 		const now = Date.now() + clockOffset;
@@ -4770,12 +5665,16 @@ var Manager = class extends EventEmitter {
 			policy,
 			limit: options.batchSize || 1,
 			ignoreSingletons: singletonsActive
-		});
+		}, this.config.noSkipLocked);
 		let result;
 		try {
 			result = await db.executeSql(query.text, query.values);
 		} catch (err) {}
-		return result?.rows || [];
+		const rows = result?.rows || [];
+		if (this.config.backend === "cockroachdb") {
+			for (const row of rows) for (const field of NUMERIC_METADATA_FIELDS) if (row[field] !== void 0 && row[field] !== null) row[field] = Number(row[field]);
+		}
+		return rows;
 	}
 	mapCompletionIdArg(id, funcName) {
 		const errorMessage = `${funcName}() requires an id`;
@@ -4800,27 +5699,188 @@ var Manager = class extends EventEmitter {
 		const db = this.assertDb(options);
 		const ids = this.mapCompletionIdArg(id, "complete");
 		const { table } = await this.getQueueCache(name);
+		const outputData = this.mapCompletionDataArg(data);
+		if (this.config.noMultiMutationCte) return this.completeDistributed(name, ids, outputData, table, db, options.includeQueued);
 		const sql = completeJobs(this.config.schema, table, options.includeQueued);
 		const result = await db.executeSql(sql, [
 			name,
 			ids,
-			this.mapCompletionDataArg(data)
+			outputData
 		]);
 		return this.mapCommandResponse(ids, result);
 	}
+	async withDistributedTransaction(db, fn) {
+		if (db === this.db && this.db._pgbdb) return this.db.withTransaction(fn);
+		return fn(db);
+	}
+	async completeDistributed(name, ids, outputData, table, db, includeQueued) {
+		return this.withDistributedTransaction(db, async (tx) => {
+			const completeSql = completeJobsDistributed(this.config.schema, table, includeQueued);
+			const { rows } = await tx.executeSql(completeSql, [
+				name,
+				ids,
+				outputData
+			]);
+			const blockingIds = rows.filter((row) => row.blocking).map((row) => row.id);
+			if (blockingIds.length > 0) {
+				const decrementSql = decrementDependents(this.config.schema);
+				await tx.executeSql(decrementSql, [name, blockingIds]);
+			}
+			return {
+				jobs: ids,
+				requested: ids.length,
+				affected: rows.length
+			};
+		});
+	}
 	async fail(name, id, data, options = {}) {
 		assertQueueName(name);
 		const db = this.assertDb(options);
 		const ids = this.mapCompletionIdArg(id, "fail");
 		const { table } = await this.getQueueCache(name);
+		const outputData = this.mapCompletionDataArg(data);
+		if (this.config.noMultiMutationCte) return this.failDistributed(name, ids, outputData, table, db);
 		const sql = failJobsById(this.config.schema, table);
 		const result = await db.executeSql(sql, [
 			name,
 			ids,
-			this.mapCompletionDataArg(data)
+			outputData
 		]);
 		return this.mapCommandResponse(ids, result);
 	}
+	async failDistributed(name, ids, outputData, table, db) {
+		return this.withDistributedTransaction(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, outputData);
+			return {
+				jobs: ids,
+				requested: ids.length,
+				affected: count
+			};
+		});
+	}
+	async failJobsByTimeoutDistributed(table, queues) {
+		const select = selectJobsToFailByTimeout(this.config.schema, table, queues);
+		return this.expireJobsDistributed(table, select, { value: { message: "job timed out" } });
+	}
+	async failJobsByHeartbeatDistributed(table, queues) {
+		const select = selectJobsToFailByHeartbeat(this.config.schema, table, queues);
+		return this.expireJobsDistributed(table, select, { value: { message: "job heartbeat timeout" } });
+	}
+	async expireJobsDistributed(table, select, outputData) {
+		return this.withDistributedTransaction(this.db, async (tx) => {
+			const { rows: jobs } = await tx.executeSql(select.text, []);
+			if (jobs.length === 0) return 0;
+			const ids = jobs.map((job) => job.id);
+			const deleteSql = deleteJobsByIds(this.config.schema, table);
+			await tx.executeSql(deleteSql.text, [ids]);
+			return this.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 = !forceTerminal && retryCount < retryLimit;
+			let retried = false;
+			if (canRetry) {
+				let startAfter = job.start_after;
+				if (!job.retry_backoff) startAfter = new Date(Date.now() + retryDelay * 1e3);
+				else {
+					const exp = Math.min(16, retryCount + 1);
+					const delay = retryDelay * (Math.pow(2, exp) / 2 + Math.pow(2, exp) / 2 * Math.random());
+					const cappedDelay = retryDelayMax != null ? Math.min(retryDelayMax, delay) : delay;
+					startAfter = new Date(Date.now() + cappedDelay * 1e3);
+				}
+				const { rows } = await tx.executeSql(insertSql, [
+					job.id,
+					job.name,
+					job.priority,
+					job.data,
+					"retry",
+					job.retry_limit,
+					job.retry_count,
+					job.retry_delay,
+					job.retry_backoff,
+					job.retry_delay_max,
+					startAfter,
+					job.started_on,
+					job.singleton_key,
+					job.singleton_on,
+					job.group_id,
+					job.group_tier,
+					job.expire_seconds,
+					job.deletion_seconds,
+					job.created_on,
+					null,
+					job.keep_until,
+					job.policy,
+					jobOutput,
+					job.dead_letter,
+					null,
+					job.heartbeat_seconds,
+					job.blocked,
+					job.blocking,
+					job.pending_dependencies
+				]);
+				retried = rows.length > 0;
+			}
+			if (!retried) {
+				await tx.executeSql(insertSql, [
+					job.id,
+					job.name,
+					job.priority,
+					job.data,
+					"failed",
+					job.retry_limit,
+					job.retry_count,
+					job.retry_delay,
+					job.retry_backoff,
+					job.retry_delay_max,
+					job.start_after,
+					job.started_on,
+					job.singleton_key,
+					job.singleton_on,
+					job.group_id,
+					job.group_tier,
+					job.expire_seconds,
+					job.deletion_seconds,
+					job.created_on,
+					/* @__PURE__ */ new Date(),
+					job.keep_until,
+					job.policy,
+					jobOutput,
+					job.dead_letter,
+					null,
+					job.heartbeat_seconds,
+					job.blocked,
+					job.blocking,
+					job.pending_dependencies
+				]);
+				if (job.dead_letter) await tx.executeSql(dlqSql, [
+					job.dead_letter,
+					job.data,
+					jobOutput
+				]);
+			}
+			count++;
+		}
+		return count;
+	}
 	async deleteJob(name, id, options = {}) {
 		assertQueueName(name);
 		const db = this.assertDb(options);
@@ -4888,7 +5948,7 @@ var Manager = class extends EventEmitter {
 		const sql = createQueue$1(this.config.schema, name, {
 			...options,
 			policy
-		});
+		}, this.config.noAdvisoryLocks);
 		await this.db.executeSql(sql);
 	}
 	async getBlockedKeys(name) {
@@ -4904,6 +5964,9 @@ var Manager = class extends EventEmitter {
 		if (names) for (const name of names) assertQueueName(name);
 		const query = getQueues$1(this.config.schema, names);
 		const { rows } = await this.db.executeSql(query.text, query.values);
+		if (this.config.backend === "cockroachdb") {
+			for (const row of rows) for (const field of NUMERIC_QUEUE_FIELDS) if (row[field] !== void 0 && row[field] !== null) row[field] = Number(row[field]);
+		}
 		return rows;
 	}
 	async updateQueue(name, options = {}) {
@@ -4921,16 +5984,13 @@ var Manager = class extends EventEmitter {
 		await this.db.executeSql(sql, [name, options]);
 	}
 	async getQueue(name) {
-		assertQueueName(name);
-		const query = getQueues$1(this.config.schema, [name]);
-		const { rows } = await this.db.executeSql(query.text, query.values);
-		return rows[0] || null;
+		return (await this.getQueues([name]))[0] || null;
 	}
 	async deleteQueue(name) {
 		assertQueueName(name);
 		try {
 			await this.getQueueCache(name);
-			const sql = deleteQueue(this.config.schema, name);
+			const sql = deleteQueue(this.config.schema, name, this.config.noAdvisoryLocks);
 			await this.db.executeSql(sql);
 		} catch {}
 	}
@@ -4967,10 +6027,16 @@ var Manager = class extends EventEmitter {
 		const queue = await this.getQueueCache(name);
 		const query = getQueueStats$1(this.config.schema, queue.table, [name]);
 		const { rows } = await this.db.executeSql(query.text, query.values);
-		return Object.assign(queue, rows.at(0) || {
+		const stats = rows.at(0);
+		if (stats && this.config.backend === "cockroachdb") {
+			for (const field of NUMERIC_QUEUE_FIELDS) if (stats[field] !== void 0 && stats[field] !== null) stats[field] = Number(stats[field]);
+		}
+		return Object.assign(queue, stats || {
 			deferredCount: 0,
 			queuedCount: 0,
+			readyCount: 0,
 			activeCount: 0,
+			failedCount: 0,
 			totalCount: 0
 		});
 	}
@@ -4980,8 +6046,13 @@ var Manager = class extends EventEmitter {
 		const { table } = await this.getQueueCache(name);
 		const sql = getJobById$1(this.config.schema, table);
 		const result1 = await db.executeSql(sql, [name, id]);
-		if (result1?.rows?.length === 1) return result1.rows[0];
-		else return null;
+		if (result1?.rows?.length === 1) {
+			const row = result1.rows[0];
+			if (this.config.backend === "cockroachdb") {
+				for (const field of NUMERIC_METADATA_FIELDS) if (row[field] !== void 0 && row[field] !== null) row[field] = Number(row[field]);
+			}
+			return row;
+		} else return null;
 	}
 	async findJobs(name, options = {}) {
 		assertQueueName(name);
@@ -5000,6 +6071,26 @@ var Manager = class extends EventEmitter {
 		if (data !== void 0) values.push(JSON.stringify(data));
 		return (await db.executeSql(sql, values))?.rows || [];
 	}
+	async getDependencies(name, id, options = {}) {
+		assertQueueName(name);
+		const db = this.assertDb(options);
+		const sql = getDependencies(this.config.schema);
+		const { rows } = await db.executeSql(sql, [name, id]);
+		return rows.map((r) => ({
+			name: r.parentName,
+			id: r.parentId
+		}));
+	}
+	async getDependents(name, id, options = {}) {
+		assertQueueName(name);
+		const db = this.assertDb(options);
+		const sql = getDependents(this.config.schema);
+		const { rows } = await db.executeSql(sql, [name, id]);
+		return rows.map((r) => ({
+			name: r.childName,
+			id: r.childId
+		}));
+	}
 	assertDb(options) {
 		if (options.db) return options.db;
 		if (this.db._pgbdb) assert(this.db.opened, "Database connection is not opened");
@@ -5008,7 +6099,7 @@ var Manager = class extends EventEmitter {
 };
 //#endregion
 //#region ../../src/boss.ts
-var events$2 = {
+var events$3 = {
 	error: "error",
 	warning: "warning"
 };
@@ -5034,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;
@@ -5069,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) {
@@ -5099,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;
 		}
@@ -5142,17 +6233,21 @@ var Boss = class extends EventEmitter {
 		if (this.#stopping) return;
 		if (rows.length) {
 			const queues = rows.map((q) => q.name);
-			const cacheStatsSql = cacheQueueStats(this.#config.schema, table, queues);
+			const cacheStatsSql = cacheQueueStats(this.#config.schema, table, queues, this.#config.noAdvisoryLocks);
 			const { rows: rowsCacheStats } = await this.#executeQuery(cacheStatsSql);
 			if (this.#stopping) return;
-			const warnings = rowsCacheStats.filter((i) => i.queuedCount > (i.warningQueueSize || WARNINGS.LARGE_QUEUE.size));
+			const warnings = rowsCacheStats.filter((i) => Number(i.queuedCount) > (Number(i.warningQueueSize) || WARNINGS.LARGE_QUEUE.size));
 			for (const warning of warnings) await emitAndPersistWarning(this.#warningContext, WARNING_TYPES.QUEUE_BACKLOG, WARNINGS.LARGE_QUEUE.message, warning);
-			const sql = failJobsByTimeout(this.#config.schema, table, queues);
-			await this.#executeQuery(sql);
+			if (this.#config.noMultiMutationCte) await this.#manager.failJobsByTimeoutDistributed(table, queues);
+			else {
+				const sql = failJobsByTimeout(this.#config.schema, table, queues, this.#config.noAdvisoryLocks);
+				await this.#executeQuery(sql);
+			}
 			if (this.#stopping) return;
 			const heartbeatQueues = queues.filter((q) => heartbeatQueueNames.has(q));
-			if (heartbeatQueues.length) {
-				const heartbeatSql = failJobsByHeartbeat(this.#config.schema, table, heartbeatQueues);
+			if (heartbeatQueues.length) if (this.#config.noMultiMutationCte) await this.#manager.failJobsByHeartbeatDistributed(table, heartbeatQueues);
+			else {
+				const heartbeatSql = failJobsByHeartbeat(this.#config.schema, table, heartbeatQueues, this.#config.noAdvisoryLocks);
 				await this.#executeQuery(heartbeatSql);
 			}
 		}
@@ -5164,14 +6259,16 @@ var Boss = class extends EventEmitter {
 		if (this.#stopping) return;
 		if (rows.length) {
 			const queues = rows.map((q) => q.name);
-			const sql = deletion(this.#config.schema, table, queues);
+			const sql = deletion(this.#config.schema, table, queues, this.#config.noAdvisoryLocks);
 			await this.#executeQuery(sql);
+			const depSql = cleanupDependencies(this.#config.schema, table, queues, this.#config.noAdvisoryLocks);
+			await this.#executeQuery(depSql);
 		}
 	}
 };
 //#endregion
 //#region ../../src/bam.ts
-var events$1 = {
+var events$2 = {
 	error: "error",
 	bam: "bam"
 };
@@ -5181,7 +6278,7 @@ var Bam = class extends EventEmitter {
 	#pollInterval;
 	#db;
 	#config;
-	events = events$1;
+	events = events$2;
 	constructor(db, config) {
 		super();
 		this.#db = db;
@@ -5217,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;
 		}
@@ -5226,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",
@@ -5237,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",
@@ -5247,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",
@@ -5273,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;
@@ -5304,6 +6471,78 @@ 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();
+		try {
+			await client.query("BEGIN");
+			const result = await fn({ executeSql: (text, values) => client.query(text, values) });
+			await client.query("COMMIT");
+			return result;
+		} catch (err) {
+			await client.query("ROLLBACK");
+			throw err;
+		} finally {
+			client.release();
+		}
+	}
 };
 //#endregion
 //#region ../../src/index.ts
@@ -5326,6 +6565,7 @@ var PgBoss = class extends EventEmitter {
 	#manager;
 	#timekeeper;
 	#bam;
+	#notifier;
 	constructor(value) {
 		super();
 		this.#stoppingOn = null;
@@ -5341,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));
@@ -5357,23 +6601,43 @@ var PgBoss = class extends EventEmitter {
 	async start() {
 		if (this.#starting || this.#started) return this;
 		this.#starting = true;
-		if (this.#db._pgbdb && !this.#db.opened) await this.#db.open();
-		if (this.#config.migrate) await this.#contractor.start();
-		else await this.#contractor.check();
-		await this.#manager.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();
+		try {
+			if (this.#db._pgbdb && !this.#db.opened) await this.#db.open();
+			await this.#warnIfDistributedMisconfigured();
+			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();
+		} catch (err) {
+			this.#starting = false;
+			throw err;
+		}
 		this.#starting = false;
 		this.#started = true;
 		this.#stopped = false;
 		return this;
 	}
+	async #warnIfDistributedMisconfigured() {
+		try {
+			const { rows } = await this.#db.executeSql("SELECT version()");
+			const version = rows?.[0]?.version || "";
+			if (/yugabyte|-yb-/i.test(version)) {
+				if (!this.#config.noTablePartitioning || !this.#config.noAdvisoryLocks) this.emit(events.warning, {
+					message: "YugabyteDB detected: set backend: 'yugabytedb' for compatibility. Partitioned queues (partition: true) are not supported on YugabyteDB.",
+					data: { backend: "yugabytedb" }
+				});
+			}
+		} catch {}
+	}
 	async stop(options = {}) {
 		if (this.#stoppingOn || this.#stopped) return;
 		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();
@@ -5408,6 +6672,9 @@ var PgBoss = class extends EventEmitter {
 	insert(name, jobs, options) {
 		return this.#manager.insert(name, jobs, options);
 	}
+	flow(jobs, options) {
+		return this.#manager.flow(jobs, options);
+	}
 	fetch(name, options = {}) {
 		return this.#manager.fetch(name, options);
 	}
@@ -5474,6 +6741,12 @@ var PgBoss = class extends EventEmitter {
 	getBlockedKeys(name) {
 		return this.#manager.getBlockedKeys(name);
 	}
+	getDependencies(name, id, options) {
+		return this.#manager.getDependencies(name, id, options);
+	}
+	getDependents(name, id, options) {
+		return this.#manager.getDependents(name, id, options);
+	}
 	updateQueue(name, options) {
 		return this.#manager.updateQueue(name, options);
 	}
@@ -5531,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;
 	}
@@ -5626,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",
@@ -5879,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
 	};
@@ -5992,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",
@@ -6002,9 +7351,9 @@ var statCards = [
 		accent: "primary"
 	},
 	{
-		name: "Deferred",
-		key: "totalDeferred",
-		hint: "scheduled for later",
+		name: "Failed",
+		key: "totalFailed",
+		hint: "recent failures",
 		accent: "neutral"
 	},
 	{
@@ -6216,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",
@@ -6258,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, {
@@ -6329,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",
@@ -6843,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) {
@@ -6883,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);
@@ -6931,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) {
@@ -7111,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"));
@@ -7148,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, {
@@ -7314,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",
@@ -7330,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);
@@ -7353,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)]",
@@ -7537,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) };
 }
@@ -7610,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: {
@@ -8058,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");
@@ -8136,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: {
@@ -8195,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",
@@ -8209,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",
@@ -8556,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 });
@@ -8615,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: {
@@ -8868,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;
@@ -8890,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) {
@@ -9000,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);
@@ -9023,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: {
@@ -9183,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) };
 }
@@ -9241,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: {
@@ -9507,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) };
 }
@@ -9562,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: {
@@ -9794,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,
@@ -9905,8 +11500,8 @@ function WarningTypeBadge({ type }) {
 //#region \0virtual:react-router/server-manifest
 var server_manifest_default = {
 	"entry": {
-		"module": "/assets/entry.client-6KjasuHH.js",
-		"imports": ["/assets/jsx-runtime-DcdjQ3vN.js", "/assets/react-dom-DQHA9Ik4.js"],
+		"module": "/assets/entry.client-CqyjuPDB.js",
+		"imports": ["/assets/jsx-runtime-RQyiN6Nr.js", "/assets/react-dom-D_m_Zgd3.js"],
 		"css": []
 	},
 	"routes": {
@@ -9923,16 +11518,16 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/root-Cvarn0sH.js",
+			"module": "/assets/root-qxoeL6W3.js",
 			"imports": [
-				"/assets/jsx-runtime-DcdjQ3vN.js",
-				"/assets/react-dom-DQHA9Ik4.js",
-				"/assets/db-link-DISwKBYZ.js",
-				"/assets/MenuTrigger-CkqlwCsV.js",
-				"/assets/createLucideIcon-oZ0wXCaF.js",
-				"/assets/useOpenInteractionType-BGObzouY.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-D24FtLBP.css"],
+			"css": ["/assets/root-B0MB8jZH.css"],
 			"clientActionModule": void 0,
 			"clientLoaderModule": void 0,
 			"clientMiddlewareModule": void 0,
@@ -9951,15 +11546,15 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/_index-CNX0dPQi.js",
+			"module": "/assets/_index-DqpFaaQw.js",
 			"imports": [
-				"/assets/jsx-runtime-DcdjQ3vN.js",
-				"/assets/db-link-DISwKBYZ.js",
-				"/assets/error-card-2aexlkmv.js",
-				"/assets/badge-DFReduIj.js",
-				"/assets/button-CafwM-5D.js",
-				"/assets/stat-card-y2feeHt0.js",
-				"/assets/table-B5BEGV9S.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,
@@ -9980,24 +11575,24 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/jobs-BjoGjnb0.js",
+			"module": "/assets/jobs-CAd_qqLH.js",
 			"imports": [
-				"/assets/jsx-runtime-DcdjQ3vN.js",
-				"/assets/db-link-DISwKBYZ.js",
-				"/assets/error-card-2aexlkmv.js",
-				"/assets/badge-DFReduIj.js",
-				"/assets/button-CafwM-5D.js",
-				"/assets/filter-select-Dln9CAM3.js",
-				"/assets/pagination-5gEldBFM.js",
-				"/assets/table-B5BEGV9S.js",
-				"/assets/MenuTrigger-CkqlwCsV.js",
-				"/assets/useOpenInteractionType-BGObzouY.js",
-				"/assets/createLucideIcon-oZ0wXCaF.js",
-				"/assets/check-BePyOaOM.js",
-				"/assets/chevron-down-C8oENez_.js",
-				"/assets/chevron-right-B0sTJmdc.js",
-				"/assets/x-EA6eZ1AP.js",
-				"/assets/react-dom-DQHA9Ik4.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,
@@ -10018,14 +11613,14 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/queues._index-BM3eKnSr.js",
+			"module": "/assets/queues._index-8YriSqbQ.js",
 			"imports": [
-				"/assets/jsx-runtime-DcdjQ3vN.js",
-				"/assets/db-link-DISwKBYZ.js",
-				"/assets/badge-DFReduIj.js",
-				"/assets/button-CafwM-5D.js",
-				"/assets/filter-select-Dln9CAM3.js",
-				"/assets/table-B5BEGV9S.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,
@@ -10046,14 +11641,14 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/queues.create-BVR72i85.js",
+			"module": "/assets/queues.create-DsY0Sc19.js",
 			"imports": [
-				"/assets/jsx-runtime-DcdjQ3vN.js",
-				"/assets/db-link-DISwKBYZ.js",
-				"/assets/error-card-2aexlkmv.js",
-				"/assets/button-CafwM-5D.js",
-				"/assets/chevron-down-C8oENez_.js",
-				"/assets/createLucideIcon-oZ0wXCaF.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,
@@ -10074,25 +11669,25 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/queues._name-DSOGXBen.js",
+			"module": "/assets/queues._name-Cb17IB2u.js",
 			"imports": [
-				"/assets/jsx-runtime-DcdjQ3vN.js",
-				"/assets/db-link-DISwKBYZ.js",
-				"/assets/error-card-2aexlkmv.js",
-				"/assets/badge-DFReduIj.js",
-				"/assets/button-CafwM-5D.js",
-				"/assets/dialog-IBPuwpas.js",
-				"/assets/filter-select-Dln9CAM3.js",
-				"/assets/pagination-5gEldBFM.js",
-				"/assets/stat-card-y2feeHt0.js",
-				"/assets/table-B5BEGV9S.js",
-				"/assets/MenuTrigger-CkqlwCsV.js",
-				"/assets/createLucideIcon-oZ0wXCaF.js",
-				"/assets/chevron-down-C8oENez_.js",
-				"/assets/chevron-right-B0sTJmdc.js",
-				"/assets/useOpenInteractionType-BGObzouY.js",
-				"/assets/x-EA6eZ1AP.js",
-				"/assets/react-dom-DQHA9Ik4.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,
@@ -10113,19 +11708,19 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/queues._name.jobs._jobId-DKGu8NkE.js",
+			"module": "/assets/queues._name.jobs._jobId-Bkv8POBj.js",
 			"imports": [
-				"/assets/jsx-runtime-DcdjQ3vN.js",
-				"/assets/db-link-DISwKBYZ.js",
-				"/assets/error-card-2aexlkmv.js",
-				"/assets/badge-DFReduIj.js",
-				"/assets/button-CafwM-5D.js",
-				"/assets/dialog-IBPuwpas.js",
-				"/assets/createLucideIcon-oZ0wXCaF.js",
-				"/assets/check-BePyOaOM.js",
-				"/assets/useOpenInteractionType-BGObzouY.js",
-				"/assets/x-EA6eZ1AP.js",
-				"/assets/react-dom-DQHA9Ik4.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,
@@ -10146,15 +11741,15 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/schedules-CE-hWC9e.js",
+			"module": "/assets/schedules-iYfIJxOD.js",
 			"imports": [
-				"/assets/jsx-runtime-DcdjQ3vN.js",
-				"/assets/db-link-DISwKBYZ.js",
-				"/assets/error-card-2aexlkmv.js",
-				"/assets/badge-DFReduIj.js",
-				"/assets/button-CafwM-5D.js",
-				"/assets/pagination-5gEldBFM.js",
-				"/assets/table-B5BEGV9S.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,
@@ -10175,17 +11770,17 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/schedules._name._key-DT8Kg4jU.js",
+			"module": "/assets/schedules._name._key-CJVu73XY.js",
 			"imports": [
-				"/assets/jsx-runtime-DcdjQ3vN.js",
-				"/assets/db-link-DISwKBYZ.js",
-				"/assets/error-card-2aexlkmv.js",
-				"/assets/button-CafwM-5D.js",
-				"/assets/dialog-IBPuwpas.js",
-				"/assets/useOpenInteractionType-BGObzouY.js",
-				"/assets/x-EA6eZ1AP.js",
-				"/assets/react-dom-DQHA9Ik4.js",
-				"/assets/createLucideIcon-oZ0wXCaF.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,
@@ -10206,12 +11801,12 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/schedules.new-bKRusXXO.js",
+			"module": "/assets/schedules.new-Cq0Mxa7G.js",
 			"imports": [
-				"/assets/jsx-runtime-DcdjQ3vN.js",
-				"/assets/db-link-DISwKBYZ.js",
-				"/assets/error-card-2aexlkmv.js",
-				"/assets/button-CafwM-5D.js"
+				"/assets/jsx-runtime-RQyiN6Nr.js",
+				"/assets/db-link-BajQ1v8I.js",
+				"/assets/button-9NpSS9Ow.js",
+				"/assets/error-card-BH7i86fH.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -10232,12 +11827,43 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/send-BaWw8x7J.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-DcdjQ3vN.js",
-				"/assets/db-link-DISwKBYZ.js",
-				"/assets/error-card-2aexlkmv.js",
-				"/assets/button-CafwM-5D.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,
@@ -10258,16 +11884,16 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/warnings-lzi34PdC.js",
+			"module": "/assets/warnings-C1R_RzIe.js",
 			"imports": [
-				"/assets/jsx-runtime-DcdjQ3vN.js",
-				"/assets/db-link-DISwKBYZ.js",
-				"/assets/error-card-2aexlkmv.js",
-				"/assets/badge-DFReduIj.js",
-				"/assets/button-CafwM-5D.js",
-				"/assets/filter-select-Dln9CAM3.js",
-				"/assets/pagination-5gEldBFM.js",
-				"/assets/table-B5BEGV9S.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,
@@ -10276,23 +11902,15 @@ var server_manifest_default = {
 			"hydrateFallbackModule": void 0
 		}
 	},
-	"url": "/assets/manifest-e6a94de0.js",
-	"version": "e6a94de0",
+	"url": "/assets/manifest-27e8e133.js",
+	"version": "27e8e133",
 	"sri": void 0
 };
 //#endregion
 //#region \0virtual:react-router/server-build
 var assetsBuildDirectory = "build/client";
 var basename = "/";
-var future = {
-	"unstable_optimizeDeps": false,
-	"v8_passThroughRequests": true,
-	"v8_trailingSlashAwareDataRequests": true,
-	"unstable_previewServerPrerendering": false,
-	"v8_middleware": true,
-	"v8_splitRouteModules": true,
-	"v8_viteEnvironmentApi": true
-};
+var future = { "unstable_optimizeDeps": false };
 var ssr = true;
 var isSpaMode = false;
 var prerender = [];
@@ -10391,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",