bunqueue 2.8.60 → 2.9.2

package/dist/application/queue-manager/services.d.ts

@@ -12,7 +12,7 @@ export declare class QueueManagerServices extends QueueManagerObservability {
     setDashboardEmit(fn: (event: string, data: Record<string, unknown>) => void): void;
     emitDashboardEvent(event: string, data: Record<string, unknown>): void;
     subscribe(callback: (event: JobEvent) => void): () => void;
-    waitForJobCompletion(jobId: JobId, timeoutMs: number): Promise<boolean>;
+    waitForJobCompletion(jobId: JobId, timeoutMs: number, signal?: AbortSignal): Promise<boolean>;
     registerWorker(name: string, queues: string[], concurrency?: number, options?: CreateWorkerOptions): import("../../domain/types/worker").Worker;
     unregisterWorker(workerId: string): boolean;
     unregisterWorkersByClientId(clientId: string): number;

package/dist/application/queue-manager/services.js

@@ -1,7 +1,9 @@
+import { assertValidCronInput } from '../../infrastructure/scheduler/cron/validation';
 import { shardIndex } from '../../shared/hash';
 import { QueueManagerObservability } from './observability';
 export class QueueManagerServices extends QueueManagerObservability {
     addCron(input) {
+        assertValidCronInput(input);
         if (input.preventOverlap) {
             this.removeOrphanedCronJob(input.queue, input.uniqueKey ?? `cron:${input.name}`);
         }
@@ -54,8 +56,8 @@ export class QueueManagerServices extends QueueManagerObservability {
     subscribe(callback) {
         return this.eventsManager.subscribe(callback);
     }
-    waitForJobCompletion(jobId, timeoutMs) {
-        return this.eventsManager.waitForJobCompletion(jobId, timeoutMs);
+    waitForJobCompletion(jobId, timeoutMs, signal) {
+        return this.eventsManager.waitForJobCompletion(jobId, timeoutMs, signal);
     }
     registerWorker(name, queues, concurrency, options) {
         const worker = this.workerManager.register(name, queues, concurrency, options);

package/dist/application/queue-manager/state.js

@@ -1,6 +1,7 @@
 import { Shard } from '../../domain/queue/shard';
 import { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 import { CronScheduler } from '../../infrastructure/scheduler/cronScheduler';
+import { assertPersistedCronsSupported } from '../../infrastructure/scheduler/cron/persisted';
 import { RWLock } from '../../shared/lock';
 import { SHARD_COUNT } from '../../shared/hash';
 import { BoundedMap, BoundedSet, LRUMap } from '../../shared/lru';
@@ -83,6 +84,20 @@ export class QueueManagerState {
     constructor(config = {}) {
         this.config = { ...DEFAULT_CONFIG, ...config };
         this.storage = config.dataPath ? new SqliteStorage({ path: config.dataPath }) : null;
+        let persistedCrons;
+        try {
+            persistedCrons = this.storage?.loadCronJobs() ?? [];
+            assertPersistedCronsSupported(persistedCrons);
+        }
+        catch (error) {
+            try {
+                this.storage?.close();
+            }
+            catch {
+                // Preserve the read/validation error that made construction fail.
+            }
+            throw error;
+        }
         this.telemetryJournal = new QueueTelemetryJournal(this.storage, this.config.maxQueueEvents, this.config.maxMetricDataPoints);
         this.completedJobsData = new BoundedMap(this.config.maxCompletedJobs);
         this.completedJobs = new BoundedSet(this.config.maxCompletedJobs, (id) => {
@@ -120,7 +135,7 @@ export class QueueManagerState {
         this.workerManager = new WorkerManager();
         this.cronScheduler.setWorkerCheckCallback((queue) => this.workerManager.getForQueue(queue).length > 0);
         this.eventsManager = new EventsManager(this.webhookManager);
-        this.eventsManager.subscribe((event) => this.telemetryJournal.record(event));
+        this.eventsManager.subscribe((event) => this.telemetryJournal.record(event), (events) => this.telemetryJournal.recordBatch(events));
         this.contextFactory = new ContextFactory(createContextDependencies(managerRuntime(this)), createContextCallbacks(runtime));
         bgTasks.recover(this.contextFactory.getBackgroundContext());
         if (this.storage) {
@@ -138,7 +153,7 @@ export class QueueManagerState {
         }
         this.recoveryStats = { queues: this.queueNamesCache.size, jobs: this.jobIndex.size };
         if (this.storage)
-            this.cronScheduler.load(this.storage.loadCronJobs());
+            this.cronScheduler.load(persistedCrons);
         this.backgroundTaskHandles = bgTasks.startBackgroundTasks(this.contextFactory.getBackgroundContext(), this.cronScheduler);
     }
 }

package/dist/application/queueTelemetryJournal.d.ts

@@ -10,6 +10,8 @@ export declare class QueueTelemetryJournal {
     private readonly maxMetricDataPoints;
     constructor(storage: SqliteStorage | null, maxEvents: number, maxMetricDataPoints: number);
     record(event: JobEvent): void;
+    /** Persist a lifecycle batch atomically, with scalar fallback on write failure. */
+    recordBatch(events: readonly JobEvent[]): void;
     getMetrics(queue: string, type: QueueMetricType, start?: number, end?: number): QueueMetrics;
     trimEvents(queue: string, maxLength: number): number;
     clearQueue(queue: string): void;

package/dist/application/queueTelemetryJournal.js

@@ -55,6 +55,29 @@ export class QueueTelemetryJournal {
         queueMetrics.set(type, state);
         this.metrics.set(event.queue, queueMetrics);
     }
+    /** Persist a lifecycle batch atomically, with scalar fallback on write failure. */
+    recordBatch(events) {
+        if (events.length === 0)
+            return;
+        if (this.storage) {
+            try {
+                this.storage.recordQueueEventsBatch(events, this.maxEvents, this.maxMetricDataPoints);
+            }
+            catch {
+                for (const event of events) {
+                    try {
+                        this.storage.recordQueueEvent(event, this.maxEvents, this.maxMetricDataPoints);
+                    }
+                    catch {
+                        // Match scalar subscriber isolation and continue with later events.
+                    }
+                }
+            }
+            return;
+        }
+        for (const event of events)
+            this.record(event);
+    }
     getMetrics(queue, type, start = 0, end = -1) {
         assertNonNegativeInteger(start, 'start');
         if (end !== -1)

package/dist/application/types/ack.d.ts

@@ -2,7 +2,7 @@ import type { Shard } from '../../domain/queue/shard';
 import type { FlowFailureRecord } from '../../domain/types/flow';
 import type { FailureReason } from '../../domain/types/dlq';
 import type { Job, JobId } from '../../domain/types/job';
-import type { EventType, JobLocation } from '../../domain/types/queue';
+import type { EventType, JobEvent, JobLocation } from '../../domain/types/queue';
 import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 import type { RWLock } from '../../shared/lock';
 import type { MapLike, SetLike } from '../../shared/lru';
@@ -43,6 +43,7 @@ export interface AckContext {
         prev?: string;
         terminal?: boolean;
     }) => void;
+    broadcastBatch?: (events: readonly JobEvent[]) => void;
     onJobCompleted: (jobId: JobId) => void;
     onJobFailed?: (jobId: JobId) => void;
     onJobsCompleted?: (jobIds: JobId[]) => void;
@@ -107,6 +108,7 @@ export interface FinalizeContext {
         timestamp: number;
         data?: unknown;
     }) => void;
+    broadcastBatch?: (events: readonly JobEvent[]) => void;
     onJobCompleted: (jobId: JobId) => void;
     onJobsCompleted?: (jobIds: JobId[]) => void;
     needsBroadcast?: () => boolean;

package/dist/cli/commandRouter.d.ts

@@ -1,3 +1,3 @@
-export declare const CLI_NETWORK_COMMANDS: readonly ("push" | "queue" | "cron" | "dlq" | "job" | "fail" | "worker" | "concurrency" | "stats" | "ping" | "metrics" | "pull" | "ack" | "rate-limit" | "health" | "webhook")[];
+export declare const CLI_NETWORK_COMMANDS: readonly ("push" | "queue" | "cron" | "concurrency" | "job" | "dlq" | "fail" | "worker" | "stats" | "ping" | "metrics" | "pull" | "ack" | "rate-limit" | "health" | "webhook")[];
 /** Build the protocol command for a routed network CLI command. */
 export declare function buildCommand(command: string, args: string[]): Promise<Record<string, unknown> | null>;

package/dist/cli/commands/server.js

@@ -106,5 +106,5 @@ export async function runServer(args, showHelp) {
     const mergedConfig = applyCliFlags(fileConfig, flags);
     const config = resolveServerConfig(mergedConfig);
     // Same full server as the bare `bunqueue` entry (shared bootstrap)
-    bootServer(mergedConfig, config);
+    await bootServer(mergedConfig, config);
 }

package/dist/client/flowPush.js

@@ -4,6 +4,10 @@
  */
 import { getSharedManager } from './manager';
 import { jobId } from '../domain/types/job';
+import { normalizeGroupId } from './groupId';
+function groupId(opts) {
+    return opts.group ? normalizeGroupId(opts.group.id) : undefined;
+}
 /** Parse removeOnComplete/removeOnFail options */
 function parseRemoveOptions(opts) {
     return {
@@ -67,6 +71,7 @@ function managerOptions(opts) {
         removeDependencyOnFailure: opts.removeDependencyOnFailure,
         ignoreDependencyOnFailure: opts.ignoreDependencyOnFailure,
         continueParentOnFailure: opts.continueParentOnFailure,
+        groupId: groupId(opts),
     };
 }
 /** Full option set for the TCP PUSH command, mirroring buildPushPayload in add.ts (#90). */
@@ -94,6 +99,7 @@ function tcpOptions(opts) {
         removeDependencyOnFailure: opts.removeDependencyOnFailure,
         ignoreDependencyOnFailure: opts.ignoreDependencyOnFailure,
         continueParentOnFailure: opts.continueParentOnFailure,
+        groupId: groupId(opts),
     };
 }
 /** Push a job via embedded manager or TCP */

package/dist/client/forwarder.d.ts

@@ -5,11 +5,13 @@
  * The edge pattern: jobs buffer in the local queue (typically embedded
  * SQLite on a gateway); the Forwarder drains them to a central server over
  * TCP/TLS. A remote failure makes the local job fail → local retry/backoff →
- * local DLQ, so nothing is lost while the uplink is down.
+ * local DLQ. With a persistent local `dataPath`, queued work survives uplink
+ * outages and process restarts; memory-only sources provide no such guarantee.
  *
  * Idempotency: every forwarded job carries the deterministic remote jobId
- * `fwd:<localQueueKey>:<localJobId>`. The server dedupes custom jobIds, so a
- * re-forward after a crash or retry never duplicates the job remotely.
+ * `fwd:<localQueueKey>:<localJobId>`. The server dedupes custom jobIds while
+ * their ownership is retained; after bounded retention or removal, downstream
+ * effects must still tolerate at-least-once delivery.
  */
 import { EventEmitter } from 'events';
 import type { ConnectionOptions, QueueOptions } from './types';
@@ -21,7 +23,7 @@ export interface ForwardOptions {
     queue?: string;
     /** Parallel forwards (default: 4) */
     concurrency?: number;
-    /** Push to the remote with durable: true (immediate fsync server-side) */
+    /** Push with durable: true (bypasses SQLite buffering; PostgreSQL is already transactional). */
     durable?: boolean;
 }
 /** Source queue identity + config, provided by Queue.forward() */

package/dist/client/forwarder.js

@@ -5,11 +5,13 @@
  * The edge pattern: jobs buffer in the local queue (typically embedded
  * SQLite on a gateway); the Forwarder drains them to a central server over
  * TCP/TLS. A remote failure makes the local job fail → local retry/backoff →
- * local DLQ, so nothing is lost while the uplink is down.
+ * local DLQ. With a persistent local `dataPath`, queued work survives uplink
+ * outages and process restarts; memory-only sources provide no such guarantee.
  *
  * Idempotency: every forwarded job carries the deterministic remote jobId
- * `fwd:<localQueueKey>:<localJobId>`. The server dedupes custom jobIds, so a
- * re-forward after a crash or retry never duplicates the job remotely.
+ * `fwd:<localQueueKey>:<localJobId>`. The server dedupes custom jobIds while
+ * their ownership is retained; after bounded retention or removal, downstream
+ * effects must still tolerate at-least-once delivery.
  */
 import { EventEmitter } from 'events';
 import { Worker } from './worker';

package/dist/client/groupId.d.ts

@@ -0,0 +1 @@
+export { normalizeGroupId } from '../domain/types/group';

package/dist/client/groupId.js

@@ -0,0 +1 @@
+export { normalizeGroupId } from '../domain/types/group';

package/dist/client/index.d.ts

@@ -38,7 +38,7 @@ export { shutdownManager } from './manager';
 export { closeSharedTcpClient } from './tcpClient';
 export type { ConnectionHealth } from './tcpClient';
 export { TcpConnectionPool, getSharedPool, closeAllSharedPools } from './tcpPool';
-export type { Job, JobOptions, JobJson, JobJsonRaw, QueueOptions, WorkerOptions, Processor, FlowJobData, StallConfig, DlqConfig, DlqEntry, DlqStats, DlqFilter, FailureReason, ConnectionOptions, ParentOpts, RateLimiterOptions, ChangePriorityOpts, GetDependenciesOpts, JobDependencies, JobDependenciesCount, QueueMetrics, QueueMetricsMeta, QueueMetricType, } from './types';
+export type { Job, JobOptions, GroupJobOptions, GroupWorkerOptions, JobJson, JobJsonRaw, QueueOptions, WorkerOptions, Processor, FlowJobData, StallConfig, DlqConfig, DlqEntry, DlqStats, DlqFilter, FailureReason, ConnectionOptions, ParentOpts, RateLimiterOptions, ChangePriorityOpts, GetDependenciesOpts, JobDependencies, JobDependenciesCount, QueueMetrics, QueueMetricsMeta, QueueMetricType, } from './types';
 export type { FlowStep, FlowResult, FlowJob, JobNode, FlowProducerOptions, FlowOpts } from './flow';
 export type { RepeatOpts, JobTemplate, SchedulerInfo } from './queue/scheduler';
 export type { SandboxedWorkerOptions } from './sandboxedWorker';

package/dist/client/jobHelpers.js

@@ -97,6 +97,7 @@ export function buildJobOpts(job) {
         debounce: job.debounceId && job.debounceTtl !== null
             ? { id: job.debounceId, ttl: job.debounceTtl }
             : undefined,
+        group: job.groupId ? { id: job.groupId } : undefined,
     };
 }
 /** Build parent key from job */

package/dist/client/queue/dlq.d.ts

@@ -52,6 +52,8 @@ export declare function purgeDlq(ctx: DlqContext): number;
  * purge-then-assert-empty patterns need this variant.
  */
 export declare function purgeDlqAsync(ctx: DlqContext): Promise<number>;
+/** Remove one DLQ entry without re-enqueuing it. */
+export declare function removeDlqJobAsync(ctx: DlqContext, id: string): Promise<boolean>;
 /** Retry completed job */
 export declare function retryCompleted(ctx: DlqContext, id?: string): number;
 /** Retry completed job (async) */

package/dist/client/queue/dlq.js

@@ -197,6 +197,20 @@ export async function purgeDlqAsync(ctx) {
         return 0;
     return (response.count ?? 0);
 }
+/** Remove one DLQ entry without re-enqueuing it. */
+export async function removeDlqJobAsync(ctx, id) {
+    if (ctx.embedded)
+        return dlqOps.removeDlqJobEmbedded(ctx.name, id);
+    if (!ctx.tcp)
+        return false;
+    const response = await ctx.tcp.send({ cmd: 'RemoveDlqJob', queue: ctx.name, jobId: id });
+    if (!response.ok) {
+        const error = typeof response.error === 'string' ? response.error : 'Failed to remove the DLQ job';
+        throw new Error(error);
+    }
+    const payload = response;
+    return payload.data?.removed === true;
+}
 /** Retry completed job */
 export function retryCompleted(ctx, id) {
     if (ctx.embedded) {

package/dist/client/queue/dlqOps.d.ts

@@ -18,6 +18,8 @@ export declare function retryDlqByFilterEmbedded(queue: string, filter: DlqFilte
 export declare function retryDlqEmbedded(queue: string, id?: string): number;
 /** Purge DLQ (embedded) */
 export declare function purgeDlqEmbedded(queue: string): number;
+/** Remove one DLQ entry in embedded mode. */
+export declare function removeDlqJobEmbedded(queue: string, id: string): boolean;
 /** Set stall config (embedded only) */
 export declare function setStallConfigEmbedded(queue: string, config: Record<string, unknown>): void;
 /** Get stall config (embedded only) */

package/dist/client/queue/dlqOps.js

@@ -50,6 +50,10 @@ export function retryDlqEmbedded(queue, id) {
 export function purgeDlqEmbedded(queue) {
     return getSharedManager().purgeDlq(queue);
 }
+/** Remove one DLQ entry in embedded mode. */
+export function removeDlqJobEmbedded(queue, id) {
+    return getSharedManager().removeDlqJob(queue, jobId(id));
+}
 /** Set stall config (embedded only) */
 export function setStallConfigEmbedded(queue, config) {
     const manager = getSharedManager();

package/dist/client/queue/helpers.js

@@ -20,6 +20,8 @@ export function getDlqContext(manager) {
         shards: getShards(manager),
         jobIndex: manager.getJobIndex(),
         jobResults: manager.jobResults,
+        dependencyResults: manager.dependencyResults,
+        customIdMap: manager.customIdMap,
         jobLogs: manager.jobLogs,
         // #110-class: without storage, retryDlqByFilter's deleteDlqEntry/insertJob
         // silently no-op — filtered retries were never persisted in embedded mode

package/dist/client/queue/operations/add/bulk.js

@@ -1,7 +1,7 @@
 import { getSharedManager } from '../../../manager';
 import { jobId } from '../../../../domain/types/job';
 import { createJobProxy, createSimpleJob } from '../../jobProxy';
-import { buildJobData, buildRepeatOptions, compact, reflectionMeta } from './payload';
+import { buildJobData, buildRepeatOptions, compact, reflectionMeta, resolveGroupId, } from './payload';
 export async function addBulk(context, jobs) {
     if (jobs.length === 0)
         return [];
@@ -11,7 +11,7 @@ export async function addBulk(context, jobs) {
         ...opts,
     }));
     if (context.embedded) {
-        const manager = getSharedManager();
+        const manager = getSharedManager(context.opts.dataPath);
         const inputs = jobs.map(({ name, data }, index) => {
             const options = merged[index];
             const removeOnComplete = typeof options.removeOnComplete === 'boolean' ? options.removeOnComplete : false;
@@ -30,7 +30,7 @@ export async function addBulk(context, jobs) {
                 dependsOn: options.dependsOn?.map((id) => jobId(id)),
                 parentId: options.parent ? jobId(options.parent.id) : undefined,
                 tags: options.tags,
-                groupId: options.groupId,
+                groupId: resolveGroupId(options),
                 stallTimeout: options.stallTimeout,
                 timestamp: options.timestamp,
                 removeOnComplete,
@@ -84,7 +84,7 @@ export async function addBulk(context, jobs) {
             ttl: options.ttl,
             customId: options.jobId,
             tags: options.tags,
-            groupId: options.groupId,
+            groupId: resolveGroupId(options),
             dependsOn: options.dependsOn?.map((id) => jobId(id)),
             parentId: options.parent ? jobId(options.parent.id) : undefined,
             uniqueKey: options.deduplication?.id,

package/dist/client/queue/operations/add/payload.d.ts

@@ -16,6 +16,7 @@ export declare function buildRepeatOptions(repeat: NonNullable<JobOptions['repea
     jobId: string | undefined;
 };
 export declare function buildPushPayload(queue: string, name: string, data: unknown, options: ExtendedJobOptions): Record<string, unknown>;
+export declare function resolveGroupId(options: ExtendedJobOptions): string | undefined;
 export declare function buildJobData(data: unknown, options: ExtendedJobOptions): unknown;
 export declare function reflectionMeta(options: ExtendedJobOptions): {
     priority?: number;

package/dist/client/queue/operations/add/payload.js

@@ -1,3 +1,4 @@
+import { normalizeGroupId } from '../../../groupId';
 export function compact(object) {
     const output = {};
     for (const key in object) {
@@ -51,7 +52,7 @@ export function buildPushPayload(queue, name, data, options) {
             : undefined,
         dependsOn: options.dependsOn,
         tags: options.tags,
-        groupId: options.groupId,
+        groupId: resolveGroupId(options),
         lifo: options.lifo,
         removeOnComplete: typeof options.removeOnComplete === 'boolean' ? options.removeOnComplete : undefined,
         removeOnFail: typeof options.removeOnFail === 'boolean' ? options.removeOnFail : undefined,
@@ -71,6 +72,11 @@ export function buildPushPayload(queue, name, data, options) {
         parentId: options.parent?.id,
     });
 }
+export function resolveGroupId(options) {
+    if (options.group)
+        return normalizeGroupId(options.group.id);
+    return options.groupId === undefined ? undefined : normalizeGroupId(options.groupId);
+}
 export function buildJobData(data, options) {
     if (!options.parent)
         return data;

package/dist/client/queue/operations/add/single.js

@@ -3,12 +3,12 @@ import { removeJobDeduplicationKey } from '../../../jobDeduplication';
 import { toPublicJob } from '../../../types';
 import { jobId } from '../../../../domain/types/job';
 import { createJobProxy } from '../../jobProxy';
-import { buildJobData, buildPushPayload, buildRepeatOptions } from './payload';
+import { buildJobData, buildPushPayload, buildRepeatOptions, resolveGroupId } from './payload';
 export async function add(context, jobName, data, options = {}) {
     const merged = { ...context.opts.defaultJobOptions, ...options };
     const jobData = buildJobData(data, merged);
     if (context.embedded) {
-        const manager = getSharedManager();
+        const manager = getSharedManager(context.opts.dataPath);
         const removeOnComplete = typeof merged.removeOnComplete === 'boolean' ? merged.removeOnComplete : false;
         const removeOnFail = typeof merged.removeOnFail === 'boolean' ? merged.removeOnFail : false;
         const repeat = merged.repeat ? buildRepeatOptions(merged.repeat) : undefined;
@@ -25,7 +25,7 @@ export async function add(context, jobName, data, options = {}) {
             customId: merged.jobId,
             dependsOn: merged.dependsOn?.map((id) => jobId(id)),
             tags: merged.tags,
-            groupId: merged.groupId,
+            groupId: resolveGroupId(merged),
             dedup: merged.deduplication
                 ? {
                     ttl: merged.deduplication.ttl,

package/dist/client/queue/operations/groups.d.ts

@@ -0,0 +1,21 @@
+import type { TcpConnectionPool } from '../../tcpPool';
+interface GroupContext {
+    name: string;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+    dataPath: string | undefined;
+}
+export declare function getGroupJobsCount(ctx: GroupContext, groupId: string): Promise<number>;
+export declare function getGroupsJobsCount(ctx: GroupContext, maxCount?: number): Promise<number>;
+export declare function getGroupActiveCount(ctx: GroupContext, groupId: string): Promise<number>;
+export declare function setGroupRateLimit(ctx: GroupContext, groupId: string, max: number, duration: number): Promise<void>;
+export declare function getGroupRateLimit(ctx: GroupContext, groupId: string): Promise<{
+    max: number;
+    duration: number;
+} | null>;
+export declare function removeGroupRateLimit(ctx: GroupContext, groupId: string): Promise<number>;
+export declare function getGroupRateLimitTtl(ctx: GroupContext, groupId: string, maxJobs?: number): Promise<number>;
+export declare function setGroupConcurrency(ctx: GroupContext, groupId: string, concurrency: number): Promise<void>;
+export declare function getGroupConcurrency(ctx: GroupContext, groupId: string): Promise<number | null>;
+export declare function removeGroupConcurrency(ctx: GroupContext, groupId: string): Promise<number>;
+export {};

package/dist/client/queue/operations/groups.js

@@ -0,0 +1,88 @@
+import { getSharedManager } from '../../manager';
+import { normalizeGroupId } from '../../groupId';
+function manager(ctx) {
+    return getSharedManager(ctx.dataPath);
+}
+async function send(ctx, command) {
+    if (!ctx.tcp)
+        throw new Error('TCP connection is unavailable for group operation');
+    const response = await ctx.tcp.send({ ...command, queue: ctx.name });
+    if (!response.ok)
+        throw new Error(String(response.error ?? 'Group operation failed'));
+    const data = typeof response.data === 'object' && response.data !== null
+        ? response.data
+        : {};
+    return { ...response, ...data };
+}
+export async function getGroupJobsCount(ctx, groupId) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded)
+        return await manager(ctx).getGroupJobsCount(ctx.name, id);
+    const response = await send(ctx, { cmd: 'GetGroupJobsCount', groupId: id });
+    return Number(response.count ?? 0);
+}
+export async function getGroupsJobsCount(ctx, maxCount = 100) {
+    if (ctx.embedded)
+        return await manager(ctx).getGroupsJobsCount(ctx.name);
+    const response = await send(ctx, { cmd: 'GetGroupsJobsCount', maxCount });
+    return Number(response.count ?? 0);
+}
+export async function getGroupActiveCount(ctx, groupId) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded)
+        return await manager(ctx).getGroupActiveCount(ctx.name, id);
+    const response = await send(ctx, { cmd: 'GetGroupActiveCount', groupId: id });
+    return Number(response.count ?? 0);
+}
+export async function setGroupRateLimit(ctx, groupId, max, duration) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded) {
+        await manager(ctx).setGroupRateLimit(ctx.name, id, max, duration);
+        return;
+    }
+    await send(ctx, { cmd: 'SetGroupRateLimit', groupId: id, max, duration });
+}
+export async function getGroupRateLimit(ctx, groupId) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded)
+        return await manager(ctx).getGroupRateLimit(ctx.name, id);
+    const response = await send(ctx, { cmd: 'GetGroupRateLimit', groupId: id });
+    return response.limit ?? null;
+}
+export async function removeGroupRateLimit(ctx, groupId) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded)
+        return await manager(ctx).removeGroupRateLimit(ctx.name, id);
+    const response = await send(ctx, { cmd: 'RemoveGroupRateLimit', groupId: id });
+    return Number(response.removed ?? 0);
+}
+export async function getGroupRateLimitTtl(ctx, groupId, maxJobs) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded) {
+        return await manager(ctx).getGroupRateLimitTtl(ctx.name, id, maxJobs);
+    }
+    const response = await send(ctx, { cmd: 'GetGroupRateLimitTtl', groupId: id, maxJobs });
+    return Number(response.ttl ?? -2);
+}
+export async function setGroupConcurrency(ctx, groupId, concurrency) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded) {
+        await manager(ctx).setGroupConcurrency(ctx.name, id, concurrency);
+        return;
+    }
+    await send(ctx, { cmd: 'SetGroupConcurrency', groupId: id, concurrency });
+}
+export async function getGroupConcurrency(ctx, groupId) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded)
+        return await manager(ctx).getGroupConcurrency(ctx.name, id);
+    const response = await send(ctx, { cmd: 'GetGroupConcurrency', groupId: id });
+    return typeof response.concurrency === 'number' ? response.concurrency : null;
+}
+export async function removeGroupConcurrency(ctx, groupId) {
+    const id = normalizeGroupId(groupId);
+    if (ctx.embedded)
+        return await manager(ctx).removeGroupConcurrency(ctx.name, id);
+    const response = await send(ctx, { cmd: 'RemoveGroupConcurrency', groupId: id });
+    return Number(response.removed ?? 0);
+}

package/dist/client/queue/runtime/configuration.d.ts

@@ -21,6 +21,10 @@ export declare class QueueConfiguration<T> extends QueueControl<T> {
     retryDlqByFilterAsync(filter: DlqFilter): Promise<number>;
     purgeDlq(): number;
     purgeDlqAsync(): Promise<number>;
+    /** Remove one DLQ entry and resolve when the removal completes. */
+    removeDlqJob(id: string): Promise<boolean>;
+    /** Explicit async alias for removeDlqJob. */
+    removeDlqJobAsync(id: string): Promise<boolean>;
     retryCompleted(id?: string): number;
     retryCompletedAsync(id?: string): Promise<number>;
     setGlobalConcurrency(concurrency: number): void;

package/dist/client/queue/runtime/configuration.js

@@ -61,6 +61,14 @@ export class QueueConfiguration extends QueueControl {
     purgeDlqAsync() {
         return dlqOps.purgeDlqAsync(this.ctx);
     }
+    /** Remove one DLQ entry and resolve when the removal completes. */
+    removeDlqJob(id) {
+        return dlqOps.removeDlqJobAsync(this.ctx, id);
+    }
+    /** Explicit async alias for removeDlqJob. */
+    removeDlqJobAsync(id) {
+        return this.removeDlqJob(id);
+    }
     retryCompleted(id) {
         return dlqOps.retryCompleted(this.ctx, id);
     }

package/dist/client/queue/runtime/queries.d.ts

@@ -3,6 +3,19 @@ import * as countsOps from '../operations/counts';
 import { QueueState } from './state';
 /** Job creation, lookup, state-listing, and count operations. */
 export declare class QueueQueries<T> extends QueueState<T> {
+    getGroupJobsCount(groupId: string): Promise<number>;
+    getGroupsJobsCount(maxCount?: number): Promise<number>;
+    getGroupActiveCount(groupId: string): Promise<number>;
+    setGroupRateLimit(groupId: string, max: number, duration: number): Promise<void>;
+    getGroupRateLimit(groupId: string): Promise<{
+        max: number;
+        duration: number;
+    } | null>;
+    removeGroupRateLimit(groupId: string): Promise<number>;
+    getGroupRateLimitTtl(groupId: string, maxJobs?: number): Promise<number>;
+    setGroupConcurrency(groupId: string, concurrency: number): Promise<void>;
+    getGroupConcurrency(groupId: string): Promise<number | null>;
+    removeGroupConcurrency(groupId: string): Promise<number>;
     add(name: string, data: T, opts?: JobOptions): Promise<Job<T>>;
     addBulk(jobs: Array<{
         name: string;

package/dist/client/queue/runtime/queries.js

@@ -2,9 +2,40 @@ import * as countsOps from '../operations/counts';
 import * as addOps from '../operations/add';
 import * as queryOps from '../operations/query';
 import * as queryStateOps from '../operations/queryStates';
+import * as groupOps from '../operations/groups';
 import { QueueState } from './state';
 /** Job creation, lookup, state-listing, and count operations. */
 export class QueueQueries extends QueueState {
+    getGroupJobsCount(groupId) {
+        return groupOps.getGroupJobsCount(this.ctx, groupId);
+    }
+    getGroupsJobsCount(maxCount) {
+        return groupOps.getGroupsJobsCount(this.ctx, maxCount);
+    }
+    getGroupActiveCount(groupId) {
+        return groupOps.getGroupActiveCount(this.ctx, groupId);
+    }
+    setGroupRateLimit(groupId, max, duration) {
+        return groupOps.setGroupRateLimit(this.ctx, groupId, max, duration);
+    }
+    getGroupRateLimit(groupId) {
+        return groupOps.getGroupRateLimit(this.ctx, groupId);
+    }
+    removeGroupRateLimit(groupId) {
+        return groupOps.removeGroupRateLimit(this.ctx, groupId);
+    }
+    getGroupRateLimitTtl(groupId, maxJobs) {
+        return groupOps.getGroupRateLimitTtl(this.ctx, groupId, maxJobs);
+    }
+    setGroupConcurrency(groupId, concurrency) {
+        return groupOps.setGroupConcurrency(this.ctx, groupId, concurrency);
+    }
+    getGroupConcurrency(groupId) {
+        return groupOps.getGroupConcurrency(this.ctx, groupId);
+    }
+    removeGroupConcurrency(groupId) {
+        return groupOps.removeGroupConcurrency(this.ctx, groupId);
+    }
     add(name, data, opts) {
         if (this.addBatcher && !opts?.durable) {
             return this.addBatcher.enqueue(name, data, opts);