@pg-boss/dashboard 1.2.0 → 1.2.1

package/build/server/index.js

@@ -1434,6 +1434,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 +1470,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 +1482,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}`;
@@ -1601,6 +1608,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 +1712,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 +1741,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 +1768,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 +1793,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
@@ -1850,15 +1935,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 +1947,36 @@ 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 deleteQueue(schema, name) {
-	return locked(schema, `SELECT ${schema}.delete_queue('${name}')`, "delete-queue");
+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 +1990,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}'`;
@@ -2159,7 +2246,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 +2283,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 +2305,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 +2330,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 +2346,62 @@ 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 cancelJobs(schema, table) {
@@ -2320,7 +2463,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 +2476,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 +2490,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,7 +2518,10 @@ 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}'
@@ -2380,16 +2532,16 @@ function insertJobs(schema, { table, name, returnId = true }) {
 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 `
@@ -2438,7 +2590,10 @@ function failJobs(schema, table, where, output) {
         output,
         dead_letter,
         heartbeat_on,
-        heartbeat_seconds
+        heartbeat_seconds,
+        blocked,
+        blocking,
+        pending_dependencies
       )
       SELECT
         id,
@@ -2478,7 +2633,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
       ON CONFLICT DO NOTHING
       RETURNING *
@@ -2510,7 +2668,10 @@ function failJobs(schema, table, where, output) {
         output,
         dead_letter,
         heartbeat_on,
-        heartbeat_seconds
+        heartbeat_seconds,
+        blocked,
+        blocking,
+        pending_dependencies
       )
       SELECT
         id,
@@ -2538,7 +2699,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 *
@@ -2566,7 +2730,85 @@ function failJobs(schema, table, where, output) {
     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 +2818,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 `
@@ -2609,7 +2851,7 @@ function getQueueStats$1(schema, table, queues) {
 		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
@@ -2628,22 +2870,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 +2931,48 @@ function getJobById$1(schema, table) {
       AND id = $2
     `;
 }
+function insertDependencies(schema) {
+	return `
+    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
+  `;
+}
+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"
@@ -2744,6 +3033,46 @@ var POLICY = {
 	MIN_POLLING_INTERVAL_MS: 500,
 	MAX_RETENTION_DAYS: 365
 };
+var COMPATIBILITY_FLAGS = [
+	"noSkipLocked",
+	"noMultiMutationCte",
+	"noTablePartitioning",
+	"noDeferrableConstraints",
+	"noAdvisoryLocks",
+	"noCoveringIndexes"
+];
+var BACKEND_PROFILES = {
+	postgres: {
+		kind: "standard",
+		flags: {}
+	},
+	cockroachdb: {
+		kind: "distributed",
+		flags: {
+			noSkipLocked: true,
+			noMultiMutationCte: true,
+			noTablePartitioning: true,
+			noDeferrableConstraints: true,
+			noAdvisoryLocks: true,
+			noCoveringIndexes: 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`);
 }
@@ -2796,6 +3125,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`);
@@ -2875,6 +3280,7 @@ function getConfig(value) {
 	config.supervise = "supervise" in config ? config.supervise : true;
 	config.migrate = "migrate" in config ? config.migrate : true;
 	config.createSchema = "createSchema" in config ? config.createSchema : true;
+	resolveBackend(config);
 	applySchemaConfig(config);
 	applyOpsConfig(config);
 	applyScheduleConfig(config);
@@ -2892,6 +3298,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");
@@ -2965,24 +3382,24 @@ function applyBamConfig(config) {
 }
 //#endregion
 //#region ../../src/migrationStore.ts
-function flatten(schema, commands, version) {
+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 migrate(schema, version, migrations, noAdvisoryLocks) {
 	migrations = migrations || getAll(schema);
 	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);
@@ -2997,7 +3414,7 @@ function migrate(schema, version, migrations) {
 		version
 	});
 	assert(result.install.length > 0, `Version ${version} not found.`);
-	return flatten(schema, result.install, result.version);
+	return flatten(schema, result.install, result.version, noAdvisoryLocks);
 }
 function getAll(schema) {
 	return [
@@ -3743,6 +4160,203 @@ function getAll(schema) {
 				`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$)`,
+				`
+        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;
+        `
+			],
+			uninstall: [
+				`DROP INDEX IF EXISTS ${schema}.job_dep_parent_idx`,
+				`DROP TABLE IF EXISTS ${schema}.job_dependency`,
+				`
+        CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
+        RETURNS VOID AS
+        $$
+        DECLARE
+          tablename varchar := CASE WHEN options->>'partition' = 'true'
+                                THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
+                                ELSE 'job_common'
+                                END;
+          queue_created_on timestamptz;
+        BEGIN
+
+          WITH q as (
+            INSERT INTO ${schema}.queue (
+              name,
+              policy,
+              retry_limit,
+              retry_delay,
+              retry_backoff,
+              retry_delay_max,
+              expire_seconds,
+              retention_seconds,
+              deletion_seconds,
+              warning_queued,
+              dead_letter,
+              partition,
+              table_name,
+              heartbeat_seconds
+            )
+            VALUES (
+              queue_name,
+              options->>'policy',
+              COALESCE((options->>'retryLimit')::int, 2),
+              COALESCE((options->>'retryDelay')::int, 0),
+              COALESCE((options->>'retryBackoff')::bool, false),
+              (options->>'retryDelayMax')::int,
+              COALESCE((options->>'expireInSeconds')::int, 900),
+              COALESCE((options->>'retentionSeconds')::int, 1209600),
+              COALESCE((options->>'deleteAfterSeconds')::int, 604800),
+              COALESCE((options->>'warningQueueSize')::int, 0),
+              options->>'deadLetter',
+              COALESCE((options->>'partition')::bool, false),
+              tablename,
+              (options->>'heartbeatSeconds')::int
+            )
+            ON CONFLICT DO NOTHING
+            RETURNING created_on
+          )
+          SELECT created_on into queue_created_on from q;
+
+          IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
+            RETURN;
+          END IF;
+
+          EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
+
+          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
+          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+          EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+
+          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i5 ON ${schema}.job (name, start_after) INCLUDE (priority, created_on, id) WHERE state < 'active'$cmd$, tablename);
+          EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
+          EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
+
+          IF options->>'policy' = 'short' THEN
+            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
+          ELSIF options->>'policy' = 'singleton' THEN
+            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
+          ELSIF options->>'policy' = 'stately' THEN
+            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
+          ELSIF options->>'policy' = 'exclusive' THEN
+            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
+          ELSIF options->>'policy' = 'key_strict_fifo' THEN
+            EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i8 ON ${schema}.job (name, singleton_key) WHERE state IN ('active', 'retry', 'failed') AND policy = 'key_strict_fifo'$cmd$, tablename);
+            EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, tablename);
+          END IF;
+
+          EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
+          EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
+        END;
+        $$
+        LANGUAGE plpgsql;
+        `,
+				`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`
+			]
 		}
 	];
 }
@@ -3750,7 +4364,7 @@ function getAll(schema) {
 //#region ../../src/contractor.ts
 var schemaVersion = {
 	name: "pg-boss",
-	version: "12.18.3",
+	version: "12.20.0",
 	description: "Queueing jobs in Postgres from Node.js like a boss",
 	type: "module",
 	main: "./dist/index.js",
@@ -3763,6 +4377,7 @@ var schemaVersion = {
 		"serialize-error": "^13.0.1"
 	},
 	devDependencies: {
+		"@electric-sql/pglite": "^0.4.1",
 		"@prisma/adapter-pg": "^7.8.0",
 		"@prisma/client": "^7.8.0",
 		"@tsconfig/node-ts": "^23.6.4",
@@ -3772,6 +4387,7 @@ var schemaVersion = {
 		"@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",
@@ -3789,6 +4405,12 @@ var schemaVersion = {
 		"prepublishOnly": "npm install && npm test && npm run build",
 		"pretest": "prisma generate --schema=test/prisma/schema.prisma",
 		"test": "eslint . && vitest run",
+		"test:distributed": "cross-env DISTRIBUTED=true npm test",
+		"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",
@@ -3797,7 +4419,7 @@ var schemaVersion = {
 		"db:migrate": "node --import=tsx -e 'console.log(require(\"./src\").getMigrationPlans())'",
 		"db:construct": "node --import=tsx -e 'console.log(require(\"./src\").getConstructionPlans())'"
 	},
-	pgboss: { "schema": 30 },
+	pgboss: { "schema": 31 },
 	repository: {
 		"type": "git",
 		"url": "git+https://github.com/timgit/pg-boss.git"
@@ -3864,18 +4486,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);
 	}
 };
@@ -4280,10 +4902,39 @@ var INTERNAL_QUEUES = Object.values(QUEUES).reduce((acc, i) => ({
 	...acc,
 	[i]: i
 }), {});
+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$3 = {
 	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;
 	db;
@@ -4735,6 +5386,10 @@ var Manager = class extends EventEmitter {
 		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;
@@ -4743,13 +5398,100 @@ var Manager = class extends EventEmitter {
 			name,
 			returnId
 		});
-		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 } = 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
+				};
+			});
+			const insertSql = insertJobs(this.config.schema, {
+				table,
+				name: queueName,
+				returnId: true
+			}).replace("$1", () => serializeJsonParam(insertPayload));
+			statements.push(`
+        WITH ins AS (
+          ${insertSql}
+        )
+        SELECT 1 / (CASE WHEN (SELECT count(*) FROM ins) = ${insertPayload.length} THEN 1 ELSE 0 END)
+      `);
+		}
+		if (depRows.length > 0) statements.push(insertDependencies(this.config.schema).replace("$1", () => serializeJsonParam(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 +5512,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 +5546,187 @@ 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) {
+		const insertSql = insertRetryJob(this.config.schema, table);
+		const dlqSql = insertDeadLetterJob(this.config.schema);
+		let count = 0;
+		for (const job of jobs) {
+			const retryCount = Number(job.retry_count);
+			const retryLimit = Number(job.retry_limit);
+			const retryDelay = Number(job.retry_delay);
+			const retryDelayMax = job.retry_delay_max != null ? Number(job.retry_delay_max) : null;
+			const canRetry = retryCount < retryLimit;
+			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,
+					outputData,
+					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,
+					outputData,
+					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,
+					outputData
+				]);
+			}
+			count++;
+		}
+		return count;
+	}
 	async deleteJob(name, id, options = {}) {
 		assertQueueName(name);
 		const db = this.assertDb(options);
@@ -4888,7 +5794,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 +5810,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 +5830,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,7 +5873,11 @@ 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,
 			activeCount: 0,
@@ -4980,8 +5890,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 +5915,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");
@@ -5142,17 +6077,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,8 +6103,10 @@ 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);
 		}
 	}
 };
@@ -5304,6 +6245,21 @@ var Db = class extends EventEmitter {
 		assert(this.opened, "Database not opened. Call open() before executing SQL.");
 		return await this.pool.query(text, values);
 	}
+	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
@@ -5357,18 +6313,36 @@ 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.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;
@@ -5408,6 +6382,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 +6451,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);
 	}
@@ -9905,8 +10888,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-DL_oPh96.js",
+		"imports": ["/assets/jsx-runtime-BgbGXvsu.js", "/assets/react-dom-QnGHOQwT.js"],
 		"css": []
 	},
 	"routes": {
@@ -9923,16 +10906,16 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/root-Cvarn0sH.js",
+			"module": "/assets/root-Df70GAY3.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-BgbGXvsu.js",
+				"/assets/react-dom-QnGHOQwT.js",
+				"/assets/db-link-BWWnHM0k.js",
+				"/assets/MenuTrigger-BhalG0aG.js",
+				"/assets/createLucideIcon-DVP_i62f.js",
+				"/assets/useOpenInteractionType-D3JsvupP.js"
 			],
-			"css": ["/assets/root-D24FtLBP.css"],
+			"css": ["/assets/root-C0MdPLOa.css"],
 			"clientActionModule": void 0,
 			"clientLoaderModule": void 0,
 			"clientMiddlewareModule": void 0,
@@ -9951,15 +10934,15 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/_index-CNX0dPQi.js",
+			"module": "/assets/_index-D1-nZ7Th.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-BgbGXvsu.js",
+				"/assets/db-link-BWWnHM0k.js",
+				"/assets/error-card-B0ANyjh3.js",
+				"/assets/badge-DCQvSdiR.js",
+				"/assets/button-BxLcuaPM.js",
+				"/assets/stat-card-DLtQnscf.js",
+				"/assets/table-DqqzSNik.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -9980,24 +10963,24 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/jobs-BjoGjnb0.js",
+			"module": "/assets/jobs-D0a6Lwq0.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-BgbGXvsu.js",
+				"/assets/db-link-BWWnHM0k.js",
+				"/assets/error-card-B0ANyjh3.js",
+				"/assets/badge-DCQvSdiR.js",
+				"/assets/button-BxLcuaPM.js",
+				"/assets/filter-select--qLjbs9m.js",
+				"/assets/pagination-Bzx8wbXG.js",
+				"/assets/table-DqqzSNik.js",
+				"/assets/MenuTrigger-BhalG0aG.js",
+				"/assets/useOpenInteractionType-D3JsvupP.js",
+				"/assets/createLucideIcon-DVP_i62f.js",
+				"/assets/check-Ch42cXMT.js",
+				"/assets/chevron-down-Byq-CYG9.js",
+				"/assets/chevron-right-CKAGD7DJ.js",
+				"/assets/x-BPKZwOn9.js",
+				"/assets/react-dom-QnGHOQwT.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -10018,14 +11001,14 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/queues._index-BM3eKnSr.js",
+			"module": "/assets/queues._index-D8903DTa.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-BgbGXvsu.js",
+				"/assets/db-link-BWWnHM0k.js",
+				"/assets/badge-DCQvSdiR.js",
+				"/assets/button-BxLcuaPM.js",
+				"/assets/filter-select--qLjbs9m.js",
+				"/assets/table-DqqzSNik.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -10046,14 +11029,14 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/queues.create-BVR72i85.js",
+			"module": "/assets/queues.create-CMqQVLup.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-BgbGXvsu.js",
+				"/assets/db-link-BWWnHM0k.js",
+				"/assets/error-card-B0ANyjh3.js",
+				"/assets/button-BxLcuaPM.js",
+				"/assets/chevron-down-Byq-CYG9.js",
+				"/assets/createLucideIcon-DVP_i62f.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -10074,25 +11057,25 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/queues._name-DSOGXBen.js",
+			"module": "/assets/queues._name-BVt_4pav.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-BgbGXvsu.js",
+				"/assets/db-link-BWWnHM0k.js",
+				"/assets/error-card-B0ANyjh3.js",
+				"/assets/badge-DCQvSdiR.js",
+				"/assets/button-BxLcuaPM.js",
+				"/assets/dialog-Bik519zD.js",
+				"/assets/filter-select--qLjbs9m.js",
+				"/assets/pagination-Bzx8wbXG.js",
+				"/assets/stat-card-DLtQnscf.js",
+				"/assets/table-DqqzSNik.js",
+				"/assets/MenuTrigger-BhalG0aG.js",
+				"/assets/createLucideIcon-DVP_i62f.js",
+				"/assets/chevron-down-Byq-CYG9.js",
+				"/assets/chevron-right-CKAGD7DJ.js",
+				"/assets/useOpenInteractionType-D3JsvupP.js",
+				"/assets/x-BPKZwOn9.js",
+				"/assets/react-dom-QnGHOQwT.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -10113,19 +11096,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-BkG9y75k.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-BgbGXvsu.js",
+				"/assets/db-link-BWWnHM0k.js",
+				"/assets/error-card-B0ANyjh3.js",
+				"/assets/badge-DCQvSdiR.js",
+				"/assets/button-BxLcuaPM.js",
+				"/assets/dialog-Bik519zD.js",
+				"/assets/createLucideIcon-DVP_i62f.js",
+				"/assets/check-Ch42cXMT.js",
+				"/assets/useOpenInteractionType-D3JsvupP.js",
+				"/assets/x-BPKZwOn9.js",
+				"/assets/react-dom-QnGHOQwT.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -10146,15 +11129,15 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/schedules-CE-hWC9e.js",
+			"module": "/assets/schedules-DPXQoaEE.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-BgbGXvsu.js",
+				"/assets/db-link-BWWnHM0k.js",
+				"/assets/error-card-B0ANyjh3.js",
+				"/assets/badge-DCQvSdiR.js",
+				"/assets/button-BxLcuaPM.js",
+				"/assets/pagination-Bzx8wbXG.js",
+				"/assets/table-DqqzSNik.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -10175,17 +11158,17 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/schedules._name._key-DT8Kg4jU.js",
+			"module": "/assets/schedules._name._key-B_luxy1w.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-BgbGXvsu.js",
+				"/assets/db-link-BWWnHM0k.js",
+				"/assets/error-card-B0ANyjh3.js",
+				"/assets/button-BxLcuaPM.js",
+				"/assets/dialog-Bik519zD.js",
+				"/assets/useOpenInteractionType-D3JsvupP.js",
+				"/assets/x-BPKZwOn9.js",
+				"/assets/react-dom-QnGHOQwT.js",
+				"/assets/createLucideIcon-DVP_i62f.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -10206,12 +11189,12 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/schedules.new-bKRusXXO.js",
+			"module": "/assets/schedules.new-BQV7GWzs.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-BgbGXvsu.js",
+				"/assets/db-link-BWWnHM0k.js",
+				"/assets/error-card-B0ANyjh3.js",
+				"/assets/button-BxLcuaPM.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -10232,12 +11215,12 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/send-BaWw8x7J.js",
+			"module": "/assets/send-DJBsfnx_.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-BgbGXvsu.js",
+				"/assets/db-link-BWWnHM0k.js",
+				"/assets/error-card-B0ANyjh3.js",
+				"/assets/button-BxLcuaPM.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -10258,16 +11241,16 @@ var server_manifest_default = {
 			"hasClientMiddleware": false,
 			"hasDefaultExport": true,
 			"hasErrorBoundary": true,
-			"module": "/assets/warnings-lzi34PdC.js",
+			"module": "/assets/warnings-CHKaRfIW.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-BgbGXvsu.js",
+				"/assets/db-link-BWWnHM0k.js",
+				"/assets/error-card-B0ANyjh3.js",
+				"/assets/badge-DCQvSdiR.js",
+				"/assets/button-BxLcuaPM.js",
+				"/assets/filter-select--qLjbs9m.js",
+				"/assets/pagination-Bzx8wbXG.js",
+				"/assets/table-DqqzSNik.js"
 			],
 			"css": [],
 			"clientActionModule": void 0,
@@ -10276,23 +11259,15 @@ var server_manifest_default = {
 			"hydrateFallbackModule": void 0
 		}
 	},
-	"url": "/assets/manifest-e6a94de0.js",
-	"version": "e6a94de0",
+	"url": "/assets/manifest-ef81a0f9.js",
+	"version": "ef81a0f9",
 	"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 = [];