bunqueue 2.8.60 → 2.9.2

package/dist/domain/queue/groupScheduler.js

@@ -0,0 +1,256 @@
+import { getGroupFifoOrder, setGroupFifoOrder } from '../job/groupFifoOrder';
+import { isExpired, isReady } from '../types/job';
+import { IndexedPriorityQueue } from './priorityQueue';
+import { compareGroupFifoEntries, compareGroupWakeEntries, nextGroupCheckAt, orderedGroupClone, } from './groupSchedulerOrder';
+/** Lazy secondary ready/group indexes; the primary queue remains authoritative. */
+export class GroupScheduler {
+    queues = new Map();
+    nextFifoOrder = 1n;
+    assignFifoOrder(job) {
+        if (!job.groupId)
+            return;
+        const existing = getGroupFifoOrder(job);
+        if (existing !== null) {
+            this.observeFifoOrder(job);
+            return;
+        }
+        setGroupFifoOrder(job, this.nextFifoOrder++);
+    }
+    observeFifoOrder(job) {
+        const order = getGroupFifoOrder(job);
+        if (order !== null && order >= this.nextFifoOrder)
+            this.nextFifoOrder = order + 1n;
+    }
+    insert(queue, job, primaryJobs, now = Date.now()) {
+        this.assignFifoOrder(job);
+        let state = this.queues.get(queue);
+        const previous = state?.jobs.get(job.id);
+        if (previous) {
+            this.remove(queue, previous);
+            state = this.queues.get(queue);
+        }
+        if (!state) {
+            if (!job.groupId)
+                return false;
+            state = this.createState();
+            this.queues.set(queue, state);
+            for (const current of primaryJobs()) {
+                this.assignFifoOrder(current);
+                this.insertTracked(state, current, now);
+            }
+            return true;
+        }
+        this.insertTracked(state, job, now);
+        return true;
+    }
+    remove(queue, job) {
+        const state = this.queues.get(queue);
+        if (!state)
+            return false;
+        const tracked = state.jobs.get(job.id) ?? job;
+        const placement = state.placements.get(job.id);
+        if (!placement)
+            return true;
+        if (placement.kind === 'plain') {
+            state.plain.remove(job.id);
+        }
+        else if (placement.kind === 'delayed') {
+            state.delayed.remove(job.id);
+        }
+        else {
+            const lane = state.lanes.get(placement.groupId);
+            lane?.jobs.remove(job.id);
+            if (lane?.jobs.isEmpty)
+                this.detachLane(state, placement.groupId, lane);
+        }
+        state.placements.delete(job.id);
+        state.jobs.delete(job.id);
+        if (tracked.groupId) {
+            const count = (state.groupCounts.get(tracked.groupId) ?? 1) - 1;
+            if (count > 0)
+                state.groupCounts.set(tracked.groupId, count);
+            else {
+                state.groupCounts.delete(tracked.groupId);
+                const lane = state.lanes.get(tracked.groupId);
+                if (lane?.jobs.isEmpty && !lane.inRotation)
+                    state.lanes.delete(tracked.groupId);
+            }
+            state.groupedCount = Math.max(0, state.groupedCount - 1);
+            if (state.groupedCount === 0)
+                this.queues.delete(queue);
+        }
+        return this.queues.has(queue);
+    }
+    isActive(queue) {
+        return this.queues.has(queue);
+    }
+    peek(queue, now, eligibility) {
+        const state = this.queues.get(queue);
+        if (!state)
+            return { job: null, nextRunAt: null };
+        while (true) {
+            this.promoteDue(state, now);
+            let plain = state.plain.peek();
+            while (plain) {
+                const job = state.jobs.get(plain.id) ?? plain;
+                if (isReady(job, now) || isExpired(job, now))
+                    return { job, nextRunAt: null };
+                this.demoteReady(state, job);
+                plain = state.plain.peek();
+            }
+            let nextRunAt = state.delayed.peek()?.runAt ?? null;
+            let groupId = state.cursor;
+            let restart = false;
+            for (let visited = 0; groupId && visited < state.rotationSize; visited++) {
+                const lane = state.lanes.get(groupId);
+                if (!lane?.inRotation)
+                    break;
+                const candidate = lane.jobs.peek();
+                if (candidate) {
+                    const job = state.jobs.get(candidate.id) ?? candidate;
+                    if (!isReady(job, now) && !isExpired(job, now)) {
+                        this.demoteReady(state, job);
+                        restart = true;
+                        break;
+                    }
+                    const status = eligibility(groupId);
+                    if (status.eligible)
+                        return { job, nextRunAt };
+                    if (status.retryAt !== null) {
+                        nextRunAt = nextRunAt === null ? status.retryAt : Math.min(nextRunAt, status.retryAt);
+                    }
+                }
+                groupId = lane.next;
+            }
+            if (!restart)
+                return { job: null, nextRunAt };
+        }
+    }
+    advance(queue, groupId) {
+        const state = this.queues.get(queue);
+        const lane = state?.lanes.get(groupId);
+        if (state && lane?.inRotation)
+            state.cursor = lane.next;
+    }
+    getGroupJobsCount(queue, groupId) {
+        return this.queues.get(queue)?.groupCounts.get(groupId) ?? 0;
+    }
+    getGroupsJobsCount(queue) {
+        return this.queues.get(queue)?.groupedCount ?? 0;
+    }
+    clearQueue(queue) {
+        this.queues.delete(queue);
+    }
+    createState() {
+        return {
+            jobs: new Map(),
+            placements: new Map(),
+            plain: new IndexedPriorityQueue(),
+            delayed: new IndexedPriorityQueue(undefined, compareGroupWakeEntries, getGroupFifoOrder),
+            lanes: new Map(),
+            groupCounts: new Map(),
+            groupedCount: 0,
+            cursor: null,
+            rotationSize: 0,
+        };
+    }
+    insertTracked(state, job, now) {
+        state.jobs.set(job.id, job);
+        if (job.groupId) {
+            state.groupCounts.set(job.groupId, (state.groupCounts.get(job.groupId) ?? 0) + 1);
+            state.groupedCount++;
+        }
+        if (nextGroupCheckAt(job) > now) {
+            state.delayed.push(orderedGroupClone(job, nextGroupCheckAt(job)));
+            state.placements.set(job.id, { kind: 'delayed' });
+            return;
+        }
+        this.insertReady(state, job);
+    }
+    promoteDue(state, now) {
+        while (true) {
+            const scheduled = state.delayed.peek();
+            if (!scheduled || scheduled.runAt > now)
+                return;
+            state.delayed.pop();
+            const job = state.jobs.get(scheduled.id);
+            if (!job || state.placements.get(job.id)?.kind !== 'delayed')
+                continue;
+            this.insertReady(state, job);
+        }
+    }
+    insertReady(state, job) {
+        if (!job.groupId) {
+            state.plain.push(job);
+            state.placements.set(job.id, { kind: 'plain' });
+            return;
+        }
+        let lane = state.lanes.get(job.groupId);
+        if (!lane) {
+            lane = {
+                jobs: new IndexedPriorityQueue(undefined, compareGroupFifoEntries, getGroupFifoOrder),
+                previous: job.groupId,
+                next: job.groupId,
+                inRotation: false,
+            };
+            state.lanes.set(job.groupId, lane);
+        }
+        lane.jobs.push(orderedGroupClone(job));
+        state.placements.set(job.id, { kind: 'group', groupId: job.groupId });
+        if (!lane.inRotation)
+            this.attachLane(state, job.groupId, lane);
+    }
+    demoteReady(state, job) {
+        const placement = state.placements.get(job.id);
+        if (placement?.kind === 'plain') {
+            state.plain.remove(job.id);
+        }
+        else if (placement?.kind === 'group') {
+            const lane = state.lanes.get(placement.groupId);
+            lane?.jobs.remove(job.id);
+            if (lane?.jobs.isEmpty)
+                this.detachLane(state, placement.groupId, lane);
+        }
+        else {
+            return;
+        }
+        state.delayed.push(orderedGroupClone(job, nextGroupCheckAt(job)));
+        state.placements.set(job.id, { kind: 'delayed' });
+    }
+    attachLane(state, groupId, lane) {
+        if (state.cursor === null) {
+            lane.previous = groupId;
+            lane.next = groupId;
+            state.cursor = groupId;
+        }
+        else {
+            const cursor = state.lanes.get(state.cursor);
+            const tail = state.lanes.get(cursor.previous);
+            lane.previous = cursor.previous;
+            lane.next = state.cursor;
+            tail.next = groupId;
+            cursor.previous = groupId;
+        }
+        lane.inRotation = true;
+        state.rotationSize++;
+    }
+    detachLane(state, groupId, lane) {
+        if (!lane.inRotation)
+            return;
+        if (state.rotationSize === 1) {
+            state.cursor = null;
+        }
+        else {
+            const previous = state.lanes.get(lane.previous);
+            const next = state.lanes.get(lane.next);
+            previous.next = lane.next;
+            next.previous = lane.previous;
+            if (state.cursor === groupId)
+                state.cursor = lane.next;
+        }
+        lane.inRotation = false;
+        state.rotationSize--;
+        if (lane.jobs.isEmpty && !state.groupCounts.has(groupId))
+            state.lanes.delete(groupId);
+    }
+}

