bunqueue 2.9.0 → 2.9.2

package/dist/infrastructure/persistence/postgres/groupSchemaFingerprint.js

@@ -0,0 +1,127 @@
+/** Verify every catalog property required by durable group scheduling. */
+export async function hasCurrentPostgresGroupSchema(tx) {
+    const [schema] = await tx `
+    WITH expected_columns(table_name, column_name, type_name, not_null, default_kind) AS (
+      VALUES
+        ('bunqueue_jobs', 'group_order', 'bigint', FALSE, 'none'),
+        ('bunqueue_group_state', 'namespace', 'text', TRUE, 'none'),
+        ('bunqueue_group_state', 'queue', 'text', TRUE, 'none'),
+        ('bunqueue_group_state', 'group_id', 'text', TRUE, 'none'),
+        ('bunqueue_group_state', 'rate_limit', 'bigint', FALSE, 'none'),
+        ('bunqueue_group_state', 'rate_duration_ms', 'bigint', FALSE, 'none'),
+        ('bunqueue_group_state', 'rate_window_started_at', 'bigint', FALSE, 'none'),
+        ('bunqueue_group_state', 'rate_count', 'bigint', TRUE, 'zero'),
+        ('bunqueue_group_state', 'rate_effective_max', 'bigint', FALSE, 'none'),
+        ('bunqueue_group_state', 'rate_effective_duration_ms', 'bigint', FALSE, 'none'),
+        ('bunqueue_group_state', 'concurrency_limit', 'bigint', FALSE, 'none'),
+        ('bunqueue_group_state', 'last_served', 'bigint', FALSE, 'none')
+    ), expected_indexes(
+      index_name, table_name, columns, descending, predicate
+    ) AS (
+      VALUES
+        ('bunqueue_jobs_group_ready_idx', 'bunqueue_jobs',
+         ARRAY['namespace', 'queue', 'group_id', 'run_at', 'group_order', 'id'],
+         ARRAY[FALSE, FALSE, FALSE, FALSE, FALSE, FALSE],
+         'group_idisnotnullandstate=anyarray[''waiting''::text,''prioritized''::text,' ||
+         '''delayed''::text]'),
+        ('bunqueue_group_state_rotation_idx', 'bunqueue_group_state',
+         ARRAY['namespace', 'queue', 'last_served', 'group_id'],
+         ARRAY[FALSE, FALSE, FALSE, FALSE], '')
+    )
+    SELECT
+      to_regclass('bunqueue_group_state') IS NOT NULL
+      AND EXISTS (
+        SELECT 1 FROM pg_sequence
+        WHERE seqrelid = to_regclass('bunqueue_group_order_seq')
+          AND seqtypid = to_regtype('bigint')
+          AND seqincrement = 1 AND seqmin = 1
+          AND seqmax = 9223372036854775807
+          AND NOT seqcycle AND seqcache = 1
+      )
+      AND (
+        SELECT COALESCE(bool_and(COALESCE(
+          attribute.atttypid = to_regtype(expected.type_name)
+          AND attribute.attnotnull = expected.not_null
+          AND CASE expected.default_kind
+            WHEN 'zero' THEN regexp_replace(
+              lower(COALESCE(pg_get_expr(defaults.adbin, defaults.adrelid), '')),
+              '[()[:space:]]', '', 'g'
+            ) IN ('0', '0::bigint')
+            ELSE defaults.oid IS NULL
+          END,
+          FALSE
+        )), FALSE)
+        FROM expected_columns AS expected
+        LEFT JOIN pg_attribute AS attribute
+          ON attribute.attrelid = to_regclass(expected.table_name)
+         AND attribute.attname = expected.column_name
+         AND NOT attribute.attisdropped
+        LEFT JOIN pg_attrdef AS defaults
+          ON defaults.adrelid = attribute.attrelid
+         AND defaults.adnum = attribute.attnum
+      )
+      AND (
+        SELECT COALESCE(bool_and(COALESCE(
+          indexes.indrelid = to_regclass(expected.table_name)
+          AND indexes.indisvalid AND indexes.indisready
+          AND NOT indexes.indisunique AND NOT indexes.indisexclusion
+          AND indexes.indnkeyatts = cardinality(expected.columns)
+          AND indexes.indnatts = indexes.indnkeyatts
+          AND indexes.indexprs IS NULL
+          AND access_method.amname = 'btree'
+          AND ARRAY(
+            SELECT attribute.attname::text
+            FROM unnest(indexes.indkey::smallint[]) WITH ORDINALITY AS key(attnum, position)
+            JOIN pg_attribute AS attribute
+              ON attribute.attrelid = indexes.indrelid
+             AND attribute.attnum = key.attnum
+            ORDER BY key.position
+          ) = expected.columns
+          AND ARRAY(
+            SELECT (option & 1) = 1
+            FROM unnest(indexes.indoption::smallint[])
+              WITH ORDINALITY AS ordering(option, position)
+            ORDER BY ordering.position
+          ) = expected.descending
+          AND regexp_replace(
+            lower(COALESCE(pg_get_expr(indexes.indpred, indexes.indrelid), '')),
+            '[()[:space:]]', '', 'g'
+          ) = expected.predicate,
+          FALSE
+        )), FALSE)
+        FROM expected_indexes AS expected
+        LEFT JOIN pg_class AS index_class
+          ON index_class.oid = to_regclass(expected.index_name)
+        LEFT JOIN pg_index AS indexes ON indexes.indexrelid = index_class.oid
+        LEFT JOIN pg_am AS access_method ON access_method.oid = index_class.relam
+      )
+      AND EXISTS (
+        SELECT 1
+        FROM pg_constraint AS constraint_state
+        JOIN pg_index AS index_state ON index_state.indexrelid = constraint_state.conindid
+        JOIN pg_class AS index_class ON index_class.oid = index_state.indexrelid
+        JOIN pg_am AS access_method ON access_method.oid = index_class.relam
+        WHERE constraint_state.conrelid = to_regclass('bunqueue_group_state')
+          AND constraint_state.contype = 'p'
+          AND constraint_state.convalidated
+          AND NOT constraint_state.condeferrable
+          AND NOT constraint_state.condeferred
+          AND index_state.indisprimary AND index_state.indisunique
+          AND index_state.indisvalid AND index_state.indisready
+          AND index_state.indimmediate
+          AND index_state.indnkeyatts = 3 AND index_state.indnatts = 3
+          AND index_state.indexprs IS NULL AND index_state.indpred IS NULL
+          AND access_method.amname = 'btree'
+          AND ARRAY(
+            SELECT attribute.attname::text
+            FROM unnest(constraint_state.conkey)
+              WITH ORDINALITY AS key(attnum, position)
+            JOIN pg_attribute AS attribute
+              ON attribute.attrelid = constraint_state.conrelid
+             AND attribute.attnum = key.attnum
+            ORDER BY key.position
+          ) = ARRAY['namespace', 'queue', 'group_id']
+      ) AS valid
+  `;
+    return schema.valid;
+}

package/dist/infrastructure/persistence/postgres/groupStateRetention.d.ts

@@ -0,0 +1,3 @@
+import { type PostgresContext } from './context';
+/** Reclaim bounded batches of inactive policyless group scheduler state. */
+export declare function prunePostgresGroupStates(ctx: PostgresContext, batchSize?: number, maxBatches?: number): Promise<number>;

package/dist/infrastructure/persistence/postgres/groupStateRetention.js

@@ -0,0 +1,93 @@
+import { databaseNow } from './context';
+async function pruneBatch(tx, ctx, batchSize) {
+    const now = await databaseNow(tx);
+    const rows = await tx `
+    SELECT groups.queue, groups.group_id
+    FROM bunqueue_group_state AS groups
+    WHERE groups.namespace = ${ctx.config.namespace}
+      AND NOT EXISTS (
+        SELECT 1 FROM bunqueue_jobs AS job
+        WHERE job.namespace = groups.namespace
+          AND job.queue = groups.queue
+          AND job.group_id = groups.group_id
+          AND job.state IN (
+            'waiting', 'prioritized', 'delayed', 'waiting-children', 'active'
+          )
+      )
+      AND (
+        groups.last_served IS NOT NULL
+        OR (
+          groups.rate_limit IS NULL
+          AND groups.rate_duration_ms IS NULL
+          AND groups.concurrency_limit IS NULL
+          AND (
+            groups.rate_window_started_at IS NULL
+            OR (
+              groups.rate_effective_duration_ms IS NOT NULL
+              AND groups.rate_window_started_at + groups.rate_effective_duration_ms <= ${now}
+            )
+          )
+        )
+      )
+    ORDER BY groups.queue, groups.group_id
+    LIMIT ${batchSize}
+    FOR UPDATE OF groups SKIP LOCKED
+  `;
+    if (rows.length === 0)
+        return { deleted: 0, selected: 0 };
+    const queues = rows.map(({ queue }) => queue);
+    const groupIds = rows.map(({ group_id }) => group_id);
+    await tx `
+    UPDATE bunqueue_group_state AS groups
+    SET last_served = NULL
+    FROM unnest(
+      ${tx.array(queues, 'TEXT')},
+      ${tx.array(groupIds, 'TEXT')}
+    ) AS target(queue, group_id)
+    WHERE groups.namespace = ${ctx.config.namespace}
+      AND groups.queue = target.queue
+      AND groups.group_id = target.group_id
+  `;
+    const deleted = await tx `
+    DELETE FROM bunqueue_group_state AS groups
+    USING unnest(
+      ${tx.array(queues, 'TEXT')},
+      ${tx.array(groupIds, 'TEXT')}
+    ) AS target(queue, group_id)
+    WHERE groups.namespace = ${ctx.config.namespace}
+      AND groups.queue = target.queue
+      AND groups.group_id = target.group_id
+      AND groups.rate_limit IS NULL
+      AND groups.rate_duration_ms IS NULL
+      AND groups.concurrency_limit IS NULL
+      AND (
+        groups.rate_window_started_at IS NULL
+        OR (
+          groups.rate_effective_duration_ms IS NOT NULL
+          AND groups.rate_window_started_at + groups.rate_effective_duration_ms <= ${now}
+        )
+      )
+      AND NOT EXISTS (
+        SELECT 1 FROM bunqueue_jobs AS job
+        WHERE job.namespace = groups.namespace
+          AND job.queue = groups.queue
+          AND job.group_id = groups.group_id
+          AND job.state IN (
+            'waiting', 'prioritized', 'delayed', 'waiting-children', 'active'
+          )
+      )
+    RETURNING groups.group_id
+  `;
+    return { deleted: deleted.length, selected: rows.length };
+}
+/** Reclaim bounded batches of inactive policyless group scheduler state. */
+export async function prunePostgresGroupStates(ctx, batchSize = 1000, maxBatches = 10) {
+    let deleted = 0;
+    for (let batch = 0; batch < maxBatches; batch++) {
+        const result = await ctx.sql.begin((tx) => pruneBatch(tx, ctx, batchSize));
+        deleted += result.deleted;
+        if (result.selected < batchSize)
+            break;
+    }
+    return deleted;
+}

