bunqueue 2.8.60 → 2.9.2

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

@@ -0,0 +1,152 @@
+import { jobId } from '../../../domain/types/job';
+import { decodePostgresJob, decodePostgresValue, numeric } from './codec';
+export async function getPostgresJob(ctx, id) {
+    const rows = await ctx.sql `
+    SELECT * FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace} AND id = ${String(id)}
+  `;
+    return rows[0] ? decodePostgresJob(rows[0]) : null;
+}
+export async function getPostgresJobs(ctx, ids, sql = ctx.sql) {
+    if (ids.length === 0)
+        return [];
+    const rows = await sql `
+    SELECT * FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace}
+      AND id = ANY(${sql.array([...new Set(ids.map(String))], 'TEXT')})
+  `;
+    return rows.map(decodePostgresJob);
+}
+/** Return dependency ids that have neither a job row nor durable completion evidence. */
+export async function findMissingPostgresDependencies(ctx, ids) {
+    const requested = [...new Set(ids.map(String))];
+    if (requested.length === 0)
+        return [];
+    const rows = await ctx.sql `
+    WITH requested(id) AS MATERIALIZED (
+      SELECT DISTINCT id
+      FROM unnest(${ctx.sql.array(requested, 'TEXT')}) AS dependency(id)
+    )
+    SELECT requested.id
+    FROM requested
+    WHERE NOT EXISTS (
+      SELECT 1 FROM bunqueue_jobs AS job
+      WHERE job.namespace = ${ctx.config.namespace} AND job.id = requested.id
+    ) AND NOT EXISTS (
+      SELECT 1 FROM bunqueue_completions AS completion
+      WHERE completion.namespace = ${ctx.config.namespace}
+        AND completion.job_id = requested.id
+    )
+  `;
+    return rows.map((row) => jobId(row.id));
+}
+export async function listPostgresJobs(ctx, queue, options = {}, sql = ctx.sql) {
+    const states = options.states ?? [
+        'waiting',
+        'prioritized',
+        'delayed',
+        'waiting-children',
+        'active',
+        'completed',
+        'failed',
+    ];
+    if (states.length === 0)
+        return [];
+    const stateArray = ctx.sql.array([...states], 'TEXT');
+    const limit = Math.max(0, options.limit ?? 1000);
+    const offset = Math.max(0, options.offset ?? 0);
+    const rows = options.asc
+        ? await sql `
+        SELECT * FROM bunqueue_jobs
+        WHERE namespace = ${ctx.config.namespace}
+          AND queue = ${queue}
+          AND state = ANY(${stateArray})
+        ORDER BY created_at ASC, id ASC
+        LIMIT ${limit} OFFSET ${offset}
+      `
+        : await sql `
+        SELECT * FROM bunqueue_jobs
+        WHERE namespace = ${ctx.config.namespace}
+          AND queue = ${queue}
+          AND state = ANY(${stateArray})
+        ORDER BY created_at DESC, id DESC
+        LIMIT ${limit} OFFSET ${offset}
+      `;
+    return rows.map(decodePostgresJob);
+}
+export async function loadAllPostgresJobs(ctx, sql = ctx.sql) {
+    const rows = await sql `
+    WITH retained_completed AS MATERIALIZED (
+      SELECT * FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND state = 'completed'
+      ORDER BY completed_at DESC NULLS LAST, id DESC
+      LIMIT ${ctx.config.maxCompletedJobs}
+    )
+    SELECT * FROM (
+      SELECT * FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND state <> 'completed'
+      UNION ALL
+      SELECT * FROM retained_completed
+    ) AS retained_jobs
+    ORDER BY created_at, id
+  `;
+    return rows.map(decodePostgresJob);
+}
+export async function getPostgresCounts(ctx, queue) {
+    const rows = queue
+        ? await ctx.sql `
+        SELECT state, COUNT(*)::bigint AS count
+        FROM bunqueue_jobs
+        WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+        GROUP BY state
+      `
+        : await ctx.sql `
+        SELECT state, COUNT(*)::bigint AS count
+        FROM bunqueue_jobs
+        WHERE namespace = ${ctx.config.namespace}
+        GROUP BY state
+      `;
+    const byState = new Map(rows.map((row) => [row.state, Number(row.count)]));
+    return {
+        waiting: byState.get('waiting') ?? 0,
+        active: byState.get('active') ?? 0,
+        completed: byState.get('completed') ?? 0,
+        failed: byState.get('failed') ?? 0,
+        delayed: byState.get('delayed') ?? 0,
+        prioritized: byState.get('prioritized') ?? 0,
+        waitingChildren: byState.get('waiting-children') ?? 0,
+    };
+}
+export async function listPostgresQueues(ctx, sql = ctx.sql) {
+    const rows = await sql `
+    SELECT queue FROM bunqueue_jobs WHERE namespace = ${ctx.config.namespace}
+    UNION
+    SELECT queue FROM bunqueue_queue_state WHERE namespace = ${ctx.config.namespace}
+    ORDER BY queue
+  `;
+    return rows.map((row) => row.queue);
+}
+export async function listPostgresDlq(ctx, queue, limit = 1000) {
+    const rows = await ctx.sql `
+    SELECT id, dlq_entry FROM bunqueue_jobs
+    WHERE namespace = ${ctx.config.namespace}
+      AND queue = ${queue}
+      AND state = 'failed'
+      AND dlq_entry IS NOT NULL
+    ORDER BY completed_at DESC, id DESC
+    LIMIT ${Math.max(0, limit)}
+  `;
+    return rows.flatMap((row) => {
+        const entry = decodePostgresValue(row.dlq_entry, null, `postgresDlq:${row.id}`);
+        return entry ? [entry] : [];
+    });
+}
+export async function latestPostgresEventId(ctx) {
+    const [row] = await ctx.sql `
+    SELECT MAX(id) AS id FROM bunqueue_events WHERE namespace = ${ctx.config.namespace}
+  `;
+    return numeric(row.id) ?? 0;
+}
+export function jobsOnly(rows) {
+    return rows.map((row) => row.job);
+}

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