package/dist/domain/queue/groupSchedulerOrder.d.ts

@@ -0,0 +1,6 @@
+import type { Job } from '../types/job';
+import type { HeapEntry } from '../types/priorityQueue';
+export declare function orderedGroupClone(job: Job, runAt?: number): Job;
+export declare function nextGroupCheckAt(job: Job): number;
+export declare function compareGroupFifoEntries(left: HeapEntry, right: HeapEntry): number;
+export declare function compareGroupWakeEntries(left: HeapEntry, right: HeapEntry): number;

package/dist/domain/queue/groupSchedulerOrder.js

@@ -0,0 +1,30 @@
+import { copyGroupFifoOrder } from '../job/groupFifoOrder';
+export function orderedGroupClone(job, runAt = job.runAt) {
+    const clone = { ...job, priority: 0, lifo: false, runAt };
+    copyGroupFifoOrder(job, clone);
+    return clone;
+}
+export function nextGroupCheckAt(job) {
+    if (job.ttl === null)
+        return job.runAt;
+    return Math.min(job.runAt, job.createdAt + job.ttl + 1);
+}
+function compareOrder(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+export function compareGroupFifoEntries(left, right) {
+    const order = compareOrder(left.groupFifoOrder ?? left.generation, right.groupFifoOrder ?? right.generation);
+    if (order !== 0)
+        return order;
+    return left.jobId < right.jobId ? -1 : left.jobId > right.jobId ? 1 : 0;
+}
+export function compareGroupWakeEntries(left, right) {
+    if (left.runAt !== right.runAt)
+        return left.runAt - right.runAt;
+    if (left.groupFifoOrder !== undefined && right.groupFifoOrder !== undefined) {
+        const order = compareOrder(left.groupFifoOrder, right.groupFifoOrder);
+        if (order !== 0)
+            return order;
+    }
+    return left.jobId < right.jobId ? -1 : left.jobId > right.jobId ? 1 : 0;
+}

package/dist/domain/queue/priorityQueue.d.ts

@@ -1,44 +1,35 @@
-/**
- * Indexed Priority Queue
- * Combines binary heap for O(log n) priority operations
- * with Map for O(1) lookups by job ID
- */
 import type { Job, JobId } from '../types/job';
-/**
- * Indexed Priority Queue implementation with 4-ary heap
- * 4-ary provides better cache locality than binary heap
- * O(log₄ n) push, pop, update
- * O(1) find, has
- */
+import type { HeapEntry } from '../types/priorityQueue';
+export interface PriorityQueueHooks {
+    onInsert(job: Job): boolean;
+    onRemove(job: Job): boolean;
+}
+export type PriorityQueueComparator = (left: HeapEntry, right: HeapEntry) => number;
+export type PriorityQueueOrder = (job: Job) => bigint | null;
+/** Indexed map-backed 4-ary heap with O(log4 n) mutations and O(1) lookup. */
 export declare class IndexedPriorityQueue {
-    /** Branching factor - 4 provides optimal cache performance */
+    private readonly hooks?;
+    private readonly compare;
+    private readonly order?;
     private static readonly D;
     private heap;
     private readonly index;
     private generation;
-    /** Get current size */
+    private hooksActive;
+    constructor(hooks?: PriorityQueueHooks | undefined, compare?: PriorityQueueComparator, order?: PriorityQueueOrder | undefined);
     get size(): number;
-    /** Check if empty */
     get isEmpty(): boolean;
-    /** Push a job into the queue */
     push(job: Job): void;
-    /** Pop the highest priority job */
     pop(): Job | null;
-    /** Peek at the highest priority job without removing */
     peek(): Job | null;
-    /** Find a job by ID - O(1) */
     find(jobId: JobId): Job | null;
-    /** Check if job exists - O(1) */
     has(jobId: JobId): boolean;
-    /** Remove a job by ID - O(1) for index, heap cleans lazily */
     remove(jobId: JobId): Job | null;
     /** Update job priority - O(log n). Optionally update the LIFO tie-break flag. */
     updatePriority(jobId: JobId, newPriority: number, newLifo?: boolean): boolean;
     /** Update job runAt (for delay changes) - O(log n) */
     updateRunAt(jobId: JobId, newRunAt: number): boolean;
-    /** Get all jobs (for iteration) */
     values(): Job[];
-    /** Clear the queue */
     clear(): void;
     /**
      * Get the ratio of stale entries in the heap
@@ -51,7 +42,6 @@ export declare class IndexedPriorityQueue {
      * O(n) operation but reclaims memory and improves performance
      */
     compact(): void;
-    /** Rebuild heap property from arbitrary array - O(n) */
     private heapify;
     /** Check if compaction is needed (stale ratio > threshold) */
     needsCompaction(threshold?: number): boolean;

package/dist/domain/queue/priorityQueue.js

@@ -1,36 +1,29 @@
-/**
- * Indexed Priority Queue
- * Combines binary heap for O(log n) priority operations
- * with Map for O(1) lookups by job ID
- */
+import { copyGroupFifoOrder } from '../job/groupFifoOrder';
 import { comparePriorityEntries } from './priorityQueueOrder';
-/**
- * Indexed Priority Queue implementation with 4-ary heap
- * 4-ary provides better cache locality than binary heap
- * O(log₄ n) push, pop, update
- * O(1) find, has
- */
+/** Indexed map-backed 4-ary heap with O(log4 n) mutations and O(1) lookup. */
 export class IndexedPriorityQueue {
-    /** Branching factor - 4 provides optimal cache performance */
+    hooks;
+    compare;
+    order;
     static D = 4;
     heap = [];
     index = new Map();
-    // Use BigInt to prevent overflow at extreme throughput
     generation = 0n;
-    /** Get current size */
+    hooksActive = false;
+    constructor(hooks, compare = comparePriorityEntries, order) {
+        this.hooks = hooks;
+        this.compare = compare;
+        this.order = order;
+    }
     get size() {
         return this.index.size;
     }
-    /** Check if empty */
     get isEmpty() {
         return this.index.size === 0;
     }
-    /** Push a job into the queue */
     push(job) {
         const gen = this.generation++;
-        // Store in index
         this.index.set(job.id, { job, generation: gen });
-        // Add to heap
         const entry = {
             jobId: job.id,
             priority: job.priority,
@@ -38,32 +31,38 @@ export class IndexedPriorityQueue {
             lifo: job.lifo,
             generation: gen,
         };
+        if (this.order) {
+            const groupFifoOrder = this.order(job);
+            if (groupFifoOrder !== null)
+                entry.groupFifoOrder = groupFifoOrder;
+        }
         this.heap.push(entry);
         this.bubbleUp(this.heap.length - 1);
+        if (this.hooks && (this.hooksActive || job.groupId)) {
+            this.hooksActive = this.hooks.onInsert(job);
+        }
     }
-    /** Pop the highest priority job */
     pop() {
         while (this.heap.length > 0) {
             const entry = this.heap[0];
             const indexed = this.index.get(entry.jobId);
-            // Skip stale entries (generation mismatch = updated or removed)
             if (indexed?.generation !== entry.generation) {
                 this.removeTop();
                 continue;
             }
-            // Remove from both structures
             this.removeTop();
             this.index.delete(entry.jobId);
+            if (this.hooks && this.hooksActive) {
+                this.hooksActive = this.hooks.onRemove(indexed.job);
+            }
             return indexed.job;
         }
         return null;
     }
-    /** Peek at the highest priority job without removing */
     peek() {
         while (this.heap.length > 0) {
             const entry = this.heap[0];
             const indexed = this.index.get(entry.jobId);
-            // Skip stale entries
             if (indexed?.generation !== entry.generation) {
                 this.removeTop();
                 continue;
@@ -72,21 +71,20 @@ export class IndexedPriorityQueue {
         }
         return null;
     }
-    /** Find a job by ID - O(1) */
     find(jobId) {
         return this.index.get(jobId)?.job ?? null;
     }
-    /** Check if job exists - O(1) */
     has(jobId) {
         return this.index.has(jobId);
     }
-    /** Remove a job by ID - O(1) for index, heap cleans lazily */
     remove(jobId) {
         const indexed = this.index.get(jobId);
         if (!indexed)
             return null;
         this.index.delete(jobId);
-        // Heap entry becomes stale, will be skipped on pop
+        if (this.hooks && this.hooksActive) {
+            this.hooksActive = this.hooks.onRemove(indexed.job);
+        }
         return indexed.job;
     }
     /** Update job priority - O(log n). Optionally update the LIFO tie-break flag. */
@@ -95,15 +93,13 @@ export class IndexedPriorityQueue {
         if (!indexed)
             return false;
         const lifo = newLifo ?? indexed.job.lifo;
-        // Create new job with updated priority (immutable pattern)
         const updatedJob = {
             ...indexed.job,
             priority: newPriority,
             lifo,
         };
-        // Create new heap entry with new generation
+        copyGroupFifoOrder(indexed.job, updatedJob);
         const gen = this.generation++;
-        // Update index with new job and generation
         this.index.set(jobId, { job: updatedJob, generation: gen });
         const entry = {
             jobId: updatedJob.id,
@@ -112,8 +108,16 @@ export class IndexedPriorityQueue {
             lifo,
             generation: gen,
         };
+        if (this.order) {
+            const groupFifoOrder = this.order(updatedJob);
+            if (groupFifoOrder !== null)
+                entry.groupFifoOrder = groupFifoOrder;
+        }
         this.heap.push(entry);
         this.bubbleUp(this.heap.length - 1);
+        if (this.hooks && (this.hooksActive || updatedJob.groupId)) {
+            this.hooksActive = this.hooks.onInsert(updatedJob);
+        }
         return true;
     }
     /** Update job runAt (for delay changes) - O(log n) */
@@ -121,14 +125,12 @@ export class IndexedPriorityQueue {
         const indexed = this.index.get(jobId);
         if (!indexed)
             return false;
-        // Create new job with updated runAt (immutable pattern)
         const updatedJob = {
             ...indexed.job,
             runAt: newRunAt,
         };
-        // Create new heap entry with new generation
+        copyGroupFifoOrder(indexed.job, updatedJob);
         const gen = this.generation++;
-        // Update index with new job and generation
         this.index.set(jobId, { job: updatedJob, generation: gen });
         const entry = {
             jobId: updatedJob.id,
@@ -137,19 +139,33 @@ export class IndexedPriorityQueue {
             lifo: updatedJob.lifo,
             generation: gen,
         };
+        if (this.order) {
+            const groupFifoOrder = this.order(updatedJob);
+            if (groupFifoOrder !== null)
+                entry.groupFifoOrder = groupFifoOrder;
+        }
         this.heap.push(entry);
         this.bubbleUp(this.heap.length - 1);
+        if (this.hooks && (this.hooksActive || updatedJob.groupId)) {
+            this.hooksActive = this.hooks.onInsert(updatedJob);
+        }
         return true;
     }
-    /** Get all jobs (for iteration) */
     values() {
         return Array.from(this.index.values()).map((v) => v.job);
     }
-    /** Clear the queue */
     clear() {
+        if (this.hooks) {
+            for (const { job } of this.index.values()) {
+                if (!this.hooksActive)
+                    break;
+                this.hooksActive = this.hooks.onRemove(job);
+            }
+        }
         this.heap = [];
         this.index.clear();
         this.generation = 0n;
+        this.hooksActive = false;
     }
     /**
      * Get the ratio of stale entries in the heap
@@ -180,11 +196,8 @@ export class IndexedPriorityQueue {
         this.heap = validEntries;
         this.heapify();
     }
-    /** Rebuild heap property from arbitrary array - O(n) */
     heapify() {
         const D = IndexedPriorityQueue.D;
-        // Start from last non-leaf node and bubble down
-        // In D-ary heap, last non-leaf is at floor((n-2)/D)
         for (let i = Math.floor((this.heap.length - 2) / D); i >= 0; i--) {
             this.bubbleDown(i);
         }
@@ -193,7 +206,6 @@ export class IndexedPriorityQueue {
     needsCompaction(threshold = 0.2) {
         return this.getStaleRatio() > threshold;
     }
-    // ============ Heap Operations ============
     removeTop() {
         if (this.heap.length <= 1) {
             this.heap.pop();
@@ -207,7 +219,7 @@ export class IndexedPriorityQueue {
         const D = IndexedPriorityQueue.D;
         while (idx > 0) {
             const parentIdx = Math.floor((idx - 1) / D);
-            if (comparePriorityEntries(this.heap[idx], this.heap[parentIdx]) >= 0) {
+            if (this.compare(this.heap[idx], this.heap[parentIdx]) >= 0) {
                 break;
             }
             this.swap(idx, parentIdx);
@@ -223,11 +235,10 @@ export class IndexedPriorityQueue {
             const firstChild = D * idx + 1;
             if (firstChild >= length)
                 break;
-            // Find minimum among up to D children (cache-friendly sequential access)
             let smallest = idx;
             const lastChild = Math.min(firstChild + D, length);
             for (let c = firstChild; c < lastChild; c++) {
-                if (comparePriorityEntries(heap[c], heap[smallest]) < 0) {
+                if (this.compare(heap[c], heap[smallest]) < 0) {
                     smallest = c;
                 }
             }

package/dist/domain/queue/shard/dlq.d.ts

@@ -18,6 +18,7 @@ export declare class ShardDlq extends ShardDependencies {
     getDlq(queue: string, count?: number): Job[];
     getDlqFiltered(queue: string, filter: DlqFilter): DlqEntry[];
     removeFromDlq(queue: string, jobId: JobId): DlqEntry | null;
+    removeAllFromDlq(queue: string, jobId: JobId): DlqEntry[];
     getAutoRetryEntries(queue: string, now?: number): DlqEntry[];
     getExpiredEntries(queue: string, now?: number): DlqEntry[];
     purgeExpired(queue: string, now?: number): number;

package/dist/domain/queue/shard/dlq.js

@@ -56,6 +56,9 @@ export class ShardDlq extends ShardDependencies {
     removeFromDlq(queue, jobId) {
         return this.dlqManager.remove(queue, jobId);
     }
+    removeAllFromDlq(queue, jobId) {
+        return this.dlqManager.removeAll(queue, jobId);
+    }
     getAutoRetryEntries(queue, now = Date.now()) {
         return this.dlqManager.getAutoRetryEntries(queue, now);
     }

package/dist/domain/queue/shard/keys.d.ts

@@ -15,4 +15,5 @@ export declare class ShardKeys extends ShardState {
     isGroupActive(queue: string, groupId: string): boolean;
     activateGroup(queue: string, groupId: string): void;
     releaseGroup(queue: string, groupId: string): void;
+    getGroupActiveCount(queue: string, groupId: string): number;
 }

package/dist/domain/queue/shard/keys.js

@@ -29,7 +29,7 @@ export class ShardKeys extends ShardState {
         return this.uniqueKeyManager.getMap();
     }
     isGroupActive(queue, groupId) {
-        return this.activeGroups.get(queue)?.has(groupId) ?? false;
+        return (this.activeGroupCounts.get(queue)?.get(groupId) ?? 0) > 0;
     }
     activateGroup(queue, groupId) {
         let groups = this.activeGroups.get(queue);
@@ -38,8 +38,31 @@ export class ShardKeys extends ShardState {
             this.activeGroups.set(queue, groups);
         }
         groups.add(groupId);
+        let counts = this.activeGroupCounts.get(queue);
+        if (!counts) {
+            counts = new Map();
+            this.activeGroupCounts.set(queue, counts);
+        }
+        counts.set(groupId, (counts.get(groupId) ?? 0) + 1);
     }
     releaseGroup(queue, groupId) {
-        this.activeGroups.get(queue)?.delete(groupId);
+        const counts = this.activeGroupCounts.get(queue);
+        const count = (counts?.get(groupId) ?? 0) - 1;
+        if (count > 0) {
+            counts?.set(groupId, count);
+        }
+        else {
+            counts?.delete(groupId);
+            const groups = this.activeGroups.get(queue);
+            groups?.delete(groupId);
+            if (groups?.size === 0)
+                this.activeGroups.delete(queue);
+        }
+        if (counts?.size === 0)
+            this.activeGroupCounts.delete(queue);
+        this.notify(queue);
+    }
+    getGroupActiveCount(queue, groupId) {
+        return this.activeGroupCounts.get(queue)?.get(groupId) ?? 0;
     }
 }

package/dist/domain/queue/shard/lifecycle.js

@@ -12,6 +12,7 @@ export class ShardLifecycle extends ShardMetrics {
             this.temporalManager.removeDelayed(job.id);
         }
         priorityQueue.clear();
+        this.groupScheduler.clearQueue(queue);
         this.temporalManager.clearIndexForQueue(queue);
         this.counters.adjustQueued(-count);
         this.counters.syncDelayedCount();
@@ -37,7 +38,10 @@ export class ShardLifecycle extends ShardMetrics {
         this.queues.delete(queue);
         this.uniqueKeyManager.clearQueue(queue);
         this.limiterManager.deleteQueue(queue);
+        this.groupScheduler.clearQueue(queue);
+        this.groupLimiterManager.clearQueue(queue);
         this.activeGroups.delete(queue);
+        this.activeGroupCounts.delete(queue);
         return Array.from(removed);
     }
 }