package/dist/infrastructure/persistence/postgres/groups.d.ts

@@ -0,0 +1,11 @@
+import { type GroupRateLimitOverride } from '../../../domain/types/group';
+import { type PostgresContext } from './context';
+export declare function getPostgresGroupJobsCount(ctx: PostgresContext, queue: string, groupId?: string): Promise<number>;
+export declare function getPostgresGroupActiveCount(ctx: PostgresContext, queue: string, groupId: string): Promise<number>;
+export declare function setPostgresGroupRateLimit(ctx: PostgresContext, queue: string, groupId: string, max: number, duration: number): Promise<void>;
+export declare function getPostgresGroupRateLimit(ctx: PostgresContext, queue: string, groupId: string): Promise<GroupRateLimitOverride | null>;
+export declare function removePostgresGroupRateLimit(ctx: PostgresContext, queue: string, groupId: string): Promise<number>;
+export declare function getPostgresGroupRateLimitTtl(ctx: PostgresContext, queue: string, groupId: string, maxJobs?: number): Promise<number>;
+export declare function setPostgresGroupConcurrency(ctx: PostgresContext, queue: string, groupId: string, concurrency: number): Promise<void>;
+export declare function getPostgresGroupConcurrency(ctx: PostgresContext, queue: string, groupId: string): Promise<number | null>;
+export declare function removePostgresGroupConcurrency(ctx: PostgresContext, queue: string, groupId: string): Promise<number>;

package/dist/infrastructure/persistence/postgres/groups.js

@@ -0,0 +1,117 @@
+import { assertGroupId, assertPositiveSafeInteger, } from '../../../domain/types/group';
+import { databaseNow } from './context';
+export async function getPostgresGroupJobsCount(ctx, queue, groupId) {
+    if (groupId !== undefined)
+        assertGroupId(groupId);
+    const [row] = groupId === undefined
+        ? await ctx.sql `
+        SELECT COUNT(*)::bigint AS count FROM bunqueue_jobs
+        WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+          AND group_id IS NOT NULL AND state IN ('waiting', 'prioritized', 'delayed')
+      `
+        : await ctx.sql `
+        SELECT COUNT(*)::bigint AS count FROM bunqueue_jobs
+        WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+          AND group_id = ${groupId} AND state IN ('waiting', 'prioritized', 'delayed')
+      `;
+    return Number(row.count);
+}
+export async function getPostgresGroupActiveCount(ctx, queue, groupId) {
+    assertGroupId(groupId);
+    const now = await databaseNow(ctx.sql);
+    const [row] = await ctx.sql `
+    SELECT COUNT(*)::bigint AS count FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+      AND group_id = ${groupId} AND state = 'active' AND lease_until > ${now}
+  `;
+    return Number(row.count);
+}
+export async function setPostgresGroupRateLimit(ctx, queue, groupId, max, duration) {
+    assertGroupId(groupId);
+    assertPositiveSafeInteger(max, 'max');
+    assertPositiveSafeInteger(duration, 'duration');
+    await ctx.sql `
+    INSERT INTO bunqueue_group_state (
+      namespace, queue, group_id, rate_limit, rate_duration_ms
+    ) VALUES (${ctx.config.namespace}, ${queue}, ${groupId}, ${max}, ${duration})
+    ON CONFLICT (namespace, queue, group_id) DO UPDATE
+    SET rate_limit = EXCLUDED.rate_limit,
+        rate_duration_ms = EXCLUDED.rate_duration_ms,
+        rate_window_started_at = NULL,
+        rate_count = 0,
+        rate_effective_max = NULL,
+        rate_effective_duration_ms = NULL
+  `;
+}
+export async function getPostgresGroupRateLimit(ctx, queue, groupId) {
+    assertGroupId(groupId);
+    const rows = await ctx.sql `
+    SELECT rate_limit, rate_duration_ms, rate_window_started_at, rate_count,
+           rate_effective_duration_ms, concurrency_limit
+    FROM bunqueue_group_state
+    WHERE namespace = ${ctx.config.namespace} AND queue = ${queue} AND group_id = ${groupId}
+  `;
+    const row = rows[0];
+    if (!row || row.rate_limit === null || row.rate_duration_ms === null)
+        return null;
+    return { max: Number(row.rate_limit), duration: Number(row.rate_duration_ms) };
+}
+export async function removePostgresGroupRateLimit(ctx, queue, groupId) {
+    assertGroupId(groupId);
+    const rows = await ctx.sql `
+    UPDATE bunqueue_group_state
+    SET rate_limit = NULL, rate_duration_ms = NULL, rate_window_started_at = NULL,
+        rate_count = 0, rate_effective_max = NULL, rate_effective_duration_ms = NULL
+    WHERE namespace = ${ctx.config.namespace} AND queue = ${queue} AND group_id = ${groupId}
+      AND rate_limit IS NOT NULL
+    RETURNING group_id
+  `;
+    return rows.length;
+}
+export async function getPostgresGroupRateLimitTtl(ctx, queue, groupId, maxJobs) {
+    assertGroupId(groupId);
+    const rows = await ctx.sql `
+    SELECT rate_limit, rate_duration_ms, rate_window_started_at, rate_count,
+           rate_effective_duration_ms, concurrency_limit
+    FROM bunqueue_group_state
+    WHERE namespace = ${ctx.config.namespace} AND queue = ${queue} AND group_id = ${groupId}
+  `;
+    const row = rows[0];
+    if (!row?.rate_window_started_at || row.rate_effective_duration_ms === null)
+        return -2;
+    if (maxJobs !== undefined && Number(row.rate_count) < maxJobs)
+        return 0;
+    const remaining = Number(row.rate_window_started_at) +
+        Number(row.rate_effective_duration_ms) -
+        (await databaseNow(ctx.sql));
+    return remaining > 0 ? remaining : -2;
+}
+export async function setPostgresGroupConcurrency(ctx, queue, groupId, concurrency) {
+    assertGroupId(groupId);
+    assertPositiveSafeInteger(concurrency, 'concurrency');
+    await ctx.sql `
+    INSERT INTO bunqueue_group_state (namespace, queue, group_id, concurrency_limit)
+    VALUES (${ctx.config.namespace}, ${queue}, ${groupId}, ${concurrency})
+    ON CONFLICT (namespace, queue, group_id) DO UPDATE
+    SET concurrency_limit = EXCLUDED.concurrency_limit
+  `;
+}
+export async function getPostgresGroupConcurrency(ctx, queue, groupId) {
+    assertGroupId(groupId);
+    const rows = await ctx.sql `
+    SELECT concurrency_limit FROM bunqueue_group_state
+    WHERE namespace = ${ctx.config.namespace} AND queue = ${queue} AND group_id = ${groupId}
+  `;
+    const value = rows[0]?.concurrency_limit;
+    return value === undefined || value === null ? null : Number(value);
+}
+export async function removePostgresGroupConcurrency(ctx, queue, groupId) {
+    assertGroupId(groupId);
+    const rows = await ctx.sql `
+    UPDATE bunqueue_group_state SET concurrency_limit = NULL
+    WHERE namespace = ${ctx.config.namespace} AND queue = ${queue} AND group_id = ${groupId}
+      AND concurrency_limit IS NOT NULL
+    RETURNING group_id
+  `;
+    return rows.length;
+}

package/dist/infrastructure/persistence/postgres/queueDestruction.js