@@ -0,0 +1,3 @@
+import { type PostgresContext } from './context';
+export declare function drainPostgresQueue(ctx: PostgresContext, queue: string): Promise<number>;
+export declare function obliteratePostgresQueue(ctx: PostgresContext, queue: string): Promise<number>;

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

@@ -0,0 +1,158 @@
+import { jobId } from '../../../domain/types/job';
+import { databaseNow, recordPostgresEvent } from './context';
+import { lockPostgresDestructionCandidates, lockPostgresDestructionIdentities, lockPostgresDestructionRows, partitionPostgresDestructionCandidates, } from './dependencyDestruction';
+import { deletePostgresEventPruneWatermark } from './eventPruneWatermarks';
+import { lockPostgresQueueLifecycleExclusive } from './queueLifecycle';
+import { deletePostgresQueueEventHistory, lockPostgresEventRetention } from './eventRetention';
+async function recordQueueInvalidation(tx, ctx, queue, type) {
+    await recordPostgresEvent(tx, ctx, {
+        queue,
+        type,
+        jobId: jobId(`__queue__:${queue}`),
+        occurredAt: await databaseNow(tx),
+    });
+}
+export async function drainPostgresQueue(ctx, queue) {
+    return await ctx.sql.begin(async (tx) => {
+        const candidates = await tx `
+      SELECT id FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+        AND state IN ('waiting', 'prioritized', 'delayed', 'waiting-children')
+      ORDER BY id
+    `;
+        const candidateIds = candidates.map((row) => jobId(row.id));
+        if (candidateIds.length === 0)
+            return 0;
+        await lockPostgresDestructionCandidates(tx, ctx, candidateIds);
+        const rows = await tx `
+      SELECT id FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+        AND state IN ('waiting', 'prioritized', 'delayed', 'waiting-children')
+        AND id = ANY(${tx.array(candidateIds.map(String), 'TEXT')})
+      ORDER BY id
+    `;
+        const plannedIds = rows.map((row) => jobId(row.id));
+        const { deletableIds } = await partitionPostgresDestructionCandidates(tx, ctx, plannedIds, plannedIds);
+        const ids = deletableIds.map(String);
+        if (ids.length === 0)
+            return 0;
+        const values = tx.array(ids, 'TEXT');
+        await tx `
+      DELETE FROM bunqueue_job_logs
+      WHERE namespace = ${ctx.config.namespace} AND job_id = ANY(${values})
+    `;
+        await tx `
+      DELETE FROM bunqueue_flow_failures
+      WHERE namespace = ${ctx.config.namespace} AND parent_id = ANY(${values})
+    `;
+        await tx `
+      DELETE FROM bunqueue_dependencies
+      WHERE namespace = ${ctx.config.namespace} AND job_id = ANY(${values})
+    `;
+        await tx `
+      DELETE FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND id = ANY(${values})
+    `;
+        await recordQueueInvalidation(tx, ctx, queue, 'queue-drained');
+        return ids.length;
+    });
+}
+export async function obliteratePostgresQueue(ctx, queue) {
+    return await ctx.sql.begin(async (tx) => {
+        await lockPostgresQueueLifecycleExclusive(tx, ctx, queue);
+        await lockPostgresEventRetention(tx, ctx, queue);
+        await tx `
+      INSERT INTO bunqueue_queue_state (namespace, queue)
+      VALUES (${ctx.config.namespace}, ${queue})
+      ON CONFLICT (namespace, queue) DO NOTHING
+    `;
+        await tx `
+      SELECT queue FROM bunqueue_queue_state
+      WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+      FOR UPDATE
+    `;
+        const candidates = await tx `
+      SELECT id FROM (
+        SELECT id FROM bunqueue_jobs
+        WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+        UNION
+        SELECT job_id AS id FROM bunqueue_completions
+        WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+      ) AS queue_ids
+      ORDER BY id
+    `;
+        const candidateIds = candidates.map((row) => jobId(row.id));
+        await lockPostgresDestructionIdentities(tx, ctx, candidateIds);
+        await lockPostgresDestructionRows(tx, ctx, candidateIds);
+        const jobs = await tx `
+      SELECT id FROM bunqueue_jobs
+      WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+        AND id = ANY(${tx.array(candidateIds.map(String), 'TEXT')})
+      ORDER BY id
+    `;
+        const completions = await tx `
+      SELECT job_id FROM bunqueue_completions
+      WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+        AND job_id = ANY(${tx.array(candidateIds.map(String), 'TEXT')})
+      ORDER BY job_id
+    `;
+        const jobIds = jobs.map((row) => jobId(row.id));
+        const targetIds = [
+            ...new Set([...jobIds.map(String), ...completions.map((row) => row.job_id)]),
+        ].map(jobId);
+        const { protectedIds } = await partitionPostgresDestructionCandidates(tx, ctx, targetIds, jobIds);
+        if (protectedIds.length > 0) {
+            throw new Error(`Cannot obliterate queue ${queue}: ${protectedIds.length} job(s) have live dependents`);
+        }
+        const targets = tx.array(targetIds.map(String), 'TEXT');
+        const jobValues = tx.array(jobIds.map(String), 'TEXT');
+        if (targetIds.length > 0) {
+            await tx `
+        DELETE FROM bunqueue_job_logs
+        WHERE namespace = ${ctx.config.namespace} AND job_id = ANY(${targets})
+      `;
+            await tx `
+        DELETE FROM bunqueue_repeat_links
+        WHERE namespace = ${ctx.config.namespace}
+          AND (original_id = ANY(${targets}) OR successor_id = ANY(${targets}))
+      `;
+            await tx `
+        DELETE FROM bunqueue_flow_failures
+        WHERE namespace = ${ctx.config.namespace} AND parent_id = ANY(${targets})
+      `;
+            await tx `
+        DELETE FROM bunqueue_dependencies
+        WHERE namespace = ${ctx.config.namespace}
+          AND (job_id = ANY(${jobValues}) OR dependency_id = ANY(${targets}))
+      `;
+            await tx `
+        DELETE FROM bunqueue_completions
+        WHERE namespace = ${ctx.config.namespace} AND job_id = ANY(${targets})
+      `;
+            await tx `
+        DELETE FROM bunqueue_jobs
+        WHERE namespace = ${ctx.config.namespace} AND id = ANY(${jobValues})
+      `;
+        }
+        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}
+    `;
+        await tx `
+      DELETE FROM bunqueue_metric_buckets
+      WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+    `;
+        await tx `
+      DELETE FROM bunqueue_metric_totals
+      WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+    `;
+        await deletePostgresQueueEventHistory(tx, ctx, queue);
+        await deletePostgresEventPruneWatermark(tx, ctx, queue);
+        await recordQueueInvalidation(tx, ctx, queue, 'queue-obliterated');
+        return jobIds.length;
+    });
+}

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

@@ -0,0 +1,10 @@
+import type { TransactionSQL } from 'bun';
+import type { PostgresContext } from './context';
+/** Acquire queue lifecycle locks before admission identity or row locks. */
+export declare function lockPostgresAdmissionQueues(tx: TransactionSQL, ctx: PostgresContext, queues: readonly string[]): Promise<void>;
+/** Persist queue identity only after admission has proved it inserted a generation. */
+export declare function registerPostgresAdmissionQueues(tx: TransactionSQL, ctx: PostgresContext, queues: readonly string[]): Promise<void>;
+/** Exclusively serialize queue deletion against every new admission. */
+export declare function lockPostgresQueueLifecycleExclusive(tx: TransactionSQL, ctx: PostgresContext, queue: string): Promise<void>;
+/** Try a late shared lock so repeat ACKs roll back instead of deadlocking deletion. */
+export declare function tryLockPostgresRepeatQueues(tx: TransactionSQL, ctx: PostgresContext, queues: readonly string[]): Promise<boolean>;

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

@@ -0,0 +1,60 @@
+import { postgresAdvisoryLockName } from './advisoryLocks';
+function queueNames(queues) {
+    return [...new Set(queues)].sort();
+}
+/** Acquire queue lifecycle locks before admission identity or row locks. */
+export async function lockPostgresAdmissionQueues(tx, ctx, queues) {
+    const lockNames = queueNames(queues).map((queue) => postgresAdvisoryLockName('queue-lifecycle', ctx.config.namespace, queue));
+    if (lockNames.length === 0)
+        return;
+    await tx `
+    WITH ordered_queues AS MATERIALIZED (
+      SELECT DISTINCT hashtextextended(lock_name, 0) AS lock_key
+      FROM unnest(${tx.array(lockNames, 'TEXT')}) AS requested(lock_name)
+      ORDER BY lock_key
+    ), locked_queues AS MATERIALIZED (
+      SELECT lock_key, pg_advisory_xact_lock_shared(lock_key) AS acquired
+      FROM ordered_queues
+      ORDER BY lock_key
+    )
+    SELECT COUNT(*) FROM locked_queues
+  `;
+}
+/** Persist queue identity only after admission has proved it inserted a generation. */
+export async function registerPostgresAdmissionQueues(tx, ctx, queues) {
+    const names = queueNames(queues);
+    if (names.length === 0)
+        return;
+    await tx `
+    INSERT INTO bunqueue_queue_state (namespace, queue)
+    SELECT ${ctx.config.namespace}, queue
+    FROM unnest(${tx.array(names, 'TEXT')}) AS admitted(queue)
+    ON CONFLICT (namespace, queue) DO NOTHING
+  `;
+}
+/** Exclusively serialize queue deletion against every new admission. */
+export async function lockPostgresQueueLifecycleExclusive(tx, ctx, queue) {
+    const lockName = postgresAdvisoryLockName('queue-lifecycle', ctx.config.namespace, queue);
+    await tx `
+    SELECT pg_advisory_xact_lock(hashtextextended(${lockName}, 0))
+  `;
+}
+/** Try a late shared lock so repeat ACKs roll back instead of deadlocking deletion. */
+export async function tryLockPostgresRepeatQueues(tx, ctx, queues) {
+    const lockNames = queueNames(queues).map((queue) => postgresAdvisoryLockName('queue-lifecycle', ctx.config.namespace, queue));
+    if (lockNames.length === 0)
+        return true;
+    const [result] = await tx `
+    WITH ordered_queues AS MATERIALIZED (
+      SELECT DISTINCT hashtextextended(lock_name, 0) AS lock_key
+      FROM unnest(${tx.array(lockNames, 'TEXT')}) AS requested(lock_name)
+      ORDER BY lock_key
+    ), attempted AS MATERIALIZED (
+      SELECT lock_key, pg_try_advisory_xact_lock_shared(lock_key) AS acquired
+      FROM ordered_queues
+      ORDER BY lock_key
+    )
+    SELECT COALESCE(bool_and(acquired), TRUE) AS acquired FROM attempted
+  `;
+    return result.acquired;
+}

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

@@ -0,0 +1,6 @@
+export interface NormalizedPostgresRateLimit {
+    readonly durationMs: number | null;
+    readonly ttlMs: number | null;
+}
+/** Match the in-memory limiter's handling of optional duration and TTL windows. */
+export declare function normalizePostgresRateLimit(durationMs: number | null | undefined, ttlMs: number | null | undefined): NormalizedPostgresRateLimit;

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

@@ -0,0 +1,10 @@
+function positiveFinite(value) {
+    return Number.isFinite(value) && value > 0 ? value : null;
+}
+/** Match the in-memory limiter's handling of optional duration and TTL windows. */
+export function normalizePostgresRateLimit(durationMs, ttlMs) {
+    return {
+        durationMs: positiveFinite(durationMs),
+        ttlMs: positiveFinite(ttlMs),
+    };
+}

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

@@ -0,0 +1,32 @@
+import type { CronJob } from '../../../domain/types/cron';
+import type { JobId } from '../../../domain/types/job';
+import type { PostgresContext } from './context';
+import { type PostgresLifetimeMetricsSnapshot } from './lifetimeMetrics';
+import type { PostgresCompletionResult, PostgresQueueState, PostgresStoredJob } from './types';
+export interface PostgresManagerSnapshot {
+    readonly rows: readonly PostgresStoredJob[];
+    readonly results: readonly PostgresCompletionResult[];
+    readonly crons: readonly CronJob[];
+    readonly states: readonly PostgresQueueState[];
+    readonly lifetimeMetrics: PostgresLifetimeMetricsSnapshot;
+}
+export interface PostgresQueueReadModel {
+    readonly rows: readonly PostgresStoredJob[];
+    readonly results: readonly PostgresCompletionResult[];
+    readonly state: PostgresQueueState;
+    readonly exists: boolean;
+}
+export interface PostgresProjectionRequest {
+    readonly id: JobId;
+    readonly queue: string;
+}
+export interface PostgresJobProjection {
+    readonly row: PostgresStoredJob | null;
+    readonly completion: PostgresCompletionResult | null;
+}
+/** Load one transactionally coherent manager bootstrap projection. */
+export declare function loadPostgresManagerSnapshot(ctx: PostgresContext): Promise<PostgresManagerSnapshot>;
+/** Load jobs, results, and policy for one queue from the same MVCC snapshot. */
+export declare function loadPostgresQueueReadModel(ctx: PostgresContext, queue: string): Promise<PostgresQueueReadModel>;
+/** Batch current rows and consult completion evidence only for removed jobs. */
+export declare function loadPostgresJobProjections(ctx: PostgresContext, requests: readonly PostgresProjectionRequest[]): Promise<ReadonlyMap<JobId, PostgresJobProjection>>;

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

@@ -0,0 +1,72 @@
+import { decodePostgresValue } from './codec';
+import { loadPostgresCompletionResults } from './completionQueries';
+import { getPostgresQueueState } from './control';
+import { listPostgresCrons } from './crons';
+import { loadPostgresLifetimeMetrics, } from './lifetimeMetrics';
+import { getPostgresJobs, listPostgresJobs, listPostgresQueues, loadAllPostgresJobs, } from './queries';
+import { assertPostgresSnapshotBudget } from './snapshotBudget';
+/** Load one transactionally coherent manager bootstrap projection. */
+export async function loadPostgresManagerSnapshot(ctx) {
+    return await ctx.sql.begin('isolation level repeatable read read only', async (tx) => {
+        await assertPostgresSnapshotBudget(ctx, tx);
+        const [rows, results, crons, queues, lifetimeMetrics] = await Promise.all([
+            loadAllPostgresJobs(ctx, tx),
+            loadPostgresCompletionResults(ctx, undefined, tx),
+            listPostgresCrons(ctx, tx),
+            listPostgresQueues(ctx, tx),
+            loadPostgresLifetimeMetrics(ctx, tx),
+        ]);
+        const states = await Promise.all(queues.map((queue) => getPostgresQueueState(ctx, queue, tx)));
+        return { rows, results, crons, states, lifetimeMetrics };
+    });
+}
+/** Load jobs, results, and policy for one queue from the same MVCC snapshot. */
+export async function loadPostgresQueueReadModel(ctx, queue) {
+    return await ctx.sql.begin('isolation level repeatable read read only', async (tx) => {
+        await assertPostgresSnapshotBudget(ctx, tx, queue);
+        const [rows, results, state, [presence]] = await Promise.all([
+            listPostgresJobs(ctx, queue, { limit: 2_147_483_647, asc: true }, tx),
+            loadPostgresCompletionResults(ctx, queue, tx),
+            getPostgresQueueState(ctx, queue, tx),
+            tx `
+        SELECT EXISTS (
+          SELECT 1 FROM bunqueue_jobs
+          WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+          UNION ALL
+          SELECT 1 FROM bunqueue_queue_state
+          WHERE namespace = ${ctx.config.namespace} AND queue = ${queue}
+        ) AS exists
+      `,
+        ]);
+        return { rows, results, state, exists: presence.exists };
+    });
+}
+/** Batch current rows and consult completion evidence only for removed jobs. */
+export async function loadPostgresJobProjections(ctx, requests) {
+    if (requests.length === 0)
+        return new Map();
+    const rows = await getPostgresJobs(ctx, requests.map(({ id }) => id));
+    const byId = new Map(rows.map((row) => [row.job.id, row]));
+    const missing = requests.filter(({ id }) => !byId.has(id));
+    const completions = missing.length === 0
+        ? []
+        : await ctx.sql `
+          SELECT job_id, queue, result FROM bunqueue_completions
+          WHERE namespace = ${ctx.config.namespace}
+            AND job_id = ANY(${ctx.sql.array(missing.map(({ id }) => String(id)), 'TEXT')})
+        `;
+    const completionById = new Map(completions.map((row) => [row.job_id, row]));
+    return new Map(requests.map(({ id }) => {
+        const row = byId.get(id) ?? null;
+        const completionRow = completionById.get(String(id));
+        const completion = !row && completionRow !== undefined
+            ? {
+                jobId: id,
+                queue: completionRow.queue,
+                result: decodePostgresValue(completionRow.result, null, `postgresCompletion:${String(id)}`),
+                pinned: false,
+            }
+            : null;
+        return [id, { row, completion }];
+    }));
+}

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

@@ -0,0 +1,3 @@
+import { type PostgresContext } from './context';
+/** Reclaim expired active leases. Row locks make the sweep safe across many brokers. */
+export declare function recoverExpiredPostgresLeases(ctx: PostgresContext, limit?: number): Promise<number>;