bunqueue 2.8.60 → 2.9.2

package/dist/application/operations/pull.js

@@ -2,10 +2,11 @@
  * Pull Operations
  * Job pull logic with timeout support
  */
+import { assertGroupPullOptions } from '../../domain/types/group';
 import { withWriteLock } from '../../shared/lock';
-import { shardIndex, processingShardIndex } from '../../shared/hash';
+import { shardIndex } from '../../shared/hash';
 import { latencyTracker } from '../latencyTracker';
-import { throughputTracker } from '../throughputTracker';
+import { finalizeProcessing, finalizeProcessingBatch } from './pullFinalization';
 import { createDequeueScan, requeueJob, restoreParkedJobs, tryDequeueNextJob, } from './pullStateTransition';
 /** Wait until either a notification arrives, the next delay matures, or the pull deadline. */
 async function waitForNextCandidate(options) {
@@ -14,64 +15,18 @@ async function waitForNextCandidate(options) {
     const untilNextRun = nextRunAt === null ? remaining : Math.max(1, nextRunAt - now);
     await shard.waitForJob(queue, Math.min(remaining, untilNextRun), signal);
 }
-/**
- * Finish the handoff of a dequeued job: persist active state and broadcast.
- *
- * The job was ALREADY inserted into processingShards and jobIndex was flipped
- * to 'processing' inside the dequeue critical section (tryDequeueNextJob),
- * atomically with the queue pop, so readers never see a stale 'queue'
- * location. Only the bookkeeping that may follow an await happens here.
- *
- * Returns false when the job is no longer in processingShards: a management
- * op (discardJob, moveJobToDelayed, obliterate) claimed it between the
- * dequeue and this call. The claimer owns the job now; the pull must NOT
- * deliver it to a worker nor mark it active.
- */
-function finalizeProcessing(job, queue, ctx) {
-    const procIdx = processingShardIndex(job.id);
-    if (!ctx.processingShards[procIdx].has(job.id))
-        return false;
-    const now = Date.now();
-    try {
-        ctx.storage?.markActive(job.id, job.startedAt ?? now, job.timeline);
-    }
-    catch {
-        // Non-fatal: job is already in processingShards (in-memory source of truth).
-        // On crash, SQLite recovery will handle the stale state.
-    }
-    ctx.totalPulled.value++;
-    throughputTracker.pullRate.increment();
-    ctx.broadcast({
-        eventType: 'pulled',
-        queue,
-        jobId: job.id,
-        timestamp: now,
-    });
-    return true;
-}
-/**
- * Finish the handoff for a batch of dequeued jobs.
- * Returns the jobs actually delivered (claimed jobs are skipped, see above).
- */
-function finalizeProcessingBatch(jobs, queue, ctx) {
-    const delivered = [];
-    for (const job of jobs) {
-        if (finalizeProcessing(job, queue, ctx))
-            delivered.push(job);
-    }
-    return delivered;
-}
 /**
  * Pull next job from queue
  */
-export async function pullJob(queue, timeoutMs, ctx, signal) {
+export async function pullJob(queue, timeoutMs, ctx, signal, groupOptions) {
+    assertGroupPullOptions(groupOptions);
     const startNs = Bun.nanoseconds();
     const deadline = timeoutMs > 0 ? Date.now() + timeoutMs : 0;
     const idx = shardIndex(queue);
     while (true) {
         if (signal?.aborted)
             return null;
-        const attempt = await tryPullFromShard(queue, idx, ctx, signal);
+        const attempt = await tryPullFromShard(queue, idx, ctx, signal, groupOptions);
         const job = attempt.job;
         if (job) {
             if (signal?.aborted) {
@@ -112,7 +67,7 @@ export async function pullJob(queue, timeoutMs, ctx, signal) {
 /**
  * Try to pull a job from a specific shard
  */
-async function tryPullFromShard(queue, idx, ctx, signal) {
+async function tryPullFromShard(queue, idx, ctx, signal, groupOptions) {
     return await withWriteLock(ctx.shardLocks[idx], () => {
         if (signal?.aborted)
             return { job: null, nextRunAt: null };
@@ -122,7 +77,7 @@ async function tryPullFromShard(queue, idx, ctx, signal) {
             return { job: null, nextRunAt: null };
         }
         const now = Date.now();
-        const scan = createDequeueScan();
+        const scan = createDequeueScan(groupOptions);
         try {
             const result = tryDequeueNextJob(shard, queue, now, ctx, scan);
             return result.status === 'job'
@@ -137,14 +92,16 @@ async function tryPullFromShard(queue, idx, ctx, signal) {
 /**
  * Pull multiple jobs from queue
  */
-export async function pullJobBatch(queue, count, timeoutMs, ctx, signal) {
+export async function pullJobBatch(queue, count, timeoutMs, ctx, options = {}) {
+    assertGroupPullOptions(options.group);
+    const { signal } = options;
     const startNs = Bun.nanoseconds();
     const deadline = timeoutMs > 0 ? Date.now() + timeoutMs : 0;
     const idx = shardIndex(queue);
     while (true) {
         if (signal?.aborted)
             return [];
-        const attempt = await tryPullBatchFromShard(queue, idx, count, ctx, signal);
+        const attempt = await tryPullBatchFromShard(queue, idx, count, ctx, options);
         const jobs = attempt.jobs;
         if (jobs.length > 0) {
             if (signal?.aborted) {
@@ -194,7 +151,8 @@ export async function pullJobBatch(queue, count, timeoutMs, ctx, signal) {
 /**
  * Try to pull multiple jobs from a shard
  */
-async function tryPullBatchFromShard(queue, idx, count, ctx, signal) {
+async function tryPullBatchFromShard(queue, idx, count, ctx, options) {
+    const { signal, group: groupOptions } = options;
     return await withWriteLock(ctx.shardLocks[idx], () => {
         if (signal?.aborted)
             return { jobs: [], nextRunAt: null };
@@ -204,7 +162,7 @@ async function tryPullBatchFromShard(queue, idx, count, ctx, signal) {
         if (state.paused)
             return { jobs, nextRunAt: null };
         const now = Date.now();
-        const scan = createDequeueScan();
+        const scan = createDequeueScan(groupOptions);
         try {
             while (jobs.length < count) {
                 const result = tryDequeueNextJob(shard, queue, now, ctx, scan);

package/dist/application/operations/pullFinalization.d.ts

@@ -0,0 +1,6 @@
+import type { Job } from '../../domain/types/job';
+import type { PullContext } from './pullStateTransition';
+/** Persist and publish a single processing handoff. */
+export declare function finalizeProcessing(job: Job, queue: string, ctx: PullContext): boolean;
+/** Persist and publish all processing handoffs with one durable state transaction. */
+export declare function finalizeProcessingBatch(jobs: Job[], queue: string, ctx: PullContext): Job[];

package/dist/application/operations/pullFinalization.js

@@ -0,0 +1,69 @@
+import { processingShardIndex } from '../../shared/hash';
+import { throughputTracker } from '../throughputTracker';
+function createPulledEvent(job, queue, ctx) {
+    if (!ctx.processingShards[processingShardIndex(job.id)].has(job.id))
+        return null;
+    return {
+        eventType: 'pulled',
+        queue,
+        jobId: job.id,
+        timestamp: Date.now(),
+    };
+}
+function persistActive(job, fallbackStartedAt, ctx) {
+    try {
+        ctx.storage?.markActive(job.id, job.startedAt ?? fallbackStartedAt, job.timeline);
+    }
+    catch {
+        // Non-fatal: the in-memory processing map remains authoritative.
+    }
+}
+function persistActiveBatch(jobs, events, ctx) {
+    const storage = ctx.storage;
+    if (!storage || jobs.length === 0)
+        return;
+    try {
+        storage.markActiveBatch(jobs.map((job, index) => ({
+            jobId: job.id,
+            startedAt: job.startedAt ?? events[index].timestamp,
+            timeline: job.timeline,
+        })));
+    }
+    catch {
+        for (let index = 0; index < jobs.length; index++) {
+            persistActive(jobs[index], events[index].timestamp, ctx);
+        }
+    }
+}
+/** Persist and publish a single processing handoff. */
+export function finalizeProcessing(job, queue, ctx) {
+    const event = createPulledEvent(job, queue, ctx);
+    if (!event)
+        return false;
+    persistActive(job, event.timestamp, ctx);
+    ctx.totalPulled.value++;
+    throughputTracker.pullRate.increment();
+    ctx.broadcast(event);
+    return true;
+}
+/** Persist and publish all processing handoffs with one durable state transaction. */
+export function finalizeProcessingBatch(jobs, queue, ctx) {
+    const delivered = [];
+    const events = [];
+    for (const job of jobs) {
+        const event = createPulledEvent(job, queue, ctx);
+        if (!event)
+            continue;
+        delivered.push(job);
+        events.push(event);
+    }
+    persistActiveBatch(delivered, events, ctx);
+    ctx.totalPulled.value += BigInt(delivered.length);
+    throughputTracker.pullRate.increment(delivered.length);
+    if (ctx.broadcastBatch)
+        ctx.broadcastBatch(events);
+    else
+        for (const event of events)
+            ctx.broadcast(event);
+    return delivered;
+}

package/dist/application/operations/pullStateTransition.d.ts

@@ -3,7 +3,8 @@
  */
 import type { Shard } from '../../domain/queue/shard';
 import { type Job, type JobId } from '../../domain/types/job';
-import type { EventType, JobLocation } from '../../domain/types/queue';
+import type { GroupPullOptions } from '../../domain/types/group';
+import type { EventType, JobEvent, JobLocation } from '../../domain/types/queue';
 import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 import type { RWLock } from '../../shared/lock';
 /** Dependencies shared by the single and batch pull paths. */
@@ -23,11 +24,13 @@ export interface PullContext {
         jobId: JobId;
         timestamp: number;
     }) => void;
+    broadcastBatch?: (events: readonly JobEvent[]) => void;
     dashboardEmit?: (event: string, data: Record<string, unknown>) => void;
 }
 export interface DequeueScan {
     parked: Job[];
     nextRunAt: number | null;
+    groupOptions?: GroupPullOptions;
 }
 export type DequeueResult = {
     status: 'job';
@@ -35,15 +38,13 @@ export type DequeueResult = {
 } | {
     status: 'stop';
 };
-export declare function createDequeueScan(): DequeueScan;
+export declare function createDequeueScan(groupOptions?: GroupPullOptions): DequeueScan;
 /** Restore physical heap membership without changing logical queue state. */
 export declare function restoreParkedJobs(shard: Shard, queue: string, scan: DequeueScan): void;
 /**
- * Remove the best eligible job while retaining ineligible roots in `scan`.
- *
- * A batch reuses one scan, because readiness cannot change while the synchronous
- * shard critical section is held: time is fixed and active FIFO groups only
- * grow. Its parked jobs therefore need to be restored only once after the batch.
+ * Remove the best eligible job from the shard's secondary group indexes.
+ * A batch reuses the same fixed timestamp and group defaults while its
+ * synchronous shard critical section is held.
  */
 export declare function tryDequeueNextJob(shard: Shard, queue: string, now: number, ctx: PullContext, scan: DequeueScan): DequeueResult;
 /** Restore a dequeued job when its handoff to the worker cannot complete. */

package/dist/application/operations/pullStateTransition.js

@@ -4,8 +4,8 @@
 import { isExpired, isReady, MAX_TIMELINE_ENTRIES, } from '../../domain/types/job';
 import { processingShardIndex } from '../../shared/hash';
 import { withWriteLock } from '../../shared/lock';
-export function createDequeueScan() {
-    return { parked: [], nextRunAt: null };
+export function createDequeueScan(groupOptions) {
+    return { parked: [], nextRunAt: null, groupOptions };
 }
 /** Restore physical heap membership without changing logical queue state. */
 export function restoreParkedJobs(shard, queue, scan) {
@@ -15,23 +15,30 @@ export function restoreParkedJobs(shard, queue, scan) {
     scan.parked.length = 0;
 }
 /**
- * Remove the best eligible job while retaining ineligible roots in `scan`.
- *
- * A batch reuses one scan, because readiness cannot change while the synchronous
- * shard critical section is held: time is fixed and active FIFO groups only
- * grow. Its parked jobs therefore need to be restored only once after the batch.
+ * Remove the best eligible job from the shard's secondary group indexes.
+ * A batch reuses the same fixed timestamp and group defaults while its
+ * synchronous shard critical section is held.
  */
 export function tryDequeueNextJob(shard, queue, now, ctx, scan) {
     const priorityQueue = shard.getQueue(queue);
     while (true) {
-        const job = priorityQueue.peek();
+        const grouped = shard.hasGroupScheduler(queue);
+        const candidate = grouped
+            ? shard.peekGroupCandidate(queue, now, scan.groupOptions)
+            : { job: priorityQueue.peek(), nextRunAt: null };
+        if (grouped)
+            scan.nextRunAt = candidate.nextRunAt;
+        const job = candidate.job;
         if (!job)
             return { status: 'stop' };
         if (isExpired(job, now)) {
             // Persistence is removed first so a failed durable delete leaves the
             // in-memory job available for a later attempt.
             ctx.storage?.deleteJob(job.id);
-            priorityQueue.pop();
+            if (grouped)
+                priorityQueue.remove(job.id);
+            else
+                priorityQueue.pop();
             shard.decrementQueued(job.id);
             ctx.jobIndex.delete(job.id);
             ctx.dashboardEmit?.('job:expired', {
@@ -42,19 +49,13 @@ export function tryDequeueNextJob(shard, queue, now, ctx, scan) {
             });
             continue;
         }
-        if (!isReady(job, now)) {
+        if (!grouped && !isReady(job, now)) {
             const delayed = priorityQueue.pop();
             if (delayed)
                 scan.parked.push(delayed);
             scan.nextRunAt = scan.nextRunAt === null ? job.runAt : Math.min(scan.nextRunAt, job.runAt);
             continue;
         }
-        if (job.groupId && shard.isGroupActive(queue, job.groupId)) {
-            const blocked = priorityQueue.pop();
-            if (blocked)
-                scan.parked.push(blocked);
-            continue;
-        }
         // Capacity is consumed only after an eligible job has been found.
         if (!shard.tryAcquireConcurrency(queue)) {
             ctx.dashboardEmit?.('concurrency:rejected', { queue });
@@ -65,14 +66,20 @@ export function tryDequeueNextJob(shard, queue, now, ctx, scan) {
             ctx.dashboardEmit?.('ratelimit:rejected', { queue });
             return { status: 'stop' };
         }
-        const dequeued = priorityQueue.pop();
+        if (job.groupId && !shard.acquireGroup(queue, job.groupId, scan.groupOptions, now)) {
+            shard.releaseConcurrency(queue);
+            return { status: 'stop' };
+        }
+        const dequeued = grouped ? priorityQueue.remove(job.id) : priorityQueue.pop();
         if (!dequeued) {
+            if (job.groupId)
+                shard.releaseGroup(queue, job.groupId);
             shard.releaseConcurrency(queue);
             return { status: 'stop' };
         }
         shard.decrementQueued(dequeued.id);
         if (dequeued.groupId)
-            shard.activateGroup(queue, dequeued.groupId);
+            shard.advanceGroup(queue, dequeued.groupId);
         dequeued.startedAt = now;
         dequeued.lastHeartbeat = now;
         if (dequeued.timeline.length < MAX_TIMELINE_ENTRIES) {

package/dist/application/operations/push.js

@@ -3,6 +3,7 @@
  * Single-job push logic and stable batch re-export
  */
 import { createJob } from '../../domain/types/job';
+import { assertOptionalGroupId } from '../../domain/types/group';
 import { shardIndex } from '../../shared/hash';
 import { latencyTracker } from '../latencyTracker';
 import { throughputTracker } from '../throughputTracker';
@@ -20,6 +21,7 @@ export { pushJobBatch } from './pushBatch';
  * NOTE: customId check happens INSIDE lock to prevent race conditions
  */
 export async function pushJob(queue, input, ctx) {
+    assertOptionalGroupId(input.groupId);
     validateRepeatJobInput(input);
     const startNs = Bun.nanoseconds();
     const idx = shardIndex(queue);
@@ -58,6 +60,7 @@ export async function pushJob(queue, input, ctx) {
             };
             return;
         }
+        shard.assignGroupFifoOrder(job);
         const target = { queue, shard, shardIdx: idx };
         let storageHandled = false;
         if (linkParent) {

package/dist/application/operations/pushBatch.js

@@ -1,4 +1,5 @@
 import { createJob, normalizeJobPayload, } from '../../domain/types/job';
+import { assertOptionalGroupId } from '../../domain/types/group';
 import { shardIndex } from '../../shared/hash';
 import { releaseDependencyCompletionPins } from '../dependencyCompletions';
 import { latencyTracker } from '../latencyTracker';
@@ -13,6 +14,7 @@ import { withPushWriteLocks } from './pushLocks';
 /** Push an ordered batch while preserving its accepted-prefix contract. */
 export async function pushJobBatch(queue, inputs, ctx) {
     for (const input of inputs) {
+        assertOptionalGroupId(input.groupId);
         validateRepeatJobInput(input);
         normalizeJobPayload(input);
     }
@@ -43,6 +45,7 @@ export async function pushJobBatch(queue, inputs, ctx) {
                     resultIds.push(dedupResult.existingId);
                     continue;
                 }
+                shard.assignGroupFifoOrder(job);
                 const target = { queue, shard, shardIdx: idx };
                 let storageHandled = false;
                 if (linkParent) {
@@ -111,13 +114,17 @@ export async function pushJobBatch(queue, inputs, ctx) {
         }
         ctx.totalPushed.value += BigInt(acceptedJobs.length);
         throughputTracker.pushRate.increment(acceptedJobs.length);
-        for (const job of acceptedJobs) {
-            ctx.broadcast({
-                eventType: 'pushed',
-                queue: job.queue,
-                jobId: job.id,
-                timestamp: now,
-            });
+        const events = acceptedJobs.map((job) => ({
+            eventType: 'pushed',
+            queue: job.queue,
+            jobId: job.id,
+            timestamp: now,
+        }));
+        if (ctx.broadcastBatch)
+            ctx.broadcastBatch(events);
+        else {
+            for (const event of events)
+                ctx.broadcast(event);
         }
     }
     if (jobsToInsert.length > 0)

package/dist/application/operations/pushContext.d.ts

@@ -1,7 +1,7 @@
 import type { Shard } from '../../domain/queue/shard';
 import type { Job, JobId } from '../../domain/types/job';
 import type { JobLocation } from '../../domain/types/queue';
-import { type EventType } from '../../domain/types/queue';
+import { type EventType, type JobEvent } from '../../domain/types/queue';
 import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 import type { RWLock } from '../../shared/lock';
 import type { MapLike, SetLike } from '../../shared/lru';
@@ -34,6 +34,7 @@ export interface PushContext {
         jobId: JobId;
         timestamp: number;
     }) => void;
+    broadcastBatch?: (events: readonly JobEvent[]) => void;
     dashboardEmit?: (event: string, data: Record<string, unknown>) => void;
     registerQueueName?: (queue: string) => void;
 }

package/dist/application/postgres-queue-manager/batchSnapshot.d.ts

@@ -0,0 +1,16 @@
+import type { Job, JobId } from '../../domain/types/job';
+import type { PostgresJobState } from '../../infrastructure/persistence/postgres';
+import type { PostgresQueueSnapshot } from './snapshot';
+interface BatchCompletionItem {
+    readonly id: JobId;
+    readonly result?: unknown;
+}
+interface BatchCompletionTransition {
+    readonly applied: boolean;
+    readonly job: Job | null;
+    readonly state: PostgresJobState | null;
+    readonly removed: boolean;
+}
+/** Apply an authoritative batch result without reloading every job in its queue. */
+export declare function applyPostgresBatchCompletion(snapshot: PostgresQueueSnapshot, item: BatchCompletionItem, transition: BatchCompletionTransition): string | null;
+export {};

package/dist/application/postgres-queue-manager/batchSnapshot.js

@@ -0,0 +1,17 @@
+/** Apply an authoritative batch result without reloading every job in its queue. */
+export function applyPostgresBatchCompletion(snapshot, item, transition) {
+    if (!transition.applied || !transition.job || transition.state !== 'completed')
+        return null;
+    snapshot.apply({
+        id: 0,
+        queue: transition.job.queue,
+        type: 'completed',
+        jobId: item.id,
+        occurredAt: transition.job.completedAt ?? Date.now(),
+        job: transition.job,
+        state: 'completed',
+        result: item.result,
+        removed: transition.removed,
+    });
+    return transition.job.repeat === null ? null : transition.job.queue;
+}

package/dist/application/postgres-queue-manager/cloud.d.ts

@@ -0,0 +1,30 @@
+import type { JobId } from '../../domain/types/job';
+import type { PostgresCloudReadModel } from '../../infrastructure/persistence/postgres/cloudReadModel';
+import { PostgresQueueManagerServices } from './services';
+/** PostgreSQL-specific Cloud read port with no eventually-consistent fallback. */
+export declare class PostgresQueueManagerCloud extends PostgresQueueManagerServices {
+    getCloudProcessStats(): {
+        waiting: number;
+        prioritized: number;
+        delayed: number;
+        active: number;
+        dlq: number;
+        completed: number;
+        'waiting-children': number;
+        totalPushed: bigint;
+        totalPulled: bigint;
+        totalCompleted: bigint;
+        totalFailed: bigint;
+        uptime: number;
+        cronJobs: number;
+        cronPending: number;
+    };
+    readCloudSnapshotDurable(): Promise<PostgresCloudReadModel>;
+    listCloudJobsDurable(queue: string, options?: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }): Promise<import("../../domain/types").Job[]>;
+    getCloudResultDurable(id: JobId): Promise<unknown>;
+}

package/dist/application/postgres-queue-manager/cloud.js

@@ -0,0 +1,55 @@
+import { PostgresQueueManagerServices } from './services';
+const POSTGRES_STATES = new Set([
+    'waiting',
+    'prioritized',
+    'delayed',
+    'waiting-children',
+    'active',
+    'completed',
+    'failed',
+]);
+function pageIndex(value, fallback) {
+    if (value === undefined || !Number.isFinite(value))
+        return fallback;
+    return Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, Math.floor(value)));
+}
+function durableStates(value) {
+    if (value === undefined)
+        return undefined;
+    const requested = Array.isArray(value) ? value : [value];
+    const normalized = requested.flatMap((state) => state === 'paused' ? ['waiting', 'prioritized'] : [state]);
+    return [...new Set(normalized)].filter((state) => POSTGRES_STATES.has(state));
+}
+/** PostgreSQL-specific Cloud read port with no eventually-consistent fallback. */
+export class PostgresQueueManagerCloud extends PostgresQueueManagerServices {
+    getCloudProcessStats() {
+        return super.getStats();
+    }
+    async readCloudSnapshotDurable() {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            return await this.postgresStore.loadCloudReadModel();
+        });
+    }
+    async listCloudJobsDurable(queue, options = {}) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            const start = pageIndex(options.start, 0);
+            const end = Math.max(start, pageIndex(options.end, 100));
+            const rows = await this.postgresStore.list(queue, {
+                states: durableStates(options.state),
+                offset: start,
+                limit: end - start,
+                asc: options.asc ?? true,
+            });
+            return rows.map((row) => row.job);
+        });
+    }
+    async getCloudResultDurable(id) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            const result = await this.postgresStore.getResult(id);
+            return result.found ? result.result : null;
+        });
+    }
+}

package/dist/application/postgres-queue-manager/config.d.ts

@@ -0,0 +1,5 @@
+import type { PostgresStorageConfig } from '../../infrastructure/persistence/postgres';
+import type { QueueManagerConfig } from '../types';
+export interface PostgresQueueManagerConfig extends Omit<QueueManagerConfig, 'dataPath'> {
+    readonly postgres: PostgresStorageConfig;
+}

package/dist/application/postgres-queue-manager/config.js

@@ -0,0 +1 @@
+export {};

package/dist/application/postgres-queue-manager/control.d.ts

@@ -0,0 +1,30 @@
+import { type DlqConfig } from '../../domain/types/dlq';
+import { type StallConfig } from '../../domain/types/stall';
+import { PostgresQueueManagerMaintenance } from './maintenance';
+/** Durable queue controls and policies shared by every PostgreSQL broker. */
+export declare class PostgresQueueManagerControl extends PostgresQueueManagerMaintenance {
+    setGroupRateLimit(queue: string, groupId: string, max: number, duration: number): Promise<void>;
+    removeGroupRateLimit(queue: string, groupId: string): Promise<number>;
+    setGroupConcurrency(queue: string, groupId: string, concurrency: number): Promise<void>;
+    removeGroupConcurrency(queue: string, groupId: string): Promise<number>;
+    pause(queue: string): void;
+    resume(queue: string): void;
+    pauseDurable(queue: string, paused: boolean): Promise<void>;
+    drain(queue: string): number;
+    drainDurable(queue: string): Promise<number>;
+    obliterate(queue: string): void;
+    obliterateDurable(queue: string): Promise<void>;
+    setRateLimit(queue: string, limit: number, durationMs?: number, ttlMs?: number): void;
+    clearRateLimit(queue: string): void;
+    setConcurrency(queue: string, limit: number): void;
+    clearConcurrency(queue: string): void;
+    setRateLimitDurable(queue: string, limit: number | null, durationMs: number | null, ttlMs?: number | null): Promise<void>;
+    setConcurrencyDurable(queue: string, limit: number | null): Promise<void>;
+    setStallConfig(queue: string, patch: Record<string, unknown>): void;
+    getStallConfig(queue: string): StallConfig;
+    setStallConfigDurable(queue: string, patch: Record<string, unknown>): Promise<void>;
+    setDlqConfig(queue: string, patch: Record<string, unknown>): void;
+    getDlqConfig(queue: string): DlqConfig;
+    setDlqConfigDurable(queue: string, patch: Record<string, unknown>): Promise<void>;
+    private setLocalQueueState;
+}