@@ -135,6 +135,10 @@ export async function obliteratePostgresQueue(ctx, queue) {
       `;
         }
         await tx `
+      DELETE FROM bunqueue_group_state
+      WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+    `;
+        await tx `
       DELETE FROM bunqueue_queue_state
       WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
     `;

package/dist/infrastructure/persistence/postgres/runtime.d.ts

@@ -1,7 +1,6 @@
 import { PostgresEventStream } from './events';
 import type { PostgresContext } from './context';
 import type { PostgresDeliveredStoreEvent, PostgresStorageConfig, PostgresStorageHealth } from './types';
-/** Connection, schema, event stream, health, and maintenance lifecycle. */
 export declare class PostgresQueueStoreRuntime {
     readonly context: PostgresContext;
     readonly events: PostgresEventStream;

package/dist/infrastructure/persistence/postgres/runtime.js

@@ -9,13 +9,13 @@ import { initializePostgresSchema } from './schemaInitialization';
 import { PostgresPostCommitMaintenance } from './postCommitMaintenance';
 import { sweepPostgresEventRetention } from './telemetry';
 import { prunePostgresCompletionTombstones } from './completionLifecycle';
+import { prunePostgresGroupStates } from './groupStateRetention';
 import { PostgresMaintenanceFlights } from './maintenanceFlights';
 import { resolvePostgresRuntimeConfig } from './runtimeConfig';
 import { PostgresEventCommitGc } from './eventCommitGc';
 import { createPostgresConnection } from './connection';
 import { PostgresStorageHealthTracker } from './storageHealth';
 import { heartbeatPostgresBroker, PostgresBrokerSessionFencedError, purgeStalePostgresBrokers, registerPostgresBroker, unregisterPostgresBroker, } from './brokerSessions';
-/** Connection, schema, event stream, health, and maintenance lifecycle. */
 export class PostgresQueueStoreRuntime {
     context;
     events;
@@ -192,6 +192,7 @@ export class PostgresQueueStoreRuntime {
             await recoverExpiredPostgresLeases(this.context);
             await repairPostgresDlq(this.context);
             await prunePostgresCompletionTombstones(this.context);
+            await prunePostgresGroupStates(this.context);
             await sweepPostgresEventRetention(this.context);
             await prunePostgresEventCommits(this.context);
             await this.events.start();
@@ -217,6 +218,7 @@ export class PostgresQueueStoreRuntime {
             }, 'dlq');
             void this.runMaintenance(() => sweepPostgresEventRetention(this.context), 'event-retention');
             void this.postCommitMaintenance.run('completion-retention', () => prunePostgresCompletionTombstones(this.context));
+            void this.postCommitMaintenance.run('group-state-retention', () => prunePostgresGroupStates(this.context));
         }, 60_000);
         this.cronTimer = setInterval(() => void this.runMaintenance(() => processPostgresCrons(this.context), 'cron'), this.config.pollIntervalMs);
     }

package/dist/infrastructure/persistence/postgres/schema.d.ts

@@ -1,4 +1,4 @@
-export declare const POSTGRES_SCHEMA_VERSION = 17;
+export declare const POSTGRES_SCHEMA_VERSION = 19;
 /** PostgreSQL schema for the database-authoritative distributed queue engine. */
-export declare const POSTGRES_SCHEMA = "\nCREATE TABLE IF NOT EXISTS bunqueue_schema_migrations (\n  version INTEGER PRIMARY KEY,\n  applied_at BIGINT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS bunqueue_jobs (\n  namespace TEXT NOT NULL,\n  id TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  payload BYTEA NOT NULL,\n  state TEXT NOT NULL CHECK (\n    state IN ('waiting', 'prioritized', 'delayed', 'waiting-children',\n              'active', 'completed', 'failed')\n  ),\n  priority INTEGER NOT NULL DEFAULT 0,\n  lifo BOOLEAN NOT NULL DEFAULT FALSE,\n  run_at BIGINT NOT NULL,\n  created_at BIGINT NOT NULL,\n  started_at BIGINT,\n  completed_at BIGINT,\n  attempts INTEGER NOT NULL DEFAULT 0,\n  max_attempts INTEGER NOT NULL DEFAULT 3,\n  ttl BIGINT,\n  timeout BIGINT,\n  unique_key TEXT,\n  unique_expires_at BIGINT,\n  custom_id TEXT,\n  group_id TEXT,\n  parent_id TEXT,\n  lease_owner TEXT,\n  lease_broker_id TEXT,\n  lease_broker_session_id TEXT,\n  lease_token TEXT,\n  lease_until BIGINT,\n  lease_renewals INTEGER NOT NULL DEFAULT 0,\n  result BYTEA,\n  dlq_entry BYTEA,\n  dlq_retry_state BYTEA,\n  error TEXT,\n  failure_reason TEXT,\n  version BIGINT NOT NULL DEFAULT 0,\n  PRIMARY KEY (namespace, id)\n);\n\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_ready_idx\n  ON bunqueue_jobs(namespace, queue, priority DESC, run_at ASC, id ASC)\n  WHERE state IN ('waiting', 'prioritized', 'delayed');\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_state_idx\n  ON bunqueue_jobs(namespace, queue, state, created_at, id);\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_lease_idx\n  ON bunqueue_jobs(namespace, lease_until)\n  WHERE state = 'active';\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_parent_idx\n  ON bunqueue_jobs(namespace, parent_id)\n  WHERE parent_id IS NOT NULL;\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_group_ready_idx\n  ON bunqueue_jobs(namespace, queue, group_id, priority DESC, run_at ASC, id ASC)\n  WHERE group_id IS NOT NULL AND state IN ('waiting', 'prioritized', 'delayed');\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_group_active_idx\n  ON bunqueue_jobs(namespace, queue, group_id, lease_until)\n  WHERE group_id IS NOT NULL AND state = 'active';\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_lifo_ready_idx\n  ON bunqueue_jobs(namespace, queue, priority DESC, id DESC)\n  WHERE group_id IS NULL AND lifo AND state IN ('waiting', 'prioritized', 'delayed');\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_ttl_pending_idx\n  ON bunqueue_jobs(namespace, queue, created_at, id)\n  WHERE ttl IS NOT NULL AND state IN ('waiting', 'prioritized', 'delayed');\nALTER TABLE bunqueue_jobs\n  ADD COLUMN IF NOT EXISTS unique_expires_at BIGINT;\nALTER TABLE bunqueue_jobs\n  ADD COLUMN IF NOT EXISTS lease_broker_id TEXT;\nALTER TABLE bunqueue_jobs\n  ADD COLUMN IF NOT EXISTS lease_broker_session_id TEXT;\nALTER TABLE bunqueue_jobs\n  ADD COLUMN IF NOT EXISTS lease_renewals INTEGER NOT NULL DEFAULT 0;\nALTER TABLE bunqueue_jobs\n  ADD COLUMN IF NOT EXISTS dlq_retry_state BYTEA;\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_broker_session_lease_idx\n  ON bunqueue_jobs(namespace, lease_broker_id, lease_broker_session_id, id)\n  WHERE state = 'active';\n\nCREATE TABLE IF NOT EXISTS bunqueue_dependencies (\n  namespace TEXT NOT NULL,\n  job_id TEXT NOT NULL,\n  dependency_id TEXT NOT NULL,\n  PRIMARY KEY (namespace, job_id, dependency_id)\n);\nCREATE INDEX IF NOT EXISTS bunqueue_dependencies_dependency_idx\n  ON bunqueue_dependencies(namespace, dependency_id, job_id);\n\nCREATE TABLE IF NOT EXISTS bunqueue_flow_failures (\n  namespace TEXT NOT NULL,\n  parent_id TEXT NOT NULL,\n  child_id TEXT NOT NULL,\n  child_queue TEXT NOT NULL,\n  mode TEXT NOT NULL CHECK (mode IN ('fail', 'remove', 'ignore', 'continue')),\n  error TEXT NOT NULL,\n  created_at BIGINT NOT NULL,\n  PRIMARY KEY (namespace, parent_id, child_id)\n);\nCREATE INDEX IF NOT EXISTS bunqueue_flow_failures_parent_idx\n  ON bunqueue_flow_failures(namespace, parent_id, mode);\n\nCREATE TABLE IF NOT EXISTS bunqueue_repeat_links (\n  namespace TEXT NOT NULL,\n  original_id TEXT NOT NULL,\n  successor_id TEXT NOT NULL,\n  PRIMARY KEY (namespace, original_id)\n);\nCREATE INDEX IF NOT EXISTS bunqueue_repeat_links_successor_idx\n  ON bunqueue_repeat_links(namespace, successor_id);\n\nCREATE TABLE IF NOT EXISTS bunqueue_job_logs (\n  id BIGSERIAL PRIMARY KEY,\n  namespace TEXT NOT NULL,\n  job_id TEXT NOT NULL,\n  timestamp BIGINT NOT NULL,\n  level TEXT NOT NULL CHECK (level IN ('info', 'warn', 'error')),\n  message TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS bunqueue_job_logs_job_idx\n  ON bunqueue_job_logs(namespace, job_id, id);\n\nCREATE TABLE IF NOT EXISTS bunqueue_crons (\n  namespace TEXT NOT NULL,\n  name TEXT NOT NULL,\n  payload BYTEA NOT NULL,\n  next_run BIGINT NOT NULL,\n  executions INTEGER NOT NULL DEFAULT 0,\n  max_limit INTEGER,\n  updated_at BIGINT NOT NULL,\n  PRIMARY KEY (namespace, name)\n);\nCREATE INDEX IF NOT EXISTS bunqueue_crons_due_idx\n  ON bunqueue_crons(namespace, next_run, name);\n\nCREATE TABLE IF NOT EXISTS bunqueue_workers (\n  namespace TEXT NOT NULL,\n  id TEXT NOT NULL,\n  broker_id TEXT NOT NULL,\n  broker_session_id TEXT,\n  client_id TEXT,\n  queues TEXT[] NOT NULL,\n  payload BYTEA NOT NULL,\n  last_seen BIGINT NOT NULL,\n  PRIMARY KEY (namespace, id)\n);\nCREATE INDEX IF NOT EXISTS bunqueue_workers_queue_idx\n  ON bunqueue_workers USING GIN(queues);\nCREATE INDEX IF NOT EXISTS bunqueue_workers_broker_idx\n  ON bunqueue_workers(namespace, broker_id, client_id);\nALTER TABLE bunqueue_workers\n  ADD COLUMN IF NOT EXISTS broker_session_id TEXT;\nCREATE INDEX IF NOT EXISTS bunqueue_workers_broker_session_idx\n  ON bunqueue_workers(namespace, broker_id, broker_session_id, client_id);\n\nCREATE TABLE IF NOT EXISTS bunqueue_metric_buckets (\n  namespace TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  metric_type TEXT NOT NULL CHECK (metric_type IN ('completed', 'failed')),\n  minute BIGINT NOT NULL,\n  count INTEGER NOT NULL,\n  PRIMARY KEY (namespace, queue, metric_type, minute)\n);\nCREATE TABLE IF NOT EXISTS bunqueue_metric_totals (\n  namespace TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  metric_type TEXT NOT NULL CHECK (metric_type IN ('completed', 'failed')),\n  total_count BIGINT NOT NULL,\n  prev_ts BIGINT NOT NULL,\n  prev_count INTEGER NOT NULL,\n  PRIMARY KEY (namespace, queue, metric_type)\n);\n\nCREATE TABLE IF NOT EXISTS bunqueue_completions (\n  namespace TEXT NOT NULL,\n  job_id TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  completed_at BIGINT NOT NULL,\n  result BYTEA,\n  PRIMARY KEY (namespace, job_id)\n);\nCREATE INDEX IF NOT EXISTS bunqueue_completions_queue_idx\n  ON bunqueue_completions(namespace, queue, job_id);\nCREATE INDEX IF NOT EXISTS bunqueue_completions_recent_idx\n  ON bunqueue_completions(namespace, completed_at DESC, job_id DESC);\n\nCREATE TABLE IF NOT EXISTS bunqueue_queue_state (\n  namespace TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  paused BOOLEAN NOT NULL DEFAULT FALSE,\n  rate_limit INTEGER,\n  rate_duration_ms BIGINT,\n  rate_window_started_at BIGINT,\n  rate_expires_at BIGINT,\n  rate_count INTEGER NOT NULL DEFAULT 0,\n  concurrency_limit INTEGER,\n  stall_config BYTEA,\n  dlq_config BYTEA,\n  PRIMARY KEY (namespace, queue)\n);\n\nALTER TABLE bunqueue_queue_state\n  ADD COLUMN IF NOT EXISTS rate_expires_at BIGINT;\n\nINSERT INTO bunqueue_queue_state (namespace, queue)\nSELECT DISTINCT namespace, queue FROM bunqueue_jobs\nON CONFLICT (namespace, queue) DO NOTHING;\n\nCREATE TABLE IF NOT EXISTS bunqueue_events (\n  id BIGSERIAL PRIMARY KEY,\n  namespace TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  event_type TEXT NOT NULL,\n  job_id TEXT NOT NULL,\n  occurred_at BIGINT NOT NULL,\n  payload BYTEA\n);\nCREATE INDEX IF NOT EXISTS bunqueue_events_namespace_id_idx\n  ON bunqueue_events(namespace, id);\nCREATE INDEX IF NOT EXISTS bunqueue_events_queue_id_idx\n  ON bunqueue_events(namespace, queue, id DESC);\n\nCREATE TABLE IF NOT EXISTS bunqueue_event_prune_watermarks (\n  namespace TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  source_event_id BIGINT NOT NULL,\n  pruned_through BIGINT NOT NULL,\n  PRIMARY KEY (namespace, queue, source_event_id)\n);\nCREATE INDEX IF NOT EXISTS bunqueue_event_prune_watermarks_namespace_queue_idx\n  ON bunqueue_event_prune_watermarks(namespace, queue, pruned_through DESC);\n\n\nCREATE SEQUENCE IF NOT EXISTS bunqueue_event_commit_seq AS BIGINT CACHE 1;\nALTER SEQUENCE bunqueue_event_commit_seq\n  AS BIGINT INCREMENT BY 1 NO MINVALUE NO MAXVALUE NO CYCLE CACHE 1;\n\nCREATE TABLE IF NOT EXISTS bunqueue_event_commits (\n  namespace TEXT NOT NULL,\n  transaction_id BIGINT NOT NULL,\n  commit_seq BIGINT,\n  PRIMARY KEY (namespace, transaction_id)\n);\n\nALTER TABLE bunqueue_event_commits\n  ADD COLUMN IF NOT EXISTS namespace TEXT;\nALTER TABLE bunqueue_event_commits\n  ADD COLUMN IF NOT EXISTS transaction_id BIGINT;\nALTER TABLE bunqueue_event_commits\n  ADD COLUMN IF NOT EXISTS commit_seq BIGINT;\nALTER TABLE bunqueue_event_commits\n  ALTER COLUMN namespace TYPE TEXT USING namespace::text,\n  ALTER COLUMN transaction_id TYPE BIGINT USING transaction_id::bigint,\n  ALTER COLUMN commit_seq TYPE BIGINT USING commit_seq::bigint;\n\nALTER TABLE bunqueue_events\n  ADD COLUMN IF NOT EXISTS transaction_id BIGINT;\nALTER TABLE bunqueue_events\n  ALTER COLUMN transaction_id DROP DEFAULT;\nALTER TABLE bunqueue_events\n  ALTER COLUMN transaction_id TYPE BIGINT USING transaction_id::bigint;\nALTER TABLE bunqueue_events\n  ALTER COLUMN transaction_id SET DEFAULT (pg_current_xact_id()::text::bigint);\n\nALTER TABLE bunqueue_event_prune_watermarks\n  ADD COLUMN IF NOT EXISTS transaction_id BIGINT;\nALTER TABLE bunqueue_event_prune_watermarks\n  ADD COLUMN IF NOT EXISTS commit_seq BIGINT;\nALTER TABLE bunqueue_event_prune_watermarks\n  ADD COLUMN IF NOT EXISTS pruned_commit_seq BIGINT;\nALTER TABLE bunqueue_event_prune_watermarks\n  ADD COLUMN IF NOT EXISTS prunes_current_transaction BOOLEAN NOT NULL DEFAULT FALSE;\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN transaction_id DROP DEFAULT,\n  ALTER COLUMN pruned_commit_seq DROP DEFAULT,\n  ALTER COLUMN prunes_current_transaction DROP DEFAULT;\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN transaction_id TYPE BIGINT USING transaction_id::bigint,\n  ALTER COLUMN commit_seq TYPE BIGINT USING commit_seq::bigint,\n  ALTER COLUMN pruned_commit_seq TYPE BIGINT USING pruned_commit_seq::bigint,\n  ALTER COLUMN prunes_current_transaction TYPE BOOLEAN\n    USING prunes_current_transaction::boolean;\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN transaction_id SET DEFAULT (pg_current_xact_id()::text::bigint);\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN pruned_commit_seq SET DEFAULT 0,\n  ALTER COLUMN prunes_current_transaction SET DEFAULT FALSE;\n\nUPDATE bunqueue_events\nSET transaction_id = -id\nWHERE transaction_id IS NULL;\nUPDATE bunqueue_event_prune_watermarks\nSET transaction_id = COALESCE(transaction_id, -source_event_id),\n    commit_seq = COALESCE(commit_seq, source_event_id),\n    pruned_commit_seq = COALESCE(pruned_commit_seq, commit_seq, source_event_id)\nWHERE transaction_id IS NULL OR commit_seq IS NULL OR pruned_commit_seq IS NULL;\n\nALTER TABLE bunqueue_events\n  ALTER COLUMN transaction_id SET NOT NULL;\nALTER TABLE bunqueue_event_commits\n  ALTER COLUMN namespace SET NOT NULL,\n  ALTER COLUMN transaction_id SET NOT NULL;\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN transaction_id SET NOT NULL,\n  ALTER COLUMN pruned_commit_seq SET NOT NULL,\n  ALTER COLUMN prunes_current_transaction SET NOT NULL;\n\nDO $migration$\nBEGIN\n  IF EXISTS (\n    SELECT 1 FROM pg_attribute\n    WHERE attrelid = to_regclass('bunqueue_events')\n      AND attname = 'commit_seq' AND NOT attisdropped\n  ) THEN\n    EXECUTE $sql$\n      INSERT INTO bunqueue_event_commits (namespace, transaction_id, commit_seq)\n      SELECT namespace, transaction_id, MAX(commit_seq)\n      FROM bunqueue_events\n      WHERE commit_seq IS NOT NULL\n      GROUP BY namespace, transaction_id\n      ON CONFLICT (namespace, transaction_id) DO UPDATE SET\n        commit_seq = GREATEST(\n          COALESCE(bunqueue_event_commits.commit_seq, 0),\n          excluded.commit_seq\n        )\n    $sql$;\n  ELSE\n    INSERT INTO bunqueue_event_commits (namespace, transaction_id, commit_seq)\n    SELECT namespace, transaction_id, MAX(id)\n    FROM bunqueue_events\n    GROUP BY namespace, transaction_id\n    ON CONFLICT (namespace, transaction_id) DO NOTHING;\n  END IF;\nEND;\n$migration$;\n\nINSERT INTO bunqueue_event_commits (namespace, transaction_id, commit_seq)\nSELECT namespace, transaction_id, MAX(commit_seq)\nFROM bunqueue_event_prune_watermarks\nWHERE commit_seq IS NOT NULL\nGROUP BY namespace, transaction_id\nON CONFLICT (namespace, transaction_id) DO UPDATE SET\n  commit_seq = GREATEST(\n    COALESCE(bunqueue_event_commits.commit_seq, 0),\n    excluded.commit_seq\n  );\n\nDO $block$\nDECLARE\n  journal_floor BIGINT := 0;\n  legacy_head_floor BIGINT := 0;\n  sequence_floor BIGINT := 0;\nBEGIN\n  SELECT COALESCE(MAX(commit_seq), 0) INTO journal_floor\n  FROM bunqueue_event_commits;\n  SELECT last_value INTO sequence_floor FROM bunqueue_event_commit_seq;\n  IF to_regclass('bunqueue_event_commit_heads') IS NOT NULL THEN\n    EXECUTE 'SELECT COALESCE(MAX(commit_seq), 0) FROM bunqueue_event_commit_heads'\n      INTO legacy_head_floor;\n  END IF;\n  PERFORM setval(\n    'bunqueue_event_commit_seq',\n    GREATEST(journal_floor, legacy_head_floor, sequence_floor, 1),\n    TRUE\n  );\nEND;\n$block$;\n\nDROP TABLE IF EXISTS bunqueue_event_commit_heads;\n\nDROP TRIGGER IF EXISTS bunqueue_events_register_commit ON bunqueue_events;\nDROP TRIGGER IF EXISTS bunqueue_watermarks_insert_register_commit\n  ON bunqueue_event_prune_watermarks;\nDROP TRIGGER IF EXISTS bunqueue_watermarks_update_register_commit\n  ON bunqueue_event_prune_watermarks;\nDROP TABLE IF EXISTS bunqueue_event_commit_assignments CASCADE;\nDROP INDEX IF EXISTS bunqueue_events_commit_idx;\nDROP INDEX IF EXISTS bunqueue_events_pending_commit_idx;\nALTER TABLE bunqueue_events DROP COLUMN IF EXISTS commit_seq;\n\nDROP INDEX IF EXISTS bunqueue_events_transaction_idx;\nDROP INDEX IF EXISTS bunqueue_event_commits_replay_idx;\nDROP INDEX IF EXISTS bunqueue_event_prune_watermarks_commit_idx;\nDROP INDEX IF EXISTS bunqueue_event_prune_watermarks_pending_commit_idx;\nDROP INDEX IF EXISTS bunqueue_event_prune_watermarks_transaction_idx;\n\nCREATE INDEX bunqueue_events_transaction_idx\n  ON bunqueue_events(namespace, transaction_id, id);\nCREATE INDEX bunqueue_event_commits_replay_idx\n  ON bunqueue_event_commits(namespace, commit_seq, transaction_id)\n  WHERE commit_seq IS NOT NULL;\nCREATE INDEX bunqueue_event_prune_watermarks_commit_idx\n  ON bunqueue_event_prune_watermarks(namespace, queue, commit_seq DESC)\n  WHERE commit_seq IS NOT NULL;\nCREATE INDEX bunqueue_event_prune_watermarks_pending_commit_idx\n  ON bunqueue_event_prune_watermarks(namespace, transaction_id)\n  WHERE commit_seq IS NULL;\nCREATE INDEX bunqueue_event_prune_watermarks_transaction_idx\n  ON bunqueue_event_prune_watermarks(namespace, transaction_id);\n\nCREATE OR REPLACE FUNCTION bunqueue_register_event_rows()\nRETURNS TRIGGER LANGUAGE plpgsql AS $function$\nBEGIN\n  INSERT INTO bunqueue_event_commits (namespace, transaction_id)\n  SELECT DISTINCT namespace, transaction_id FROM new_event_rows\n  ORDER BY namespace, transaction_id\n  ON CONFLICT DO NOTHING;\n  RETURN NULL;\nEND;\n$function$;\n\nCREATE OR REPLACE FUNCTION bunqueue_register_watermark_rows()\nRETURNS TRIGGER LANGUAGE plpgsql AS $function$\nBEGIN\n  INSERT INTO bunqueue_event_commits (namespace, transaction_id)\n  SELECT DISTINCT namespace, transaction_id FROM new_watermark_rows\n  ORDER BY namespace, transaction_id\n  ON CONFLICT DO NOTHING;\n  RETURN NULL;\nEND;\n$function$;\n\nCREATE OR REPLACE FUNCTION bunqueue_assign_event_commit()\nRETURNS TRIGGER LANGUAGE plpgsql AS $function$\nDECLARE\n  assigned_commit_seq BIGINT;\nBEGIN\n  PERFORM pg_advisory_xact_lock(hashtextextended(\n    'bunqueue:event-commit:' || length(NEW.namespace)::text || ':' || NEW.namespace,\n    0\n  ));\n  assigned_commit_seq := nextval('bunqueue_event_commit_seq');\n\n  UPDATE bunqueue_event_commits\n  SET commit_seq = assigned_commit_seq\n  WHERE namespace = NEW.namespace\n    AND transaction_id = NEW.transaction_id\n    AND commit_seq IS NULL;\n  UPDATE bunqueue_event_prune_watermarks\n  SET commit_seq = assigned_commit_seq,\n      pruned_commit_seq = CASE\n        WHEN prunes_current_transaction THEN GREATEST(\n          COALESCE(pruned_commit_seq, 0), assigned_commit_seq\n        )\n        ELSE pruned_commit_seq\n      END,\n      prunes_current_transaction = FALSE\n  WHERE namespace = NEW.namespace\n    AND transaction_id = NEW.transaction_id\n    AND commit_seq IS NULL;\n  RETURN NULL;\nEND;\n$function$;\n\nDROP TRIGGER IF EXISTS bunqueue_events_register_commit ON bunqueue_events;\nCREATE TRIGGER bunqueue_events_register_commit\nAFTER INSERT ON bunqueue_events\nREFERENCING NEW TABLE AS new_event_rows\nFOR EACH STATEMENT EXECUTE FUNCTION bunqueue_register_event_rows();\n\nDROP TRIGGER IF EXISTS bunqueue_watermarks_insert_register_commit\n  ON bunqueue_event_prune_watermarks;\nCREATE TRIGGER bunqueue_watermarks_insert_register_commit\nAFTER INSERT ON bunqueue_event_prune_watermarks\nREFERENCING NEW TABLE AS new_watermark_rows\nFOR EACH STATEMENT EXECUTE FUNCTION bunqueue_register_watermark_rows();\n\nDROP TRIGGER IF EXISTS bunqueue_watermarks_update_register_commit\n  ON bunqueue_event_prune_watermarks;\nCREATE TRIGGER bunqueue_watermarks_update_register_commit\nAFTER UPDATE ON bunqueue_event_prune_watermarks\nREFERENCING NEW TABLE AS new_watermark_rows\nFOR EACH STATEMENT EXECUTE FUNCTION bunqueue_register_watermark_rows();\n\nDROP TRIGGER IF EXISTS bunqueue_assign_event_commit\n  ON bunqueue_event_commits;\nCREATE CONSTRAINT TRIGGER bunqueue_assign_event_commit\nAFTER INSERT ON bunqueue_event_commits\nDEFERRABLE INITIALLY DEFERRED\nFOR EACH ROW EXECUTE FUNCTION bunqueue_assign_event_commit();\n\n\nCREATE TABLE IF NOT EXISTS bunqueue_brokers (\n  namespace TEXT NOT NULL,\n  broker_id TEXT NOT NULL,\n  session_id TEXT,\n  started_at BIGINT NOT NULL,\n  heartbeat_at BIGINT NOT NULL,\n  PRIMARY KEY (namespace, broker_id)\n);\nALTER TABLE bunqueue_brokers\n  ADD COLUMN IF NOT EXISTS session_id TEXT;\n\nDROP INDEX IF EXISTS bunqueue_jobs_live_unique_key_idx;\nCREATE UNIQUE INDEX bunqueue_jobs_live_unique_key_idx\n  ON bunqueue_jobs(namespace, queue, unique_key)\n  WHERE unique_key IS NOT NULL\n    AND state IN ('waiting', 'prioritized', 'delayed', 'waiting-children', 'active');\n";
+export declare const POSTGRES_SCHEMA = "\nCREATE TABLE IF NOT EXISTS bunqueue_schema_migrations (\n  version INTEGER PRIMARY KEY,\n  applied_at BIGINT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS bunqueue_jobs (\n  namespace TEXT NOT NULL,\n  id TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  payload BYTEA NOT NULL,\n  state TEXT NOT NULL CHECK (\n    state IN ('waiting', 'prioritized', 'delayed', 'waiting-children',\n              'active', 'completed', 'failed')\n  ),\n  priority INTEGER NOT NULL DEFAULT 0,\n  lifo BOOLEAN NOT NULL DEFAULT FALSE,\n  run_at BIGINT NOT NULL,\n  created_at BIGINT NOT NULL,\n  started_at BIGINT,\n  completed_at BIGINT,\n  attempts INTEGER NOT NULL DEFAULT 0,\n  max_attempts INTEGER NOT NULL DEFAULT 3,\n  ttl BIGINT,\n  timeout BIGINT,\n  unique_key TEXT,\n  unique_expires_at BIGINT,\n  custom_id TEXT,\n  group_id TEXT,\n  group_order BIGINT,\n  parent_id TEXT,\n  lease_owner TEXT,\n  lease_broker_id TEXT,\n  lease_broker_session_id TEXT,\n  lease_token TEXT,\n  lease_until BIGINT,\n  lease_renewals INTEGER NOT NULL DEFAULT 0,\n  result BYTEA,\n  dlq_entry BYTEA,\n  dlq_retry_state BYTEA,\n  error TEXT,\n  failure_reason TEXT,\n  version BIGINT NOT NULL DEFAULT 0,\n  PRIMARY KEY (namespace, id)\n);\n\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_ready_idx\n  ON bunqueue_jobs(namespace, queue, priority DESC, run_at ASC, id ASC)\n  WHERE state IN ('waiting', 'prioritized', 'delayed');\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_state_idx\n  ON bunqueue_jobs(namespace, queue, state, created_at, id);\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_lease_idx\n  ON bunqueue_jobs(namespace, lease_until)\n  WHERE state = 'active';\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_parent_idx\n  ON bunqueue_jobs(namespace, parent_id)\n  WHERE parent_id IS NOT NULL;\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_group_active_idx\n  ON bunqueue_jobs(namespace, queue, group_id, lease_until)\n  WHERE group_id IS NOT NULL AND state = 'active';\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_lifo_ready_idx\n  ON bunqueue_jobs(namespace, queue, priority DESC, id DESC)\n  WHERE group_id IS NULL AND lifo AND state IN ('waiting', 'prioritized', 'delayed');\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_ttl_pending_idx\n  ON bunqueue_jobs(namespace, queue, created_at, id)\n  WHERE ttl IS NOT NULL AND state IN ('waiting', 'prioritized', 'delayed');\nALTER TABLE bunqueue_jobs\n  ADD COLUMN IF NOT EXISTS unique_expires_at BIGINT;\nALTER TABLE bunqueue_jobs\n  ADD COLUMN IF NOT EXISTS lease_broker_id TEXT;\nALTER TABLE bunqueue_jobs\n  ADD COLUMN IF NOT EXISTS lease_broker_session_id TEXT;\nALTER TABLE bunqueue_jobs\n  ADD COLUMN IF NOT EXISTS lease_renewals INTEGER NOT NULL DEFAULT 0;\nALTER TABLE bunqueue_jobs\n  ADD COLUMN IF NOT EXISTS dlq_retry_state BYTEA;\nCREATE INDEX IF NOT EXISTS bunqueue_jobs_broker_session_lease_idx\n  ON bunqueue_jobs(namespace, lease_broker_id, lease_broker_session_id, id)\n  WHERE state = 'active';\n\nCREATE TABLE IF NOT EXISTS bunqueue_dependencies (\n  namespace TEXT NOT NULL,\n  job_id TEXT NOT NULL,\n  dependency_id TEXT NOT NULL,\n  PRIMARY KEY (namespace, job_id, dependency_id)\n);\nCREATE INDEX IF NOT EXISTS bunqueue_dependencies_dependency_idx\n  ON bunqueue_dependencies(namespace, dependency_id, job_id);\n\nCREATE TABLE IF NOT EXISTS bunqueue_flow_failures (\n  namespace TEXT NOT NULL,\n  parent_id TEXT NOT NULL,\n  child_id TEXT NOT NULL,\n  child_queue TEXT NOT NULL,\n  mode TEXT NOT NULL CHECK (mode IN ('fail', 'remove', 'ignore', 'continue')),\n  error TEXT NOT NULL,\n  created_at BIGINT NOT NULL,\n  PRIMARY KEY (namespace, parent_id, child_id)\n);\nCREATE INDEX IF NOT EXISTS bunqueue_flow_failures_parent_idx\n  ON bunqueue_flow_failures(namespace, parent_id, mode);\n\nCREATE TABLE IF NOT EXISTS bunqueue_repeat_links (\n  namespace TEXT NOT NULL,\n  original_id TEXT NOT NULL,\n  successor_id TEXT NOT NULL,\n  PRIMARY KEY (namespace, original_id)\n);\nCREATE INDEX IF NOT EXISTS bunqueue_repeat_links_successor_idx\n  ON bunqueue_repeat_links(namespace, successor_id);\n\nCREATE TABLE IF NOT EXISTS bunqueue_job_logs (\n  id BIGSERIAL PRIMARY KEY,\n  namespace TEXT NOT NULL,\n  job_id TEXT NOT NULL,\n  timestamp BIGINT NOT NULL,\n  level TEXT NOT NULL CHECK (level IN ('info', 'warn', 'error')),\n  message TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS bunqueue_job_logs_job_idx\n  ON bunqueue_job_logs(namespace, job_id, id);\n\nCREATE TABLE IF NOT EXISTS bunqueue_crons (\n  namespace TEXT NOT NULL,\n  name TEXT NOT NULL,\n  payload BYTEA NOT NULL,\n  next_run BIGINT NOT NULL,\n  executions INTEGER NOT NULL DEFAULT 0,\n  max_limit INTEGER,\n  updated_at BIGINT NOT NULL,\n  PRIMARY KEY (namespace, name)\n);\nCREATE INDEX IF NOT EXISTS bunqueue_crons_due_idx\n  ON bunqueue_crons(namespace, next_run, name);\n\nCREATE TABLE IF NOT EXISTS bunqueue_workers (\n  namespace TEXT NOT NULL,\n  id TEXT NOT NULL,\n  broker_id TEXT NOT NULL,\n  broker_session_id TEXT,\n  client_id TEXT,\n  queues TEXT[] NOT NULL,\n  payload BYTEA NOT NULL,\n  last_seen BIGINT NOT NULL,\n  PRIMARY KEY (namespace, id)\n);\nCREATE INDEX IF NOT EXISTS bunqueue_workers_queue_idx\n  ON bunqueue_workers USING GIN(queues);\nCREATE INDEX IF NOT EXISTS bunqueue_workers_broker_idx\n  ON bunqueue_workers(namespace, broker_id, client_id);\nALTER TABLE bunqueue_workers\n  ADD COLUMN IF NOT EXISTS broker_session_id TEXT;\nCREATE INDEX IF NOT EXISTS bunqueue_workers_broker_session_idx\n  ON bunqueue_workers(namespace, broker_id, broker_session_id, client_id);\n\nCREATE TABLE IF NOT EXISTS bunqueue_metric_buckets (\n  namespace TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  metric_type TEXT NOT NULL CHECK (metric_type IN ('completed', 'failed')),\n  minute BIGINT NOT NULL,\n  count INTEGER NOT NULL,\n  PRIMARY KEY (namespace, queue, metric_type, minute)\n);\nCREATE TABLE IF NOT EXISTS bunqueue_metric_totals (\n  namespace TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  metric_type TEXT NOT NULL CHECK (metric_type IN ('completed', 'failed')),\n  total_count BIGINT NOT NULL,\n  prev_ts BIGINT NOT NULL,\n  prev_count INTEGER NOT NULL,\n  PRIMARY KEY (namespace, queue, metric_type)\n);\n\nCREATE TABLE IF NOT EXISTS bunqueue_completions (\n  namespace TEXT NOT NULL,\n  job_id TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  completed_at BIGINT NOT NULL,\n  result BYTEA,\n  PRIMARY KEY (namespace, job_id)\n);\nCREATE INDEX IF NOT EXISTS bunqueue_completions_queue_idx\n  ON bunqueue_completions(namespace, queue, job_id);\nCREATE INDEX IF NOT EXISTS bunqueue_completions_recent_idx\n  ON bunqueue_completions(namespace, completed_at DESC, job_id DESC);\n\nCREATE TABLE IF NOT EXISTS bunqueue_queue_state (\n  namespace TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  paused BOOLEAN NOT NULL DEFAULT FALSE,\n  rate_limit INTEGER,\n  rate_duration_ms BIGINT,\n  rate_window_started_at BIGINT,\n  rate_expires_at BIGINT,\n  rate_count INTEGER NOT NULL DEFAULT 0,\n  concurrency_limit INTEGER,\n  stall_config BYTEA,\n  dlq_config BYTEA,\n  group_sequence BIGINT NOT NULL DEFAULT 0,\n  PRIMARY KEY (namespace, queue)\n);\n\nALTER TABLE bunqueue_queue_state\n  ADD COLUMN IF NOT EXISTS rate_expires_at BIGINT;\nALTER TABLE bunqueue_queue_state\n  ADD COLUMN IF NOT EXISTS group_sequence BIGINT NOT NULL DEFAULT 0;\n\n\nCREATE SEQUENCE IF NOT EXISTS bunqueue_group_order_seq AS BIGINT CACHE 1;\nALTER SEQUENCE bunqueue_group_order_seq\n  AS BIGINT INCREMENT BY 1 NO MINVALUE NO MAXVALUE NO CYCLE CACHE 1;\n\nALTER TABLE bunqueue_jobs ADD COLUMN IF NOT EXISTS group_order BIGINT;\nALTER TABLE bunqueue_jobs\n  ALTER COLUMN group_order TYPE BIGINT USING group_order::bigint,\n  ALTER COLUMN group_order DROP DEFAULT,\n  ALTER COLUMN group_order DROP NOT NULL;\n\nDO $group_order_backfill$\nDECLARE\n  target RECORD;\nBEGIN\n  PERFORM setval(\n    'bunqueue_group_order_seq',\n    GREATEST(\n      (SELECT last_value FROM bunqueue_group_order_seq),\n      COALESCE((SELECT MAX(group_order) FROM bunqueue_jobs), 0),\n      1\n    ),\n    TRUE\n  );\n  FOR target IN\n    SELECT namespace, id\n    FROM bunqueue_jobs\n    WHERE group_id IS NOT NULL AND group_order IS NULL\n    ORDER BY created_at, id, namespace\n  LOOP\n    UPDATE bunqueue_jobs\n    SET group_order = nextval('bunqueue_group_order_seq')\n    WHERE namespace = target.namespace AND id = target.id;\n  END LOOP;\nEND;\n$group_order_backfill$;\n\nCREATE TABLE IF NOT EXISTS bunqueue_group_state (\n  namespace TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  group_id TEXT NOT NULL,\n  rate_limit BIGINT,\n  rate_duration_ms BIGINT,\n  rate_window_started_at BIGINT,\n  rate_count BIGINT NOT NULL DEFAULT 0,\n  rate_effective_max BIGINT,\n  rate_effective_duration_ms BIGINT,\n  concurrency_limit BIGINT,\n  last_served BIGINT,\n  PRIMARY KEY (namespace, queue, group_id)\n);\nALTER TABLE bunqueue_group_state\n  ADD COLUMN IF NOT EXISTS namespace TEXT,\n  ADD COLUMN IF NOT EXISTS queue TEXT,\n  ADD COLUMN IF NOT EXISTS group_id TEXT,\n  ADD COLUMN IF NOT EXISTS rate_limit BIGINT,\n  ADD COLUMN IF NOT EXISTS rate_duration_ms BIGINT,\n  ADD COLUMN IF NOT EXISTS rate_window_started_at BIGINT,\n  ADD COLUMN IF NOT EXISTS rate_count BIGINT DEFAULT 0,\n  ADD COLUMN IF NOT EXISTS rate_effective_max BIGINT,\n  ADD COLUMN IF NOT EXISTS rate_effective_duration_ms BIGINT,\n  ADD COLUMN IF NOT EXISTS concurrency_limit BIGINT,\n  ADD COLUMN IF NOT EXISTS last_served BIGINT;\nALTER TABLE bunqueue_group_state\n  ALTER COLUMN namespace TYPE TEXT USING namespace::text,\n  ALTER COLUMN queue TYPE TEXT USING queue::text,\n  ALTER COLUMN group_id TYPE TEXT USING group_id::text,\n  ALTER COLUMN rate_limit TYPE BIGINT USING rate_limit::bigint,\n  ALTER COLUMN rate_duration_ms TYPE BIGINT USING rate_duration_ms::bigint,\n  ALTER COLUMN rate_window_started_at TYPE BIGINT USING rate_window_started_at::bigint,\n  ALTER COLUMN rate_count TYPE BIGINT USING rate_count::bigint,\n  ALTER COLUMN rate_effective_max TYPE BIGINT USING rate_effective_max::bigint,\n  ALTER COLUMN rate_effective_duration_ms TYPE BIGINT USING rate_effective_duration_ms::bigint,\n  ALTER COLUMN concurrency_limit TYPE BIGINT USING concurrency_limit::bigint,\n  ALTER COLUMN last_served TYPE BIGINT USING last_served::bigint;\nUPDATE bunqueue_group_state SET rate_count = 0 WHERE rate_count IS NULL;\nALTER TABLE bunqueue_group_state\n  ALTER COLUMN namespace DROP DEFAULT,\n  ALTER COLUMN namespace SET NOT NULL,\n  ALTER COLUMN queue DROP DEFAULT,\n  ALTER COLUMN queue SET NOT NULL,\n  ALTER COLUMN group_id DROP DEFAULT,\n  ALTER COLUMN group_id SET NOT NULL,\n  ALTER COLUMN rate_limit DROP DEFAULT,\n  ALTER COLUMN rate_limit DROP NOT NULL,\n  ALTER COLUMN rate_duration_ms DROP DEFAULT,\n  ALTER COLUMN rate_duration_ms DROP NOT NULL,\n  ALTER COLUMN rate_window_started_at DROP DEFAULT,\n  ALTER COLUMN rate_window_started_at DROP NOT NULL,\n  ALTER COLUMN rate_count SET DEFAULT 0,\n  ALTER COLUMN rate_count SET NOT NULL,\n  ALTER COLUMN rate_effective_max DROP DEFAULT,\n  ALTER COLUMN rate_effective_max DROP NOT NULL,\n  ALTER COLUMN rate_effective_duration_ms DROP DEFAULT,\n  ALTER COLUMN rate_effective_duration_ms DROP NOT NULL,\n  ALTER COLUMN concurrency_limit DROP DEFAULT,\n  ALTER COLUMN concurrency_limit DROP NOT NULL,\n  ALTER COLUMN last_served DROP DEFAULT,\n  ALTER COLUMN last_served DROP NOT NULL;\n\nDO $group_state_primary_key$\nDECLARE\n  constraint_name TEXT;\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1\n    FROM pg_constraint AS constraint_state\n    JOIN pg_index AS index_state ON index_state.indexrelid = constraint_state.conindid\n    JOIN pg_class AS index_class ON index_class.oid = index_state.indexrelid\n    JOIN pg_am AS access_method ON access_method.oid = index_class.relam\n    WHERE constraint_state.conrelid = to_regclass('bunqueue_group_state')\n      AND constraint_state.contype = 'p'\n      AND constraint_state.convalidated\n      AND NOT constraint_state.condeferrable\n      AND NOT constraint_state.condeferred\n      AND index_state.indisprimary AND index_state.indisunique\n      AND index_state.indisvalid AND index_state.indisready\n      AND access_method.amname = 'btree'\n      AND ARRAY(\n        SELECT attribute.attname::text\n        FROM unnest(constraint_state.conkey) WITH ORDINALITY AS key(attnum, position)\n        JOIN pg_attribute AS attribute\n          ON attribute.attrelid = constraint_state.conrelid\n         AND attribute.attnum = key.attnum\n        ORDER BY key.position\n      ) = ARRAY['namespace', 'queue', 'group_id']\n  ) THEN\n    FOR constraint_name IN\n      SELECT conname FROM pg_constraint\n      WHERE conrelid = to_regclass('bunqueue_group_state')\n        AND (contype = 'p' OR conname = 'bunqueue_group_state_pkey')\n    LOOP\n      EXECUTE format(\n        'ALTER TABLE bunqueue_group_state DROP CONSTRAINT %I',\n        constraint_name\n      );\n    END LOOP;\n    IF to_regclass('bunqueue_group_state_pkey') IS NOT NULL THEN\n      DROP INDEX bunqueue_group_state_pkey;\n    END IF;\n    ALTER TABLE bunqueue_group_state\n      ADD CONSTRAINT bunqueue_group_state_pkey PRIMARY KEY (namespace, queue, group_id);\n  END IF;\nEND;\n$group_state_primary_key$;\n\nDROP INDEX IF EXISTS bunqueue_jobs_group_ready_idx;\nCREATE INDEX bunqueue_jobs_group_ready_idx\n  ON bunqueue_jobs(namespace, queue, group_id, run_at ASC, group_order ASC, id ASC)\n  WHERE group_id IS NOT NULL AND state IN ('waiting', 'prioritized', 'delayed');\nDROP INDEX IF EXISTS bunqueue_group_state_rotation_idx;\nCREATE INDEX bunqueue_group_state_rotation_idx\n  ON bunqueue_group_state(namespace, queue, last_served, group_id);\n\n\nINSERT INTO bunqueue_queue_state (namespace, queue)\nSELECT DISTINCT namespace, queue FROM bunqueue_jobs\nON CONFLICT (namespace, queue) DO NOTHING;\n\nCREATE TABLE IF NOT EXISTS bunqueue_events (\n  id BIGSERIAL PRIMARY KEY,\n  namespace TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  event_type TEXT NOT NULL,\n  job_id TEXT NOT NULL,\n  occurred_at BIGINT NOT NULL,\n  payload BYTEA\n);\nCREATE INDEX IF NOT EXISTS bunqueue_events_namespace_id_idx\n  ON bunqueue_events(namespace, id);\nCREATE INDEX IF NOT EXISTS bunqueue_events_queue_id_idx\n  ON bunqueue_events(namespace, queue, id DESC);\n\nCREATE TABLE IF NOT EXISTS bunqueue_event_prune_watermarks (\n  namespace TEXT NOT NULL,\n  queue TEXT NOT NULL,\n  source_event_id BIGINT NOT NULL,\n  pruned_through BIGINT NOT NULL,\n  PRIMARY KEY (namespace, queue, source_event_id)\n);\nCREATE INDEX IF NOT EXISTS bunqueue_event_prune_watermarks_namespace_queue_idx\n  ON bunqueue_event_prune_watermarks(namespace, queue, pruned_through DESC);\n\n\nCREATE SEQUENCE IF NOT EXISTS bunqueue_event_commit_seq AS BIGINT CACHE 1;\nALTER SEQUENCE bunqueue_event_commit_seq\n  AS BIGINT INCREMENT BY 1 NO MINVALUE NO MAXVALUE NO CYCLE CACHE 1;\n\nCREATE TABLE IF NOT EXISTS bunqueue_event_commits (\n  namespace TEXT NOT NULL,\n  transaction_id BIGINT NOT NULL,\n  commit_seq BIGINT,\n  PRIMARY KEY (namespace, transaction_id)\n);\n\nALTER TABLE bunqueue_event_commits\n  ADD COLUMN IF NOT EXISTS namespace TEXT;\nALTER TABLE bunqueue_event_commits\n  ADD COLUMN IF NOT EXISTS transaction_id BIGINT;\nALTER TABLE bunqueue_event_commits\n  ADD COLUMN IF NOT EXISTS commit_seq BIGINT;\nALTER TABLE bunqueue_event_commits\n  ALTER COLUMN namespace TYPE TEXT USING namespace::text,\n  ALTER COLUMN transaction_id TYPE BIGINT USING transaction_id::bigint,\n  ALTER COLUMN commit_seq TYPE BIGINT USING commit_seq::bigint;\n\nALTER TABLE bunqueue_events\n  ADD COLUMN IF NOT EXISTS transaction_id BIGINT;\nALTER TABLE bunqueue_events\n  ALTER COLUMN transaction_id DROP DEFAULT;\nALTER TABLE bunqueue_events\n  ALTER COLUMN transaction_id TYPE BIGINT USING transaction_id::bigint;\nALTER TABLE bunqueue_events\n  ALTER COLUMN transaction_id SET DEFAULT (pg_current_xact_id()::text::bigint);\n\nALTER TABLE bunqueue_event_prune_watermarks\n  ADD COLUMN IF NOT EXISTS transaction_id BIGINT;\nALTER TABLE bunqueue_event_prune_watermarks\n  ADD COLUMN IF NOT EXISTS commit_seq BIGINT;\nALTER TABLE bunqueue_event_prune_watermarks\n  ADD COLUMN IF NOT EXISTS pruned_commit_seq BIGINT;\nALTER TABLE bunqueue_event_prune_watermarks\n  ADD COLUMN IF NOT EXISTS self_pruned_commit_seq BIGINT;\nALTER TABLE bunqueue_event_prune_watermarks\n  ADD COLUMN IF NOT EXISTS prunes_current_transaction BOOLEAN NOT NULL DEFAULT FALSE;\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN transaction_id DROP DEFAULT,\n  ALTER COLUMN pruned_commit_seq DROP DEFAULT,\n  ALTER COLUMN self_pruned_commit_seq DROP DEFAULT,\n  ALTER COLUMN prunes_current_transaction DROP DEFAULT;\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN transaction_id TYPE BIGINT USING transaction_id::bigint,\n  ALTER COLUMN commit_seq TYPE BIGINT USING commit_seq::bigint,\n  ALTER COLUMN pruned_commit_seq TYPE BIGINT USING pruned_commit_seq::bigint,\n  ALTER COLUMN self_pruned_commit_seq TYPE BIGINT USING self_pruned_commit_seq::bigint,\n  ALTER COLUMN prunes_current_transaction TYPE BOOLEAN\n    USING prunes_current_transaction::boolean;\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN transaction_id SET DEFAULT (pg_current_xact_id()::text::bigint);\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN pruned_commit_seq SET DEFAULT 0,\n  ALTER COLUMN self_pruned_commit_seq SET DEFAULT 0,\n  ALTER COLUMN prunes_current_transaction SET DEFAULT FALSE;\n\nUPDATE bunqueue_events\nSET transaction_id = -id\nWHERE transaction_id IS NULL;\nUPDATE bunqueue_event_prune_watermarks\nSET transaction_id = COALESCE(transaction_id, -source_event_id),\n    commit_seq = COALESCE(commit_seq, source_event_id),\n    pruned_commit_seq = COALESCE(pruned_commit_seq, commit_seq, source_event_id),\n    self_pruned_commit_seq = COALESCE(self_pruned_commit_seq, 0)\nWHERE transaction_id IS NULL OR commit_seq IS NULL OR pruned_commit_seq IS NULL\n   OR self_pruned_commit_seq IS NULL;\n\nALTER TABLE bunqueue_events\n  ALTER COLUMN transaction_id SET NOT NULL;\nALTER TABLE bunqueue_event_commits\n  ALTER COLUMN namespace SET NOT NULL,\n  ALTER COLUMN transaction_id SET NOT NULL;\nALTER TABLE bunqueue_event_prune_watermarks\n  ALTER COLUMN transaction_id SET NOT NULL,\n  ALTER COLUMN pruned_commit_seq SET NOT NULL,\n  ALTER COLUMN self_pruned_commit_seq SET NOT NULL,\n  ALTER COLUMN prunes_current_transaction SET NOT NULL;\n\nDO $migration$\nBEGIN\n  IF EXISTS (\n    SELECT 1 FROM pg_attribute\n    WHERE attrelid = to_regclass('bunqueue_events')\n      AND attname = 'commit_seq' AND NOT attisdropped\n  ) THEN\n    EXECUTE $sql$\n      INSERT INTO bunqueue_event_commits (namespace, transaction_id, commit_seq)\n      SELECT namespace, transaction_id, MAX(commit_seq)\n      FROM bunqueue_events\n      WHERE commit_seq IS NOT NULL\n      GROUP BY namespace, transaction_id\n      ON CONFLICT (namespace, transaction_id) DO UPDATE SET\n        commit_seq = GREATEST(\n          COALESCE(bunqueue_event_commits.commit_seq, 0),\n          excluded.commit_seq\n        )\n    $sql$;\n  ELSE\n    INSERT INTO bunqueue_event_commits (namespace, transaction_id, commit_seq)\n    SELECT namespace, transaction_id, MAX(id)\n    FROM bunqueue_events\n    GROUP BY namespace, transaction_id\n    ON CONFLICT (namespace, transaction_id) DO NOTHING;\n  END IF;\nEND;\n$migration$;\n\nINSERT INTO bunqueue_event_commits (namespace, transaction_id, commit_seq)\nSELECT namespace, transaction_id, MAX(commit_seq)\nFROM bunqueue_event_prune_watermarks\nWHERE commit_seq IS NOT NULL\nGROUP BY namespace, transaction_id\nON CONFLICT (namespace, transaction_id) DO UPDATE SET\n  commit_seq = GREATEST(\n    COALESCE(bunqueue_event_commits.commit_seq, 0),\n    excluded.commit_seq\n  );\n\nDO $block$\nDECLARE\n  journal_floor BIGINT := 0;\n  legacy_head_floor BIGINT := 0;\n  sequence_floor BIGINT := 0;\nBEGIN\n  SELECT COALESCE(MAX(commit_seq), 0) INTO journal_floor\n  FROM bunqueue_event_commits;\n  SELECT last_value INTO sequence_floor FROM bunqueue_event_commit_seq;\n  IF to_regclass('bunqueue_event_commit_heads') IS NOT NULL THEN\n    EXECUTE 'SELECT COALESCE(MAX(commit_seq), 0) FROM bunqueue_event_commit_heads'\n      INTO legacy_head_floor;\n  END IF;\n  PERFORM setval(\n    'bunqueue_event_commit_seq',\n    GREATEST(journal_floor, legacy_head_floor, sequence_floor, 1),\n    TRUE\n  );\nEND;\n$block$;\n\nDROP TABLE IF EXISTS bunqueue_event_commit_heads;\n\nDROP TRIGGER IF EXISTS bunqueue_events_register_commit ON bunqueue_events;\nDROP TRIGGER IF EXISTS bunqueue_watermarks_insert_register_commit\n  ON bunqueue_event_prune_watermarks;\nDROP TRIGGER IF EXISTS bunqueue_watermarks_update_register_commit\n  ON bunqueue_event_prune_watermarks;\nDROP TABLE IF EXISTS bunqueue_event_commit_assignments CASCADE;\nDROP INDEX IF EXISTS bunqueue_events_commit_idx;\nDROP INDEX IF EXISTS bunqueue_events_pending_commit_idx;\nALTER TABLE bunqueue_events DROP COLUMN IF EXISTS commit_seq;\n\nDROP INDEX IF EXISTS bunqueue_events_transaction_idx;\nDROP INDEX IF EXISTS bunqueue_event_commits_replay_idx;\nDROP INDEX IF EXISTS bunqueue_event_prune_watermarks_commit_idx;\nDROP INDEX IF EXISTS bunqueue_event_prune_watermarks_pending_commit_idx;\nDROP INDEX IF EXISTS bunqueue_event_prune_watermarks_transaction_idx;\n\nCREATE INDEX bunqueue_events_transaction_idx\n  ON bunqueue_events(namespace, transaction_id, id);\nCREATE INDEX bunqueue_event_commits_replay_idx\n  ON bunqueue_event_commits(namespace, commit_seq, transaction_id)\n  WHERE commit_seq IS NOT NULL;\nCREATE INDEX bunqueue_event_prune_watermarks_commit_idx\n  ON bunqueue_event_prune_watermarks(namespace, queue, commit_seq DESC)\n  WHERE commit_seq IS NOT NULL;\nCREATE INDEX bunqueue_event_prune_watermarks_pending_commit_idx\n  ON bunqueue_event_prune_watermarks(namespace, transaction_id)\n  WHERE commit_seq IS NULL;\nCREATE INDEX bunqueue_event_prune_watermarks_transaction_idx\n  ON bunqueue_event_prune_watermarks(namespace, transaction_id);\n\nCREATE OR REPLACE FUNCTION bunqueue_register_event_rows()\nRETURNS TRIGGER LANGUAGE plpgsql AS $function$\nBEGIN\n  INSERT INTO bunqueue_event_commits (namespace, transaction_id)\n  SELECT DISTINCT namespace, transaction_id FROM new_event_rows\n  ORDER BY namespace, transaction_id\n  ON CONFLICT DO NOTHING;\n  RETURN NULL;\nEND;\n$function$;\n\nCREATE OR REPLACE FUNCTION bunqueue_register_watermark_rows()\nRETURNS TRIGGER LANGUAGE plpgsql AS $function$\nBEGIN\n  INSERT INTO bunqueue_event_commits (namespace, transaction_id)\n  SELECT DISTINCT namespace, transaction_id FROM new_watermark_rows\n  ORDER BY namespace, transaction_id\n  ON CONFLICT DO NOTHING;\n  RETURN NULL;\nEND;\n$function$;\n\nCREATE OR REPLACE FUNCTION bunqueue_assign_event_commit()\nRETURNS TRIGGER LANGUAGE plpgsql AS $function$\nDECLARE\n  assigned_commit_seq BIGINT;\nBEGIN\n  PERFORM pg_advisory_xact_lock(hashtextextended(\n    'bunqueue:event-commit:' || length(NEW.namespace)::text || ':' || NEW.namespace,\n    0\n  ));\n  assigned_commit_seq := nextval('bunqueue_event_commit_seq');\n\n  UPDATE bunqueue_event_commits\n  SET commit_seq = assigned_commit_seq\n  WHERE namespace = NEW.namespace\n    AND transaction_id = NEW.transaction_id\n    AND commit_seq IS NULL;\n  UPDATE bunqueue_event_prune_watermarks\n  SET commit_seq = assigned_commit_seq,\n      pruned_commit_seq = CASE\n        WHEN prunes_current_transaction THEN GREATEST(\n          COALESCE(pruned_commit_seq, 0), assigned_commit_seq\n        )\n        ELSE pruned_commit_seq\n      END,\n      self_pruned_commit_seq = CASE\n        WHEN prunes_current_transaction THEN GREATEST(\n          COALESCE(self_pruned_commit_seq, 0), assigned_commit_seq\n        )\n        ELSE self_pruned_commit_seq\n      END,\n      prunes_current_transaction = FALSE\n  WHERE namespace = NEW.namespace\n    AND transaction_id = NEW.transaction_id\n    AND commit_seq IS NULL;\n  RETURN NULL;\nEND;\n$function$;\n\nDROP TRIGGER IF EXISTS bunqueue_events_register_commit ON bunqueue_events;\nCREATE TRIGGER bunqueue_events_register_commit\nAFTER INSERT ON bunqueue_events\nREFERENCING NEW TABLE AS new_event_rows\nFOR EACH STATEMENT EXECUTE FUNCTION bunqueue_register_event_rows();\n\nDROP TRIGGER IF EXISTS bunqueue_watermarks_insert_register_commit\n  ON bunqueue_event_prune_watermarks;\nCREATE TRIGGER bunqueue_watermarks_insert_register_commit\nAFTER INSERT ON bunqueue_event_prune_watermarks\nREFERENCING NEW TABLE AS new_watermark_rows\nFOR EACH STATEMENT EXECUTE FUNCTION bunqueue_register_watermark_rows();\n\nDROP TRIGGER IF EXISTS bunqueue_watermarks_update_register_commit\n  ON bunqueue_event_prune_watermarks;\nCREATE TRIGGER bunqueue_watermarks_update_register_commit\nAFTER UPDATE ON bunqueue_event_prune_watermarks\nREFERENCING NEW TABLE AS new_watermark_rows\nFOR EACH STATEMENT EXECUTE FUNCTION bunqueue_register_watermark_rows();\n\nDROP TRIGGER IF EXISTS bunqueue_assign_event_commit\n  ON bunqueue_event_commits;\nCREATE CONSTRAINT TRIGGER bunqueue_assign_event_commit\nAFTER INSERT ON bunqueue_event_commits\nDEFERRABLE INITIALLY DEFERRED\nFOR EACH ROW EXECUTE FUNCTION bunqueue_assign_event_commit();\n\n\nCREATE TABLE IF NOT EXISTS bunqueue_brokers (\n  namespace TEXT NOT NULL,\n  broker_id TEXT NOT NULL,\n  session_id TEXT,\n  started_at BIGINT NOT NULL,\n  heartbeat_at BIGINT NOT NULL,\n  PRIMARY KEY (namespace, broker_id)\n);\nALTER TABLE bunqueue_brokers\n  ADD COLUMN IF NOT EXISTS session_id TEXT;\n\nDROP INDEX IF EXISTS bunqueue_jobs_live_unique_key_idx;\nCREATE UNIQUE INDEX bunqueue_jobs_live_unique_key_idx\n  ON bunqueue_jobs(namespace, queue, unique_key)\n  WHERE unique_key IS NOT NULL\n    AND state IN ('waiting', 'prioritized', 'delayed', 'waiting-children', 'active');\n";
 export declare const POSTGRES_EVENT_CHANNEL = "bunqueue_jobs_changed";

package/dist/infrastructure/persistence/postgres/schema.js

@@ -1,5 +1,6 @@
 import { POSTGRES_EVENT_JOURNAL_SCHEMA } from './eventJournalSchema';
-export const POSTGRES_SCHEMA_VERSION = 17;
+import { POSTGRES_GROUP_SCHEMA } from './groupSchema';
+export const POSTGRES_SCHEMA_VERSION = 19;
 /** PostgreSQL schema for the database-authoritative distributed queue engine. */
 export const POSTGRES_SCHEMA = `
 CREATE TABLE IF NOT EXISTS bunqueue_schema_migrations (
@@ -30,6 +31,7 @@ CREATE TABLE IF NOT EXISTS bunqueue_jobs (
   unique_expires_at BIGINT,
   custom_id TEXT,
   group_id TEXT,
+  group_order BIGINT,
   parent_id TEXT,
   lease_owner TEXT,
   lease_broker_id TEXT,
@@ -57,9 +59,6 @@ CREATE INDEX IF NOT EXISTS bunqueue_jobs_lease_idx
 CREATE INDEX IF NOT EXISTS bunqueue_jobs_parent_idx
   ON bunqueue_jobs(namespace, parent_id)
   WHERE parent_id IS NOT NULL;
-CREATE INDEX IF NOT EXISTS bunqueue_jobs_group_ready_idx
-  ON bunqueue_jobs(namespace, queue, group_id, priority DESC, run_at ASC, id ASC)
-  WHERE group_id IS NOT NULL AND state IN ('waiting', 'prioritized', 'delayed');
 CREATE INDEX IF NOT EXISTS bunqueue_jobs_group_active_idx
   ON bunqueue_jobs(namespace, queue, group_id, lease_until)
   WHERE group_id IS NOT NULL AND state = 'active';
@@ -201,11 +200,16 @@ CREATE TABLE IF NOT EXISTS bunqueue_queue_state (
   concurrency_limit INTEGER,
   stall_config BYTEA,
   dlq_config BYTEA,
+  group_sequence BIGINT NOT NULL DEFAULT 0,
   PRIMARY KEY (namespace, queue)
 );
 
 ALTER TABLE bunqueue_queue_state
   ADD COLUMN IF NOT EXISTS rate_expires_at BIGINT;
+ALTER TABLE bunqueue_queue_state
+  ADD COLUMN IF NOT EXISTS group_sequence BIGINT NOT NULL DEFAULT 0;
+
+${POSTGRES_GROUP_SCHEMA}
 
 INSERT INTO bunqueue_queue_state (namespace, queue)
 SELECT DISTINCT namespace, queue FROM bunqueue_jobs

package/dist/infrastructure/persistence/postgres/schemaInitialization.js

@@ -2,6 +2,7 @@ import { postgresAdvisoryLockName } from './advisoryLocks';
 import { databaseNow } from './context';
 import { POSTGRES_ASSIGN_EVENT_COMMIT_BODY, POSTGRES_REGISTER_EVENT_ROWS_BODY, POSTGRES_REGISTER_WATERMARK_ROWS_BODY, } from './eventJournalSchema';
 import { POSTGRES_SCHEMA, POSTGRES_SCHEMA_VERSION } from './schema';
+import { hasCurrentPostgresGroupSchema } from './groupSchemaFingerprint';
 const EXPECTED_FUNCTION_BODIES = new Map([
     ['bunqueue_register_event_rows', POSTGRES_REGISTER_EVENT_ROWS_BODY],
     ['bunqueue_register_watermark_rows', POSTGRES_REGISTER_WATERMARK_ROWS_BODY],
@@ -41,10 +42,12 @@ async function hasCurrentSchema(tx) {
         ('bunqueue_event_prune_watermarks', 'transaction_id', 'bigint', TRUE, 'transaction'),
         ('bunqueue_event_prune_watermarks', 'commit_seq', 'bigint', FALSE, 'none'),
         ('bunqueue_event_prune_watermarks', 'pruned_commit_seq', 'bigint', TRUE, 'zero'),
+        ('bunqueue_event_prune_watermarks', 'self_pruned_commit_seq', 'bigint', TRUE, 'zero'),
         ('bunqueue_event_prune_watermarks', 'prunes_current_transaction', 'boolean', TRUE, 'false'),
         ('bunqueue_brokers', 'session_id', 'text', FALSE, 'none'),
         ('bunqueue_jobs', 'lease_broker_session_id', 'text', FALSE, 'none'),
-        ('bunqueue_workers', 'broker_session_id', 'text', FALSE, 'none')
+        ('bunqueue_workers', 'broker_session_id', 'text', FALSE, 'none'),
+        ('bunqueue_queue_state', 'group_sequence', 'bigint', TRUE, 'zero')
     ), expected_indexes(
       index_name, table_name, columns, descending, predicate, is_unique
     ) AS (
@@ -179,6 +182,8 @@ async function hasCurrentSchema(tx) {
   `;
     if (!objects.valid)
         return false;
+    if (!(await hasCurrentPostgresGroupSchema(tx)))
+        return false;
     const functions = await tx `
     SELECT expected.name, functions.prosrc AS body,
            functions.prorettype = to_regtype('trigger')

package/dist/infrastructure/persistence/postgres/store.d.ts

@@ -3,6 +3,7 @@ import { setPostgresDlqConfig, setPostgresStallConfig } from './control';
 import { type ListPostgresJobsOptions } from './queries';
 import { PostgresAdmissionStore } from './admissionStore';
 import type { CronJobInput } from '../../../domain/types/cron';
+import { type GroupPullOptions } from '../../../domain/types/group';
 import type { Worker } from '../../../domain/types/worker';
 import type { QueueMetricType } from '../../../domain/types/metrics';
 import type { ClaimedPostgresJob, PostgresCompletionInput, PostgresFailureInput } from './types';
@@ -10,8 +11,17 @@ import { finalizePostgresLifetimeMetrics } from './lifetimeMetricsFinalizer';
 import { loadPostgresJobProjections } from './readModels';
 /** Database-authoritative PostgreSQL queue store safe for concurrent brokers. */
 export declare class PostgresQueueStore extends PostgresAdmissionStore {
+    getGroupJobsCount: (queue: string, groupId?: string) => Promise<number>;
+    getGroupActiveCount: (queue: string, groupId: string) => Promise<number>;
+    setGroupRateLimit: (queue: string, groupId: string, max: number, duration: number) => Promise<void>;
+    getGroupRateLimit: (queue: string, groupId: string) => Promise<import("../../../domain/types/group").GroupRateLimitOverride | null>;
+    removeGroupRateLimit: (queue: string, groupId: string) => Promise<number>;
+    getGroupRateLimitTtl: (queue: string, groupId: string, maxJobs?: number) => Promise<number>;
+    setGroupConcurrency: (queue: string, groupId: string, concurrency: number) => Promise<void>;
+    getGroupConcurrency: (queue: string, groupId: string) => Promise<number | null>;
+    removeGroupConcurrency: (queue: string, groupId: string) => Promise<number>;
     now(): Promise<number>;
-    claim(queue: string, count: number, owner?: string, leaseDurationMs?: number): Promise<ClaimedPostgresJob[]>;
+    claim(queue: string, count: number, owner?: string, leaseDurationMs?: number, groupOptions?: GroupPullOptions): Promise<ClaimedPostgresJob[]>;
     complete(id: JobId, token: string, result?: unknown, remove?: boolean): Promise<import("./types").PostgresTransitionResult>;
     completeMany(items: readonly PostgresCompletionInput[]): Promise<import("./types").PostgresBatchCompletionResult[]>;
     fail(input: PostgresFailureInput): Promise<import("./types").PostgresTransitionResult>;