bunqueue 2.0.1 → 2.0.3

package/dist/client/queue/queue.js

@@ -2,12 +2,22 @@
  * Queue
  * BullMQ-style queue for job management
  */
-import { getSharedManager } from '../manager';
 import { TcpConnectionPool, getSharedPool, releaseSharedPool } from '../tcpPool';
-import { toPublicJob } from '../types';
-import { jobId } from '../../domain/types/job';
 import { FORCE_EMBEDDED } from './helpers';
-import * as dlqOps from './dlqOps';
+// Import operation modules
+import * as addOps from './operations/add';
+import * as queryOps from './operations/query';
+import * as countsOps from './operations/counts';
+import * as controlOps from './operations/control';
+import * as managementOps from './operations/management';
+import * as stallOps from './stall';
+import * as dlqOps from './dlq';
+import * as rateLimitOps from './rateLimit';
+import * as schedulerOps from './scheduler';
+import * as deduplicationOps from './deduplication';
+import * as jobMoveOps from './jobMove';
+import * as workersOps from './workers';
+import * as bullmqCompatOps from './bullmqCompat';
 /**
  * Queue class for adding and managing jobs
  */
@@ -43,1477 +53,368 @@ export class Queue {
             }
         }
     }
-    get tcp() {
-        if (!this.tcpPool)
-            throw new Error('No TCP connection available');
-        return this.tcpPool;
-    }
-    /** Add a job to the queue */
-    async add(name, data, opts = {}) {
-        const merged = { ...this.opts.defaultJobOptions, ...opts };
-        // Add parent info to data if specified (BullMQ v5 flow support)
-        const jobData = { name, ...data };
-        if (merged.parent) {
-            jobData.__parentId = merged.parent.id;
-            jobData.__parentQueue = merged.parent.queue;
-        }
-        if (this.embedded) {
-            const manager = getSharedManager();
-            // Parse removeOnComplete/removeOnFail (can be boolean, number, or KeepJobs)
-            const removeOnComplete = typeof merged.removeOnComplete === 'boolean' ? merged.removeOnComplete : false;
-            const removeOnFail = typeof merged.removeOnFail === 'boolean' ? merged.removeOnFail : false;
-            // Parse repeat options with extended BullMQ v5 fields
-            const repeat = merged.repeat
-                ? {
-                    every: merged.repeat.every,
-                    limit: merged.repeat.limit,
-                    pattern: merged.repeat.pattern,
-                    count: merged.repeat.count,
-                    startDate: merged.repeat.startDate instanceof Date
-                        ? merged.repeat.startDate.getTime()
-                        : typeof merged.repeat.startDate === 'string'
-                            ? new Date(merged.repeat.startDate).getTime()
-                            : merged.repeat.startDate,
-                    endDate: merged.repeat.endDate instanceof Date
-                        ? merged.repeat.endDate.getTime()
-                        : typeof merged.repeat.endDate === 'string'
-                            ? new Date(merged.repeat.endDate).getTime()
-                            : merged.repeat.endDate,
-                    tz: merged.repeat.tz,
-                    immediately: merged.repeat.immediately,
-                    prevMillis: merged.repeat.prevMillis,
-                    offset: merged.repeat.offset,
-                    jobId: merged.repeat.jobId,
-                }
-                : undefined;
-            const job = await manager.push(this.name, {
-                data: jobData,
-                priority: merged.priority,
-                delay: merged.delay,
-                maxAttempts: merged.attempts,
-                backoff: merged.backoff,
-                timeout: merged.timeout,
-                customId: merged.jobId ?? merged.deduplication?.id,
-                removeOnComplete,
-                removeOnFail,
-                repeat,
-                stallTimeout: merged.stallTimeout,
-                durable: merged.durable,
-                parentId: merged.parent ? jobId(merged.parent.id) : undefined,
-                // BullMQ v5 options
-                lifo: merged.lifo,
-                stackTraceLimit: merged.stackTraceLimit,
-                keepLogs: merged.keepLogs,
-                sizeLimit: merged.sizeLimit,
-                failParentOnFailure: merged.failParentOnFailure,
-                removeDependencyOnFailure: merged.removeDependencyOnFailure,
-                dedup: merged.deduplication ? { ttl: merged.deduplication.ttl } : undefined,
-                debounceId: merged.debounce?.id,
-                debounceTtl: merged.debounce?.ttl,
-            });
-            return toPublicJob({
-                job,
-                name,
-                getState: (jid) => this.getJobState(jid),
-                remove: (jid) => this.removeAsync(jid),
-                retry: (jid) => this.retryJob(jid),
-                getChildrenValues: (jid) => this.getChildrenValues(jid),
-                updateData: (jid, data) => this.updateJobData(jid, data),
-                promote: (jid) => this.promoteJob(jid),
-                changeDelay: (jid, delay) => this.changeJobDelay(jid, delay),
-                changePriority: (jid, opts) => this.changeJobPriority(jid, opts),
-                extendLock: (jid, token, duration) => this.extendJobLock(jid, token, duration),
-                clearLogs: (jid, keepLogs) => this.clearJobLogs(jid, keepLogs),
-                getDependencies: (jid, opts) => this.getJobDependencies(jid, opts),
-                getDependenciesCount: (jid, opts) => this.getJobDependenciesCount(jid, opts),
-                moveToCompleted: (jid, result, token) => this.moveJobToCompleted(jid, result, token),
-                moveToFailed: (jid, error, token) => this.moveJobToFailed(jid, error, token),
-                moveToWait: (jid, token) => this.moveJobToWait(jid, token),
-                moveToDelayed: (jid, timestamp, token) => this.moveJobToDelayed(jid, timestamp, token),
-                moveToWaitingChildren: (jid, token, opts) => this.moveJobToWaitingChildren(jid, token, opts),
-                waitUntilFinished: (jid, queueEvents, ttl) => this.waitJobUntilFinished(jid, queueEvents, ttl),
-            });
-        }
-        const response = await this.tcp.send({
-            cmd: 'PUSH',
-            queue: this.name,
-            data: jobData,
-            priority: merged.priority,
-            delay: merged.delay,
-            maxAttempts: merged.attempts,
-            backoff: merged.backoff,
-            timeout: merged.timeout,
-            jobId: merged.jobId,
-            removeOnComplete: merged.removeOnComplete,
-            removeOnFail: merged.removeOnFail,
-            stallTimeout: merged.stallTimeout,
-            durable: merged.durable,
-            repeat: merged.repeat,
-            parentId: merged.parent?.id,
-        });
-        if (!response.ok) {
-            throw new Error(response.error ?? 'Failed to add job');
-        }
-        const jobIdStr = response.id;
-        return this.createJobProxy(jobIdStr, name, data);
-    }
-    /** Add multiple jobs (batch optimized) */
-    async addBulk(jobs) {
-        if (jobs.length === 0)
-            return [];
-        const now = Date.now();
-        if (this.embedded) {
-            const manager = getSharedManager();
-            const inputs = jobs.map(({ name, data, opts }) => {
-                const m = { ...this.opts.defaultJobOptions, ...opts };
-                // Parse removeOnComplete/removeOnFail (can be boolean, number, or KeepJobs)
-                const removeOnComplete = typeof m.removeOnComplete === 'boolean' ? m.removeOnComplete : false;
-                const removeOnFail = typeof m.removeOnFail === 'boolean' ? m.removeOnFail : false;
-                return {
-                    data: { name, ...data },
-                    priority: m.priority,
-                    delay: m.delay,
-                    maxAttempts: m.attempts,
-                    backoff: m.backoff,
-                    timeout: m.timeout,
-                    customId: m.jobId,
-                    removeOnComplete,
-                    removeOnFail,
-                    repeat: m.repeat
-                        ? {
-                            every: m.repeat.every,
-                            limit: m.repeat.limit,
-                            pattern: m.repeat.pattern,
-                            count: m.repeat.count,
-                            startDate: m.repeat.startDate instanceof Date
-                                ? m.repeat.startDate.getTime()
-                                : typeof m.repeat.startDate === 'string'
-                                    ? new Date(m.repeat.startDate).getTime()
-                                    : m.repeat.startDate,
-                            endDate: m.repeat.endDate instanceof Date
-                                ? m.repeat.endDate.getTime()
-                                : typeof m.repeat.endDate === 'string'
-                                    ? new Date(m.repeat.endDate).getTime()
-                                    : m.repeat.endDate,
-                            tz: m.repeat.tz,
-                            immediately: m.repeat.immediately,
-                            prevMillis: m.repeat.prevMillis,
-                            offset: m.repeat.offset,
-                            jobId: m.repeat.jobId,
-                        }
-                        : undefined,
-                    stallTimeout: m.stallTimeout,
-                    durable: m.durable,
-                    // BullMQ v5 options
-                    lifo: m.lifo,
-                    stackTraceLimit: m.stackTraceLimit,
-                    keepLogs: m.keepLogs,
-                    sizeLimit: m.sizeLimit,
-                    failParentOnFailure: m.failParentOnFailure,
-                    removeDependencyOnFailure: m.removeDependencyOnFailure,
-                    dedup: m.deduplication ? { ttl: m.deduplication.ttl } : undefined,
-                    debounceId: m.debounce?.id,
-                    debounceTtl: m.debounce?.ttl,
-                };
-            });
-            const ids = await manager.pushBatch(this.name, inputs);
-            return ids.map((id, i) => this.createSimpleJob(String(id), jobs[i].name, jobs[i].data, now));
-        }
-        const jobInputs = jobs.map(({ name, data, opts }) => {
-            const m = { ...this.opts.defaultJobOptions, ...opts };
-            return {
-                data: { name, ...data },
-                priority: m.priority,
-                delay: m.delay,
-                maxAttempts: m.attempts,
-                backoff: m.backoff,
-                timeout: m.timeout,
-                customId: m.jobId,
-                removeOnComplete: m.removeOnComplete,
-                removeOnFail: m.removeOnFail,
-                stallTimeout: m.stallTimeout,
-                repeat: m.repeat,
-                durable: m.durable,
-            };
-        });
-        const response = await this.tcp.send({ cmd: 'PUSHB', queue: this.name, jobs: jobInputs });
-        if (!response.ok) {
-            throw new Error(response.error ?? 'Failed to add jobs');
-        }
-        const ids = response.ids;
-        return ids.map((id, i) => this.createSimpleJob(id, jobs[i].name, jobs[i].data, now));
+    // Context builders for modules
+    get ctx() {
+        return { name: this.name, embedded: this.embedded, tcp: this.tcpPool };
     }
-    /** Get a job by ID */
-    async getJob(id) {
-        if (this.embedded) {
-            const manager = getSharedManager();
-            const job = await manager.getJob(jobId(id));
-            if (!job)
-                return null;
-            const jobData = job.data;
-            return toPublicJob({
-                job,
-                name: jobData?.name ?? 'default',
-                getState: (jid) => this.getJobState(jid),
-                remove: (jid) => this.removeAsync(jid),
-                retry: (jid) => this.retryJob(jid),
-                getChildrenValues: (jid) => this.getChildrenValues(jid),
-                updateData: (jid, data) => this.updateJobData(jid, data),
-                promote: (jid) => this.promoteJob(jid),
-                changeDelay: (jid, delay) => this.changeJobDelay(jid, delay),
-                changePriority: (jid, opts) => this.changeJobPriority(jid, opts),
-                extendLock: (jid, token, duration) => this.extendJobLock(jid, token, duration),
-                clearLogs: (jid, keepLogs) => this.clearJobLogs(jid, keepLogs),
-                getDependencies: (jid, opts) => this.getJobDependencies(jid, opts),
-                getDependenciesCount: (jid, opts) => this.getJobDependenciesCount(jid, opts),
-                moveToCompleted: (jid, result, token) => this.moveJobToCompleted(jid, result, token),
-                moveToFailed: (jid, error, token) => this.moveJobToFailed(jid, error, token),
-                moveToWait: (jid, token) => this.moveJobToWait(jid, token),
-                moveToDelayed: (jid, timestamp, token) => this.moveJobToDelayed(jid, timestamp, token),
-                moveToWaitingChildren: (jid, token, opts) => this.moveJobToWaitingChildren(jid, token, opts),
-                waitUntilFinished: (jid, queueEvents, ttl) => this.waitJobUntilFinished(jid, queueEvents, ttl),
-            });
-        }
-        const response = await this.tcp.send({ cmd: 'GetJob', id });
-        if (!response.ok || !response.job)
-            return null;
-        const jobData = response.job;
-        const data = jobData.data;
-        const jobIdStr = String(jobData.id);
-        const ts = jobData.createdAt ?? Date.now();
-        const runAt = jobData.runAt ?? ts;
+    get addCtx() {
         return {
-            id: jobIdStr,
-            name: data?.name ?? 'default',
-            data: jobData.data,
-            queueName: this.name,
-            attemptsMade: jobData.attempts ?? 0,
-            timestamp: ts,
-            progress: jobData.progress ?? 0,
-            // BullMQ v5 properties
-            delay: runAt > ts ? runAt - ts : 0,
-            processedOn: jobData.startedAt ?? undefined,
-            finishedOn: jobData.completedAt ?? undefined,
-            stacktrace: null,
-            stalledCounter: jobData.stallCount ?? 0,
-            priority: jobData.priority ?? 0,
-            parentKey: undefined,
-            opts: {},
-            token: undefined,
-            processedBy: undefined,
-            deduplicationId: jobData.customId ?? undefined,
-            repeatJobKey: undefined,
-            attemptsStarted: jobData.attempts ?? 0,
-            // Methods
-            updateProgress: async () => { },
-            log: async () => { },
-            getState: () => this.getJobState(jobIdStr),
-            remove: () => this.removeAsync(jobIdStr),
-            retry: () => this.retryJob(jobIdStr),
-            getChildrenValues: () => this.getChildrenValues(jobIdStr),
-            // BullMQ v5 state check methods
-            isWaiting: async () => (await this.getJobState(jobIdStr)) === 'waiting',
-            isActive: async () => (await this.getJobState(jobIdStr)) === 'active',
-            isDelayed: async () => (await this.getJobState(jobIdStr)) === 'delayed',
-            isCompleted: async () => (await this.getJobState(jobIdStr)) === 'completed',
-            isFailed: async () => (await this.getJobState(jobIdStr)) === 'failed',
-            isWaitingChildren: () => Promise.resolve(false),
-            // BullMQ v5 mutation methods
-            updateData: async () => { },
-            promote: async () => { },
-            changeDelay: async () => { },
-            changePriority: async () => { },
-            extendLock: () => Promise.resolve(0),
-            clearLogs: async () => { },
-            // BullMQ v5 dependency methods
-            getDependencies: () => Promise.resolve({ processed: {}, unprocessed: [] }),
-            getDependenciesCount: () => Promise.resolve({ processed: 0, unprocessed: 0 }),
-            // BullMQ v5 serialization methods
-            toJSON: () => ({
-                id: jobIdStr,
-                name: data?.name ?? 'default',
-                data: jobData.data,
-                opts: {},
-                progress: jobData.progress ?? 0,
-                delay: runAt > ts ? runAt - ts : 0,
-                timestamp: ts,
-                attemptsMade: jobData.attempts ?? 0,
-                stacktrace: null,
-                queueQualifiedName: `bull:${this.name}`,
-            }),
-            asJSON: () => ({
-                id: jobIdStr,
-                name: data?.name ?? 'default',
-                data: JSON.stringify(jobData.data),
-                opts: '{}',
-                progress: String(jobData.progress ?? 0),
-                delay: String(runAt > ts ? runAt - ts : 0),
-                timestamp: String(ts),
-                attemptsMade: String(jobData.attempts ?? 0),
-                stacktrace: null,
-            }),
-            // BullMQ v5 move methods
-            moveToCompleted: () => Promise.resolve(null),
-            moveToFailed: () => Promise.resolve(),
-            moveToWait: () => Promise.resolve(false),
-            moveToDelayed: () => Promise.resolve(),
-            moveToWaitingChildren: () => Promise.resolve(false),
-            waitUntilFinished: () => Promise.resolve(undefined),
-            // BullMQ v5 additional methods
-            discard: () => { },
-            getFailedChildrenValues: () => Promise.resolve({}),
-            getIgnoredChildrenFailures: () => Promise.resolve({}),
-            removeChildDependency: () => Promise.resolve(false),
-            removeDeduplicationKey: () => Promise.resolve(false),
-            removeUnprocessedChildren: () => Promise.resolve(),
+            ...this.ctx,
+            opts: this.opts,
+            getJobState: (id) => this.getJobState(id),
+            removeAsync: (id) => this.removeAsync(id),
+            retryJob: (id) => this.retryJob(id),
+            getChildrenValues: (id) => this.getChildrenValues(id),
+            updateJobData: (id, data) => this.updateJobData(id, data),
+            promoteJob: (id) => this.promoteJob(id),
+            changeJobDelay: (id, delay) => this.changeJobDelay(id, delay),
+            changeJobPriority: (id, opts) => this.changeJobPriority(id, opts),
+            extendJobLock: (id, token, dur) => this.extendJobLock(id, token, dur),
+            clearJobLogs: (id, keep) => this.clearJobLogs(id, keep),
+            getJobDependencies: (id, o) => this.getJobDependencies(id, o),
+            getJobDependenciesCount: (id, o) => this.getJobDependenciesCount(id, o),
+            moveJobToCompleted: (id, r, t) => this.moveJobToCompleted(id, r, t),
+            moveJobToFailed: (id, e, t) => this.moveJobToFailed(id, e, t),
+            moveJobToWait: (id, t) => this.moveJobToWait(id, t),
+            moveJobToDelayed: (id, ts, t) => this.moveJobToDelayed(id, ts, t),
+            moveJobToWaitingChildren: (id, t, o) => this.moveJobToWaitingChildren(id, t, o),
+            waitJobUntilFinished: (id, qe, ttl) => this.waitJobUntilFinished(id, qe, ttl),
         };
     }
-    /** Remove a job by ID */
-    remove(id) {
-        if (this.embedded)
-            void getSharedManager().cancel(jobId(id));
-        else
-            void this.tcp.send({ cmd: 'Cancel', id });
+    get queryCtx() {
+        return {
+            ...this.ctx,
+            getJobState: (id) => this.getJobState(id),
+            removeAsync: (id) => this.removeAsync(id),
+            retryJob: (id) => this.retryJob(id),
+            getChildrenValues: (id) => this.getChildrenValues(id),
+            // Extended context for toPublicJob (full opts support)
+            updateJobData: (id, data) => this.updateJobData(id, data),
+            promoteJob: (id) => this.promoteJob(id),
+            changeJobDelay: (id, delay) => this.changeJobDelay(id, delay),
+            changeJobPriority: (id, opts) => this.changeJobPriority(id, opts),
+            extendJobLock: (id, token, dur) => this.extendJobLock(id, token, dur),
+            clearJobLogs: (id, keep) => this.clearJobLogs(id, keep),
+            getJobDependencies: (id, o) => this.getJobDependencies(id, o),
+            getJobDependenciesCount: (id, o) => this.getJobDependenciesCount(id, o),
+        };
     }
-    /** Remove a job by ID (async) */
-    async removeAsync(id) {
-        if (this.embedded) {
-            await getSharedManager().cancel(jobId(id));
-        }
-        else {
-            await this.tcp.send({ cmd: 'Cancel', id });
-        }
+    get moveCtx() {
+        return {
+            ...this.ctx,
+            getJobState: (id) => this.getJobState(id),
+            getJobDependencies: (id) => this.getJobDependencies(id),
+        };
     }
-    /** Retry a job by ID */
-    async retryJob(id) {
-        if (this.embedded) {
-            // For embedded mode, we need to implement retry in QueueManager
-            // For now, just get the job and re-add it
-            const manager = getSharedManager();
-            const job = await manager.getJob(jobId(id));
-            if (job) {
-                await manager.push(job.queue, { data: job.data, priority: job.priority });
-            }
-        }
-        else {
-            await this.tcp.send({ cmd: 'RetryJob', id });
-        }
+    // ============ Add Operations ============
+    add(name, data, opts) {
+        return addOps.add(this.addCtx, name, data, opts);
+    }
+    addBulk(jobs) {
+        return addOps.addBulk(this.addCtx, jobs);
+    }
+    // ============ Query Operations ============
+    getJob(id) {
+        return queryOps.getJob(this.queryCtx, id);
+    }
+    getJobState(id) {
+        return queryOps.getJobState(this.queryCtx, id);
     }
-    /**
-     * Get the return values of all children jobs (BullMQ v5 compatible).
-     * Returns a Record where keys are job keys (queueName:jobId) and values are return values.
-     */
     getChildrenValues(id) {
-        if (this.embedded) {
-            const manager = getSharedManager();
-            return manager.getChildrenValues(jobId(id));
-        }
-        // TCP mode - would need server-side support
-        // For now, return empty object
-        return Promise.resolve({});
+        return queryOps.getChildrenValues(this.queryCtx, id);
     }
-    /** Get job state by ID (async, works with both embedded and TCP) */
-    async getJobState(id) {
-        if (this.embedded) {
-            const manager = getSharedManager();
-            const state = await manager.getJobState(jobId(id));
-            return state;
-        }
-        const response = await this.tcp.send({ cmd: 'GetState', id });
-        if (!response.ok)
-            return 'unknown';
-        return response.state;
+    getJobs(opts) {
+        return queryOps.getJobs(this.queryCtx, opts);
+    }
+    getJobsAsync(opts) {
+        return queryOps.getJobsAsync(this.queryCtx, opts);
+    }
+    getWaiting(start, end) {
+        return queryOps.getWaiting(this.queryCtx, start, end);
+    }
+    getWaitingAsync(start, end) {
+        return queryOps.getWaitingAsync(this.queryCtx, start, end);
+    }
+    getDelayed(start, end) {
+        return queryOps.getDelayed(this.queryCtx, start, end);
+    }
+    getDelayedAsync(start, end) {
+        return queryOps.getDelayedAsync(this.queryCtx, start, end);
+    }
+    getActive(start, end) {
+        return queryOps.getActive(this.queryCtx, start, end);
+    }
+    getActiveAsync(start, end) {
+        return queryOps.getActiveAsync(this.queryCtx, start, end);
     }
-    /** Get job counts by state */
+    getCompleted(start, end) {
+        return queryOps.getCompleted(this.queryCtx, start, end);
+    }
+    getCompletedAsync(start, end) {
+        return queryOps.getCompletedAsync(this.queryCtx, start, end);
+    }
+    getFailed(start, end) {
+        return queryOps.getFailed(this.queryCtx, start, end);
+    }
+    getFailedAsync(start, end) {
+        return queryOps.getFailedAsync(this.queryCtx, start, end);
+    }
+    // ============ Count Operations ============
     getJobCounts() {
-        if (this.embedded) {
-            const s = getSharedManager().getStats();
-            return { waiting: s.waiting, active: s.active, completed: s.completed, failed: s.dlq };
-        }
-        return { waiting: 0, active: 0, completed: 0, failed: 0 };
-    }
-    /** Get job counts (async, works with TCP) */
-    async getJobCountsAsync() {
-        if (this.embedded)
-            return this.getJobCounts();
-        const response = await this.tcp.send({ cmd: 'Stats' });
-        if (!response.ok)
-            return { waiting: 0, active: 0, completed: 0, failed: 0 };
-        const s = response.stats;
-        return {
-            waiting: s?.queued ?? 0,
-            active: s?.processing ?? 0,
-            completed: s?.completed ?? 0,
-            failed: s?.dlq ?? 0,
-        };
+        return countsOps.getJobCounts(this.ctx);
+    }
+    getJobCountsAsync() {
+        return countsOps.getJobCountsAsync(this.ctx);
+    }
+    getWaitingCount() {
+        return countsOps.getWaitingCount(this.ctx);
+    }
+    getActiveCount() {
+        return countsOps.getActiveCount(this.ctx);
+    }
+    getCompletedCount() {
+        return countsOps.getCompletedCount(this.ctx);
+    }
+    getFailedCount() {
+        return countsOps.getFailedCount(this.ctx);
+    }
+    getDelayedCount() {
+        return countsOps.getDelayedCount(this.ctx);
+    }
+    count() {
+        return countsOps.count(this.ctx);
+    }
+    countAsync() {
+        return countsOps.countAsync(this.ctx);
     }
-    /** Get job counts grouped by priority */
     getCountsPerPriority() {
-        if (this.embedded) {
-            return getSharedManager().getCountsPerPriority(this.name);
-        }
-        // TCP mode returns empty for sync - use getCountsPerPriorityAsync
-        return {};
-    }
-    /** Get job counts grouped by priority (async, works with TCP) */
-    async getCountsPerPriorityAsync() {
-        if (this.embedded)
-            return this.getCountsPerPriority();
-        const response = await this.tcp.send({ cmd: 'GetCountsPerPriority', queue: this.name });
-        if (!response.ok)
-            return {};
-        return response.counts ?? {};
+        return countsOps.getCountsPerPriority(this.ctx);
     }
+    getCountsPerPriorityAsync() {
+        return countsOps.getCountsPerPriorityAsync(this.ctx);
+    }
+    // ============ Control Operations ============
     pause() {
-        if (this.embedded)
-            getSharedManager().pause(this.name);
-        else
-            void this.tcp.send({ cmd: 'Pause', queue: this.name });
+        controlOps.pause(this.ctx);
     }
     resume() {
-        if (this.embedded)
-            getSharedManager().resume(this.name);
-        else
-            void this.tcp.send({ cmd: 'Resume', queue: this.name });
+        controlOps.resume(this.ctx);
     }
     drain() {
-        if (this.embedded)
-            getSharedManager().drain(this.name);
-        else
-            void this.tcp.send({ cmd: 'Drain', queue: this.name });
+        controlOps.drain(this.ctx);
     }
     obliterate() {
-        if (this.embedded)
-            getSharedManager().obliterate(this.name);
-        else
-            void this.tcp.send({ cmd: 'Obliterate', queue: this.name });
+        controlOps.obliterate(this.ctx);
     }
-    /** Check if queue is paused */
     isPaused() {
-        if (this.embedded) {
-            return getSharedManager().isPaused(this.name);
-        }
-        return false;
-    }
-    /** Check if queue is paused (async, works with TCP) */
-    async isPausedAsync() {
-        if (this.embedded)
-            return this.isPaused();
-        const response = await this.tcp.send({ cmd: 'IsPaused', queue: this.name });
-        if (!response.ok)
-            return false;
-        return response.paused === true;
-    }
-    /** Count jobs awaiting processing */
-    count() {
-        if (this.embedded) {
-            return getSharedManager().count(this.name);
-        }
-        return 0;
-    }
-    /** Count jobs awaiting processing (async, works with TCP) */
-    async countAsync() {
-        if (this.embedded)
-            return this.count();
-        const response = await this.tcp.send({ cmd: 'Count', queue: this.name });
-        if (!response.ok)
-            return 0;
-        return response.count ?? 0;
-    }
-    /** Get active jobs */
-    getActive(start = 0, end = 100) {
-        return this.getJobs({ state: 'active', start, end });
-    }
-    /** Get active jobs (async) */
-    async getActiveAsync(start = 0, end = 100) {
-        return this.getJobsAsync({ state: 'active', start, end });
-    }
-    /** Get completed jobs */
-    getCompleted(start = 0, end = 100) {
-        return this.getJobs({ state: 'completed', start, end });
-    }
-    /** Get completed jobs (async) */
-    async getCompletedAsync(start = 0, end = 100) {
-        return this.getJobsAsync({ state: 'completed', start, end });
-    }
-    /** Get failed jobs */
-    getFailed(start = 0, end = 100) {
-        return this.getJobs({ state: 'failed', start, end });
-    }
-    /** Get failed jobs (async) */
-    async getFailedAsync(start = 0, end = 100) {
-        return this.getJobsAsync({ state: 'failed', start, end });
-    }
-    /** Get delayed jobs */
-    getDelayed(start = 0, end = 100) {
-        return this.getJobs({ state: 'delayed', start, end });
-    }
-    /** Get delayed jobs (async) */
-    async getDelayedAsync(start = 0, end = 100) {
-        return this.getJobsAsync({ state: 'delayed', start, end });
-    }
-    /** Get waiting jobs */
-    getWaiting(start = 0, end = 100) {
-        return this.getJobs({ state: 'waiting', start, end });
-    }
-    /** Get waiting jobs (async) */
-    async getWaitingAsync(start = 0, end = 100) {
-        return this.getJobsAsync({ state: 'waiting', start, end });
-    }
-    /** Get active job count */
-    async getActiveCount() {
-        const counts = await this.getJobCountsAsync();
-        return counts.active;
-    }
-    /** Get completed job count */
-    async getCompletedCount() {
-        const counts = await this.getJobCountsAsync();
-        return counts.completed;
-    }
-    /** Get failed job count */
-    async getFailedCount() {
-        const counts = await this.getJobCountsAsync();
-        return counts.failed;
-    }
-    /** Get delayed job count */
-    async getDelayedCount() {
-        if (this.embedded) {
-            const stats = getSharedManager().getStats();
-            return stats.delayed;
-        }
-        const response = await this.tcp.send({ cmd: 'Stats' });
-        if (!response.ok)
-            return 0;
-        return response.stats?.delayed ?? 0;
+        return controlOps.isPaused(this.ctx);
+    }
+    isPausedAsync() {
+        return controlOps.isPausedAsync(this.ctx);
     }
-    /** Get waiting job count */
-    async getWaitingCount() {
-        const counts = await this.getJobCountsAsync();
-        return counts.waiting;
+    waitUntilReady() {
+        return controlOps.waitUntilReady(this.ctx);
+    }
+    // ============ Management Operations ============
+    remove(id) {
+        managementOps.remove(this.ctx, id);
+    }
+    removeAsync(id) {
+        return managementOps.removeAsync(this.ctx, id);
+    }
+    retryJob(id) {
+        return managementOps.retryJob(this.ctx, id);
+    }
+    retryJobs(opts) {
+        return managementOps.retryJobs(this.ctx, opts);
     }
-    /** Clean old jobs from the queue */
     clean(grace, limit, type) {
-        if (this.embedded) {
-            const count = getSharedManager().clean(this.name, grace, type, limit);
-            // Return empty array for now - would need to track removed IDs
-            return new Array(count).fill('');
-        }
-        return [];
-    }
-    /** Clean old jobs from the queue (async, works with TCP) */
-    async cleanAsync(grace, limit, type) {
-        if (this.embedded)
-            return this.clean(grace, limit, type);
-        const response = await this.tcp.send({
-            cmd: 'Clean',
-            queue: this.name,
-            grace,
-            limit,
-            type,
-        });
-        if (!response.ok)
-            return [];
-        return response.removed ?? [];
-    }
-    /** Retry failed jobs */
-    async retryJobs(opts) {
-        const state = opts?.state ?? 'failed';
-        const count = opts?.count ?? 100;
-        if (this.embedded) {
-            if (state === 'failed') {
-                return getSharedManager().retryDlq(this.name);
-            }
-            else {
-                return getSharedManager().retryCompleted(this.name);
-            }
-        }
-        const cmd = state === 'failed' ? 'RetryDlq' : 'RetryCompleted';
-        const response = await this.tcp.send({ cmd, queue: this.name, count });
-        if (!response.ok)
-            return 0;
-        return response.count ?? 0;
-    }
-    /** Promote delayed jobs to waiting */
-    async promoteJobs(opts) {
-        const count = opts?.count ?? 100;
-        if (this.embedded) {
-            // Get delayed jobs and promote them
-            const jobs = this.getJobs({ state: 'delayed', start: 0, end: count });
-            let promoted = 0;
-            for (const job of jobs) {
-                const success = await getSharedManager().promote(jobId(job.id));
-                if (success)
-                    promoted++;
-            }
-            return promoted;
-        }
-        const response = await this.tcp.send({ cmd: 'PromoteJobs', queue: this.name, count });
-        if (!response.ok)
-            return 0;
-        return response.count ?? 0;
+        return managementOps.clean(this.ctx, grace, limit, type);
     }
-    /** Get job logs */
-    async getJobLogs(id, start = 0, end = 100, _asc = true) {
-        if (this.embedded) {
-            const logs = getSharedManager().getLogs(jobId(id));
-            const logStrings = logs.slice(start, end).map((l) => `[${l.level}] ${l.message}`);
-            return { logs: logStrings, count: logs.length };
-        }
-        const response = await this.tcp.send({ cmd: 'GetLogs', id, start, end });
-        if (!response.ok)
-            return { logs: [], count: 0 };
-        const result = response;
-        const logStrings = (result.logs ?? []).map((l) => `[${l.level}] ${l.message}`);
-        return { logs: logStrings, count: result.count ?? 0 };
-    }
-    /** Add a log entry to a job */
-    async addJobLog(id, logRow, _keepLogs) {
-        if (this.embedded) {
-            const success = getSharedManager().addLog(jobId(id), logRow);
-            return success ? 1 : 0;
-        }
-        const response = await this.tcp.send({ cmd: 'AddLog', id, message: logRow });
-        return response.ok ? 1 : 0;
+    cleanAsync(grace, limit, type) {
+        return managementOps.cleanAsync(this.ctx, grace, limit, type);
     }
-    /** Update job progress */
-    async updateJobProgress(id, progress) {
-        const progressValue = typeof progress === 'number' ? progress : 0;
-        const message = typeof progress === 'object' ? JSON.stringify(progress) : undefined;
-        if (this.embedded) {
-            await getSharedManager().updateProgress(jobId(id), progressValue, message);
-            return;
-        }
-        await this.tcp.send({ cmd: 'Progress', id, progress: progressValue, message });
+    promoteJobs(opts) {
+        return managementOps.promoteJobs(this.ctx, opts);
     }
-    /** Set global concurrency limit for this queue */
-    setGlobalConcurrency(concurrency) {
-        if (this.embedded) {
-            getSharedManager().setConcurrency(this.name, concurrency);
-        }
-        else {
-            void this.tcp.send({ cmd: 'SetConcurrency', queue: this.name, limit: concurrency });
-        }
+    promoteJob(id) {
+        return managementOps.promoteJob(this.ctx, id);
     }
-    /** Remove global concurrency limit */
-    removeGlobalConcurrency() {
-        if (this.embedded) {
-            getSharedManager().clearConcurrency(this.name);
-        }
-        else {
-            void this.tcp.send({ cmd: 'ClearConcurrency', queue: this.name });
-        }
+    updateJobProgress(id, progress) {
+        return managementOps.updateJobProgress(this.ctx, id, progress);
     }
-    /** Get global concurrency limit */
-    getGlobalConcurrency() {
-        // This would need to be implemented in QueueManager
-        // For now, return null
-        return Promise.resolve(null);
+    getJobLogs(id, start, end, _asc) {
+        return managementOps.getJobLogs(this.ctx, id, start, end);
     }
-    /** Set global rate limit for this queue */
-    setGlobalRateLimit(max, _duration) {
-        if (this.embedded) {
-            getSharedManager().setRateLimit(this.name, max);
-        }
-        else {
-            void this.tcp.send({ cmd: 'RateLimit', queue: this.name, limit: max });
-        }
+    addJobLog(id, logRow, _keepLogs) {
+        return managementOps.addJobLog(this.ctx, id, logRow);
     }
-    /** Remove global rate limit */
-    removeGlobalRateLimit() {
-        if (this.embedded) {
-            getSharedManager().clearRateLimit(this.name);
-        }
-        else {
-            void this.tcp.send({ cmd: 'RateLimitClear', queue: this.name });
-        }
+    clearJobLogs(id, keepLogs) {
+        return managementOps.clearJobLogs(this.ctx, id, keepLogs);
     }
-    /** Get global rate limit */
-    getGlobalRateLimit() {
-        // This would need to be implemented in QueueManager
-        // For now, return null
-        return Promise.resolve(null);
+    updateJobData(id, data) {
+        return managementOps.updateJobData(this.ctx, id, data);
     }
-    /** Get metrics for this queue */
-    async getMetrics(type, _start, _end) {
-        if (this.embedded) {
-            const stats = getSharedManager().getStats();
-            const count = type === 'completed' ? stats.completed : stats.dlq;
-            return { meta: { count }, data: [] };
-        }
-        const response = await this.tcp.send({ cmd: 'Metrics' });
-        if (!response.ok)
-            return { meta: { count: 0 }, data: [] };
-        const stats = response.stats;
-        const count = type === 'completed' ? (stats?.completed ?? 0) : (stats?.dlq ?? 0);
-        return { meta: { count }, data: [] };
-    }
-    /** Get workers processing this queue */
-    async getWorkers() {
-        if (this.embedded) {
-            // Would need to implement worker tracking
-            return [];
-        }
-        const response = await this.tcp.send({ cmd: 'ListWorkers' });
-        if (!response.ok)
-            return [];
-        return (response.workers ?? []);
-    }
-    /** Get worker count */
-    async getWorkersCount() {
-        const workers = await this.getWorkers();
-        return workers.length;
-    }
-    /** Get jobs with filtering and pagination */
-    getJobs(options = {}) {
-        if (this.embedded) {
-            const jobs = getSharedManager().getJobs(this.name, options);
-            return jobs.map((job) => {
-                const jobData = job.data;
-                return toPublicJob({
-                    job,
-                    name: jobData?.name ?? 'default',
-                    getState: (jid) => this.getJobState(jid),
-                    remove: (jid) => this.removeAsync(jid),
-                    retry: (jid) => this.retryJob(jid),
-                    getChildrenValues: (jid) => this.getChildrenValues(jid),
-                    updateData: (jid, data) => this.updateJobData(jid, data),
-                    promote: (jid) => this.promoteJob(jid),
-                    changeDelay: (jid, delay) => this.changeJobDelay(jid, delay),
-                    changePriority: (jid, opts) => this.changeJobPriority(jid, opts),
-                    extendLock: (jid, token, duration) => this.extendJobLock(jid, token, duration),
-                    clearLogs: (jid, keepLogs) => this.clearJobLogs(jid, keepLogs),
-                    getDependencies: (jid, opts) => this.getJobDependencies(jid, opts),
-                    getDependenciesCount: (jid, opts) => this.getJobDependenciesCount(jid, opts),
-                    moveToCompleted: (jid, result, token) => this.moveJobToCompleted(jid, result, token),
-                    moveToFailed: (jid, error, token) => this.moveJobToFailed(jid, error, token),
-                    moveToWait: (jid, token) => this.moveJobToWait(jid, token),
-                    moveToDelayed: (jid, timestamp, token) => this.moveJobToDelayed(jid, timestamp, token),
-                    moveToWaitingChildren: (jid, token, opts) => this.moveJobToWaitingChildren(jid, token, opts),
-                    waitUntilFinished: (jid, queueEvents, ttl) => this.waitJobUntilFinished(jid, queueEvents, ttl),
-                });
-            });
-        }
-        // Sync TCP version returns empty - use getJobsAsync
-        return [];
-    }
-    /** Get jobs with filtering and pagination (async, works with TCP) */
-    async getJobsAsync(options = {}) {
-        if (this.embedded)
-            return this.getJobs(options);
-        const response = await this.tcp.send({
-            cmd: 'GetJobs',
-            queue: this.name,
-            state: options.state,
-            offset: options.start ?? 0,
-            limit: (options.end ?? 100) - (options.start ?? 0),
-        });
-        if (!response.ok || !Array.isArray(response.jobs)) {
-            return [];
-        }
-        const jobs = response.jobs;
-        return jobs.map((j) => {
-            const jobData = j.data;
-            const jobName = jobData?.name ?? 'default';
-            return {
-                id: j.id,
-                name: jobName,
-                data: j.data,
-                queueName: j.queue,
-                attemptsMade: j.attempts,
-                timestamp: j.createdAt,
-                progress: j.progress ?? 0,
-                // BullMQ v5 properties
-                delay: 0,
-                processedOn: undefined,
-                finishedOn: undefined,
-                stacktrace: null,
-                stalledCounter: 0,
-                priority: j.priority,
-                parentKey: undefined,
-                opts: {},
-                token: undefined,
-                processedBy: undefined,
-                deduplicationId: undefined,
-                repeatJobKey: undefined,
-                attemptsStarted: j.attempts,
-                // Methods
-                updateProgress: async () => { },
-                log: async () => { },
-                getState: () => this.getJobState(j.id),
-                remove: () => this.removeAsync(j.id),
-                retry: () => this.retryJob(j.id),
-                getChildrenValues: () => this.getChildrenValues(j.id),
-                // BullMQ v5 state check methods
-                isWaiting: async () => (await this.getJobState(j.id)) === 'waiting',
-                isActive: async () => (await this.getJobState(j.id)) === 'active',
-                isDelayed: async () => (await this.getJobState(j.id)) === 'delayed',
-                isCompleted: async () => (await this.getJobState(j.id)) === 'completed',
-                isFailed: async () => (await this.getJobState(j.id)) === 'failed',
-                isWaitingChildren: () => Promise.resolve(false),
-                // BullMQ v5 mutation methods
-                updateData: async () => { },
-                promote: async () => { },
-                changeDelay: async () => { },
-                changePriority: async () => { },
-                extendLock: () => Promise.resolve(0),
-                clearLogs: async () => { },
-                // BullMQ v5 dependency methods
-                getDependencies: () => Promise.resolve({ processed: {}, unprocessed: [] }),
-                getDependenciesCount: () => Promise.resolve({ processed: 0, unprocessed: 0 }),
-                // BullMQ v5 serialization methods
-                toJSON: () => ({
-                    id: j.id,
-                    name: jobName,
-                    data: j.data,
-                    opts: {},
-                    progress: j.progress ?? 0,
-                    delay: 0,
-                    timestamp: j.createdAt,
-                    attemptsMade: j.attempts,
-                    stacktrace: null,
-                    queueQualifiedName: `bull:${j.queue}`,
-                }),
-                asJSON: () => ({
-                    id: j.id,
-                    name: jobName,
-                    data: JSON.stringify(j.data),
-                    opts: '{}',
-                    progress: String(j.progress ?? 0),
-                    delay: '0',
-                    timestamp: String(j.createdAt),
-                    attemptsMade: String(j.attempts),
-                    stacktrace: null,
-                }),
-                // BullMQ v5 move methods
-                moveToCompleted: () => Promise.resolve(null),
-                moveToFailed: () => Promise.resolve(),
-                moveToWait: () => Promise.resolve(false),
-                moveToDelayed: () => Promise.resolve(),
-                moveToWaitingChildren: () => Promise.resolve(false),
-                waitUntilFinished: () => Promise.resolve(undefined),
-                // BullMQ v5 additional methods
-                discard: () => { },
-                getFailedChildrenValues: () => Promise.resolve({}),
-                getIgnoredChildrenFailures: () => Promise.resolve({}),
-                removeChildDependency: () => Promise.resolve(false),
-                removeDeduplicationKey: () => Promise.resolve(false),
-                removeUnprocessedChildren: () => Promise.resolve(),
-            };
-        });
+    changeJobDelay(id, delay) {
+        return managementOps.changeJobDelay(this.ctx, id, delay);
+    }
+    changeJobPriority(id, opts) {
+        return managementOps.changeJobPriority(this.ctx, id, opts);
     }
-    // Stall Detection
+    extendJobLock(id, token, duration) {
+        return managementOps.extendJobLock(this.ctx, id, token, duration);
+    }
+    // ============ Stall Detection ============
     setStallConfig(config) {
-        if (!this.embedded) {
-            console.warn('setStallConfig: embedded only');
-            return;
-        }
-        dlqOps.setStallConfigEmbedded(this.name, config);
+        stallOps.setStallConfig(this.ctx, config);
     }
     getStallConfig() {
-        if (!this.embedded) {
-            return { enabled: true, stallInterval: 30000, maxStalls: 3, gracePeriod: 5000 };
-        }
-        return dlqOps.getStallConfigEmbedded(this.name);
+        return stallOps.getStallConfig(this.ctx);
     }
-    // DLQ Operations
+    // ============ DLQ Operations ============
     setDlqConfig(config) {
-        if (!this.embedded) {
-            console.warn('setDlqConfig: embedded only');
-            return;
-        }
-        dlqOps.setDlqConfig(this.name, config);
+        dlqOps.setDlqConfig(this.ctx, config);
     }
     getDlqConfig() {
-        if (!this.embedded)
-            return {};
-        return dlqOps.getDlqConfigEmbedded(this.name);
+        return dlqOps.getDlqConfig(this.ctx);
     }
     getDlq(filter) {
-        if (!this.embedded)
-            return [];
-        return dlqOps.getDlqEntries(this.name, filter);
+        return dlqOps.getDlq(this.ctx, filter);
     }
     getDlqStats() {
-        if (!this.embedded) {
-            return {
-                total: 0,
-                byReason: {},
-                pendingRetry: 0,
-                expired: 0,
-                oldestEntry: null,
-                newestEntry: null,
-            };
-        }
-        return dlqOps.getDlqStatsEmbedded(this.name);
+        return dlqOps.getDlqStats(this.ctx);
     }
     retryDlq(id) {
-        if (this.embedded)
-            return dlqOps.retryDlqEmbedded(this.name, id);
-        void this.tcp.send({ cmd: 'RetryDlq', queue: this.name, id });
-        return 0;
+        return dlqOps.retryDlq(this.ctx, id);
     }
     retryDlqByFilter(filter) {
-        if (!this.embedded)
-            return 0;
-        return dlqOps.retryDlqByFilterEmbedded(this.name, filter);
+        return dlqOps.retryDlqByFilter(this.ctx, filter);
     }
     purgeDlq() {
-        if (this.embedded)
-            return dlqOps.purgeDlqEmbedded(this.name);
-        void this.tcp.send({ cmd: 'PurgeDlq', queue: this.name });
-        return 0;
+        return dlqOps.purgeDlq(this.ctx);
     }
-    /** Retry a completed job by re-queueing it */
     retryCompleted(id) {
-        if (this.embedded) {
-            const jid = id ? jobId(id) : undefined;
-            return getSharedManager().retryCompleted(this.name, jid);
-        }
-        void this.tcp.send({ cmd: 'RetryCompleted', queue: this.name, id });
-        return 0;
-    }
-    /** Retry a completed job (async, works with TCP) */
-    async retryCompletedAsync(id) {
-        if (this.embedded)
-            return this.retryCompleted(id);
-        const response = await this.tcp.send({ cmd: 'RetryCompleted', queue: this.name, id });
-        if (!response.ok)
-            return 0;
-        return response.count ?? 0;
-    }
-    // ============================================================================
-    // BullMQ v5 Compatibility Methods (Additional)
-    // ============================================================================
-    /**
-     * Trim events to a maximum length.
-     * In bunqueue, events are emitted in real-time and not stored, so this is a no-op.
-     */
-    trimEvents(_maxLength) {
-        // Events in bunqueue are not persisted - they're emitted via EventEmitter
-        return Promise.resolve(0);
-    }
-    /**
-     * Get jobs sorted by priority (highest first).
-     * In BullMQ, this returns jobs waiting to be processed sorted by priority.
-     */
-    getPrioritized(start = 0, end = -1) {
-        // In bunqueue, all waiting jobs are already prioritized in the priority queue
-        return this.getWaitingAsync(start, end);
-    }
-    /** Get count of prioritized jobs (same as waiting count in bunqueue) */
-    getPrioritizedCount() {
-        return this.getWaitingCount();
+        return dlqOps.retryCompleted(this.ctx, id);
     }
-    /**
-     * Get jobs that are waiting for their parent to complete.
-     * Used in job flows (parent-child dependencies).
-     */
-    getWaitingChildren(start = 0, end = -1) {
-        if (this.embedded) {
-            // Get jobs with pending dependencies
-            const jobs = getSharedManager().getJobs(this.name, {
-                state: 'delayed',
-                start,
-                end: end === -1 ? 1000 : end,
-            });
-            // Filter to only those with dependencies (would need dependency tracking)
-            const result = jobs
-                .filter((j) => {
-                const data = j.data;
-                return data?._waitingParent === true;
-            })
-                .map((job) => {
-                const jobData = job.data;
-                return toPublicJob({
-                    job,
-                    name: jobData?.name ?? 'default',
-                    getState: (jid) => this.getJobState(jid),
-                    remove: (jid) => this.removeAsync(jid),
-                    retry: (jid) => this.retryJob(jid),
-                    getChildrenValues: (jid) => this.getChildrenValues(jid),
-                    updateData: (jid, data) => this.updateJobData(jid, data),
-                    promote: (jid) => this.promoteJob(jid),
-                    changeDelay: (jid, delay) => this.changeJobDelay(jid, delay),
-                    changePriority: (jid, opts) => this.changeJobPriority(jid, opts),
-                    extendLock: (jid, token, duration) => this.extendJobLock(jid, token, duration),
-                    clearLogs: (jid, keepLogs) => this.clearJobLogs(jid, keepLogs),
-                    getDependencies: (jid, opts) => this.getJobDependencies(jid, opts),
-                    getDependenciesCount: (jid, opts) => this.getJobDependenciesCount(jid, opts),
-                });
-            });
-            return Promise.resolve(result);
-        }
-        // TCP mode - not fully supported yet
-        return Promise.resolve([]);
-    }
-    /** Get count of jobs waiting for their parent */
-    async getWaitingChildrenCount() {
-        const children = await this.getWaitingChildren();
-        return children.length;
-    }
-    /**
-     * Get dependencies of a parent job.
-     * Returns processed/unprocessed children of a parent job in a flow.
-     */
-    getDependencies(_parentId, _type, _start = 0, _end = -1) {
-        // Would require implementing dependency tracking
-        return Promise.resolve({
-            processed: {},
-            unprocessed: [],
-        });
+    retryCompletedAsync(id) {
+        return dlqOps.retryCompletedAsync(this.ctx, id);
     }
-    /**
-     * Get the TTL of the current rate limit.
-     * Returns 0 if no rate limit is active.
-     */
-    getRateLimitTtl(_maxJobs) {
-        // Would need to track rate limit expiration
-        return Promise.resolve(0);
-    }
-    /**
-     * Set a temporary rate limit that expires after the given time.
-     */
-    async rateLimit(expireTimeMs) {
-        if (this.embedded) {
-            // Set rate limit with expiration
-            getSharedManager().setRateLimit(this.name, 1);
-            // Schedule removal after expiration
-            setTimeout(() => {
-                getSharedManager().clearRateLimit(this.name);
-            }, expireTimeMs);
-        }
-        else {
-            await this.tcp.send({ cmd: 'RateLimit', queue: this.name, limit: 1 });
-            // Note: TCP mode would need server-side expiration support
-        }
+    // ============ Rate Limit Operations ============
+    setGlobalConcurrency(concurrency) {
+        rateLimitOps.setGlobalConcurrency(this.ctx, concurrency);
+    }
+    removeGlobalConcurrency() {
+        rateLimitOps.removeGlobalConcurrency(this.ctx);
+    }
+    getGlobalConcurrency() {
+        return rateLimitOps.getGlobalConcurrency(this.ctx);
+    }
+    setGlobalRateLimit(max, duration) {
+        rateLimitOps.setGlobalRateLimit(this.ctx, max, duration);
+    }
+    removeGlobalRateLimit() {
+        rateLimitOps.removeGlobalRateLimit(this.ctx);
+    }
+    getGlobalRateLimit() {
+        return rateLimitOps.getGlobalRateLimit(this.ctx);
+    }
+    rateLimit(expireTimeMs) {
+        return rateLimitOps.rateLimit(this.ctx, expireTimeMs);
+    }
+    getRateLimitTtl(maxJobs) {
+        return rateLimitOps.getRateLimitTtl(this.ctx, maxJobs);
     }
-    /**
-     * Check if the queue is currently rate limited (at max capacity).
-     */
     isMaxed() {
-        // Would need to check if rate limit is currently blocking
-        return Promise.resolve(false);
-    }
-    // ============================================================================
-    // Job Scheduler Methods (BullMQ v5 repeatable jobs)
-    // ============================================================================
-    /**
-     * Create or update a job scheduler (repeatable job).
-     * This is the BullMQ v5 way to handle cron/repeating jobs.
-     */
-    async upsertJobScheduler(schedulerId, repeatOpts, jobTemplate) {
-        const cronPattern = repeatOpts.pattern;
-        const repeatEvery = repeatOpts.every;
-        if (this.embedded) {
-            const manager = getSharedManager();
-            // Use the cron scheduler
-            manager.addCron({
-                name: schedulerId,
-                queue: this.name,
-                data: jobTemplate?.data ?? {},
-                schedule: cronPattern,
-                repeatEvery,
-                timezone: 'UTC',
-            });
-            return {
-                id: schedulerId,
-                name: jobTemplate?.name ?? 'default',
-                next: Date.now() + (repeatEvery ?? 60000),
-            };
-        }
-        else {
-            const response = await this.tcp.send({
-                cmd: 'Cron',
-                name: schedulerId,
-                queue: this.name,
-                data: jobTemplate?.data ?? {},
-                schedule: cronPattern,
-                repeatEvery,
-            });
-            if (!response.ok)
-                return null;
-            return {
-                id: schedulerId,
-                name: jobTemplate?.name ?? 'default',
-                next: response.nextRun ?? Date.now(),
-            };
-        }
+        return rateLimitOps.isMaxed(this.ctx);
     }
-    /**
-     * Remove a job scheduler.
-     */
-    async removeJobScheduler(schedulerId) {
-        if (this.embedded) {
-            getSharedManager().removeCron(schedulerId);
-            return true;
-        }
-        else {
-            const response = await this.tcp.send({ cmd: 'CronDelete', name: schedulerId });
-            return response.ok === true;
-        }
+    // ============ Scheduler Operations ============
+    upsertJobScheduler(schedulerId, repeatOpts, jobTemplate) {
+        return schedulerOps.upsertJobScheduler(this.ctx, schedulerId, repeatOpts, jobTemplate);
     }
-    /**
-     * Get a job scheduler by ID.
-     */
-    async getJobScheduler(schedulerId) {
-        if (this.embedded) {
-            const crons = getSharedManager().listCrons();
-            const cron = crons.find((c) => c.name === schedulerId);
-            if (!cron)
-                return null;
-            return {
-                id: cron.name,
-                name: cron.name,
-                next: cron.nextRun,
-                pattern: cron.schedule ?? undefined,
-                every: cron.repeatEvery ?? undefined,
-            };
-        }
-        else {
-            const response = await this.tcp.send({ cmd: 'CronList' });
-            if (!response.ok)
-                return null;
-            const crons = response.crons;
-            const cron = crons?.find((c) => c.name === schedulerId);
-            if (!cron)
-                return null;
-            return {
-                id: cron.name,
-                name: cron.name,
-                next: cron.nextRun,
-                pattern: cron.schedule ?? undefined,
-                every: cron.repeatEvery ?? undefined,
-            };
-        }
+    removeJobScheduler(schedulerId) {
+        return schedulerOps.removeJobScheduler(this.ctx, schedulerId);
     }
-    /**
-     * Get all job schedulers for this queue.
-     */
-    async getJobSchedulers(_start = 0, _end = -1, _asc = true) {
-        if (this.embedded) {
-            const crons = getSharedManager()
-                .listCrons()
-                .filter((c) => c.queue === this.name);
-            return crons.map((c) => ({
-                id: c.name,
-                name: c.name,
-                next: c.nextRun,
-                pattern: c.schedule ?? undefined,
-                every: c.repeatEvery ?? undefined,
-            }));
-        }
-        else {
-            const response = await this.tcp.send({ cmd: 'CronList' });
-            if (!response.ok)
-                return [];
-            const crons = response.crons;
-            return (crons ?? [])
-                .filter((c) => c.queue === this.name)
-                .map((c) => ({
-                id: c.name,
-                name: c.name,
-                next: c.nextRun,
-                pattern: c.schedule ?? undefined,
-                every: c.repeatEvery ?? undefined,
-            }));
-        }
+    getJobScheduler(schedulerId) {
+        return schedulerOps.getJobScheduler(this.ctx, schedulerId);
+    }
+    getJobSchedulers(start, end, asc) {
+        return schedulerOps.getJobSchedulers(this.ctx, start, end, asc);
     }
-    /** Get count of job schedulers for this queue */
-    async getJobSchedulersCount() {
-        const schedulers = await this.getJobSchedulers();
-        return schedulers.length;
-    }
-    // ============================================================================
-    // Deduplication Methods
-    // ============================================================================
-    /**
-     * Get the job ID associated with a deduplication key.
-     */
+    getJobSchedulersCount() {
+        return schedulerOps.getJobSchedulersCount(this.ctx);
+    }
+    // ============ Deduplication Operations ============
     getDeduplicationJobId(deduplicationId) {
-        if (this.embedded) {
-            const job = getSharedManager().getJobByCustomId(deduplicationId);
-            return Promise.resolve(job ? String(job.id) : null);
-        }
-        // TCP mode - would need server support
-        return Promise.resolve(null);
+        return deduplicationOps.getDeduplicationJobId(this.ctx, deduplicationId);
     }
-    /**
-     * Remove a deduplication key, allowing a new job with the same key.
-     */
     removeDeduplicationKey(deduplicationId) {
-        if (this.embedded) {
-            // Remove the custom ID mapping
-            const job = getSharedManager().getJobByCustomId(deduplicationId);
-            if (job) {
-                // Would need a method to remove just the customId mapping
-                return Promise.resolve(1);
-            }
-            return Promise.resolve(0);
-        }
-        return Promise.resolve(0);
-    }
-    // ============================================================================
-    // Connection Methods
-    // ============================================================================
-    /**
-     * Wait until the queue is ready (connection established).
-     */
-    async waitUntilReady() {
-        if (this.embedded) {
-            // Embedded mode is always ready
-            return;
-        }
-        // TCP mode - the pool handles connection
-        // Just ensure we can send a ping
-        await this.tcp.send({ cmd: 'Ping' });
+        return deduplicationOps.removeDeduplicationKey(this.ctx, deduplicationId);
     }
-    /**
-     * Disconnect from the server (async version of close).
-     */
-    disconnect() {
-        this.close();
-        return Promise.resolve();
+    // ============ Job Move Operations ============
+    moveJobToCompleted(id, returnValue, token) {
+        return jobMoveOps.moveJobToCompleted(this.moveCtx, id, returnValue, token);
     }
-    // ============================================================================
-    // BullMQ v5 Job Mutation Methods (used by Job instances)
-    // ============================================================================
-    /** Update job data */
-    async updateJobData(id, data) {
-        if (this.embedded) {
-            const manager = getSharedManager();
-            await manager.updateJobData(jobId(id), data);
-        }
-        else {
-            await this.tcp.send({ cmd: 'Update', id, data });
-        }
+    moveJobToFailed(id, error, token) {
+        return jobMoveOps.moveJobToFailed(this.moveCtx, id, error, token);
     }
-    /** Promote a delayed job to waiting */
-    async promoteJob(id) {
-        if (this.embedded) {
-            await getSharedManager().promote(jobId(id));
-        }
-        else {
-            await this.tcp.send({ cmd: 'Promote', id });
-        }
+    moveJobToWait(id, token) {
+        return jobMoveOps.moveJobToWait(this.moveCtx, id, token);
     }
-    /** Change job delay */
-    async changeJobDelay(id, delay) {
-        if (this.embedded) {
-            const manager = getSharedManager();
-            await manager.changeDelay(jobId(id), delay);
-        }
-        else {
-            await this.tcp.send({ cmd: 'ChangeDelay', id, delay });
-        }
+    moveJobToDelayed(id, timestamp, token) {
+        return jobMoveOps.moveJobToDelayed(this.moveCtx, id, timestamp, token);
     }
-    /** Change job priority */
-    async changeJobPriority(id, opts) {
-        if (this.embedded) {
-            const manager = getSharedManager();
-            await manager.changePriority(jobId(id), opts.priority);
-        }
-        else {
-            await this.tcp.send({ cmd: 'ChangePriority', id, priority: opts.priority });
-        }
+    moveJobToWaitingChildren(id, token, opts) {
+        return jobMoveOps.moveJobToWaitingChildren(this.moveCtx, id, token, opts);
     }
-    /** Extend job lock */
-    async extendJobLock(id, token, duration) {
-        if (this.embedded) {
-            const manager = getSharedManager();
-            const extended = await manager.extendLock(jobId(id), token || null, duration);
-            return extended ? duration : 0;
-        }
-        else {
-            const response = await this.tcp.send({ cmd: 'ExtendLock', id, token, duration });
-            return response.ok ? duration : 0;
-        }
+    waitJobUntilFinished(id, queueEvents, ttl) {
+        return jobMoveOps.waitJobUntilFinished(this.moveCtx, id, queueEvents, ttl);
     }
-    /** Clear job logs */
-    async clearJobLogs(id, keepLogs) {
-        if (this.embedded) {
-            const manager = getSharedManager();
-            manager.clearLogs(jobId(id), keepLogs);
-        }
-        else {
-            await this.tcp.send({ cmd: 'ClearLogs', id, keepLogs });
-        }
+    // ============ Dependency Operations ============
+    getJobDependencies(id, opts) {
+        return bullmqCompatOps.getJobDependencies(this.addCtx, id, opts);
     }
-    /** Get job dependencies */
-    async getJobDependencies(id, _opts) {
-        if (this.embedded) {
-            const manager = getSharedManager();
-            const job = await manager.getJob(jobId(id));
-            if (!job)
-                return { processed: {}, unprocessed: [] };
-            const childIds = job.childrenIds;
-            const processed = {};
-            const unprocessed = [];
-            for (const childId of childIds) {
-                const result = manager.getResult(childId);
-                if (result !== undefined) {
-                    const childJob = await manager.getJob(childId);
-                    const key = childJob ? `${childJob.queue}:${childId}` : String(childId);
-                    processed[key] = result;
-                }
-                else {
-                    unprocessed.push(String(childId));
-                }
-            }
-            return { processed, unprocessed };
-        }
-        // TCP mode
-        return { processed: {}, unprocessed: [] };
+    getJobDependenciesCount(id, opts) {
+        return bullmqCompatOps.getJobDependenciesCount(this.addCtx, id, opts);
     }
-    /** Get job dependencies count */
-    async getJobDependenciesCount(id, _opts) {
-        if (this.embedded) {
-            const deps = await this.getJobDependencies(id);
-            return {
-                processed: Object.keys(deps.processed).length,
-                unprocessed: deps.unprocessed.length,
-            };
-        }
-        return { processed: 0, unprocessed: 0 };
-    }
-    // ============================================================================
-    // BullMQ v5 Job Move Methods
-    // ============================================================================
-    /**
-     * Move job to completed state (BullMQ v5 compatible).
-     * Used internally by workers to mark jobs as complete.
-     */
-    async moveJobToCompleted(id, returnValue, _token) {
-        if (this.embedded) {
-            const manager = getSharedManager();
-            await manager.ack(jobId(id), returnValue);
-            return null; // Could return next job if fetchNext was true
-        }
-        else {
-            await this.tcp.send({ cmd: 'ACK', id, result: returnValue });
-            return null;
-        }
+    getDependencies(parentId, type, start, end) {
+        return bullmqCompatOps.getDependencies(this.addCtx, parentId, type, start, end);
     }
-    /**
-     * Move job to failed state (BullMQ v5 compatible).
-     * Used internally by workers to mark jobs as failed.
-     */
-    async moveJobToFailed(id, error, _token) {
-        if (this.embedded) {
-            const manager = getSharedManager();
-            await manager.fail(jobId(id), error.message);
-        }
-        else {
-            await this.tcp.send({ cmd: 'FAIL', id, error: error.message });
-        }
+    // ============ BullMQ Compatibility ============
+    getPrioritized(start, end) {
+        return bullmqCompatOps.getPrioritized({
+            ...this.addCtx,
+            getWaitingAsync: (s, e) => this.getWaitingAsync(s, e),
+        }, start, end);
     }
-    /**
-     * Move job back to waiting state (BullMQ v5 compatible).
-     * Useful for re-queueing a job that needs to be processed again.
-     */
-    async moveJobToWait(id, _token) {
-        if (this.embedded) {
-            const manager = getSharedManager();
-            const job = await manager.getJob(jobId(id));
-            if (!job)
-                return false;
-            // Re-queue the job by pushing it again
-            await manager.push(job.queue, {
-                data: job.data,
-                priority: job.priority,
-                customId: job.customId ?? undefined,
-            });
-            return true;
-        }
-        else {
-            const response = await this.tcp.send({ cmd: 'MoveToWait', id });
-            return response.ok === true;
-        }
+    getPrioritizedCount() {
+        return bullmqCompatOps.getPrioritizedCount({
+            ...this.addCtx,
+            getWaitingAsync: (s, e) => this.getWaitingAsync(s, e),
+        });
     }
-    /**
-     * Move job to delayed state (BullMQ v5 compatible).
-     * The job will become available for processing at the specified timestamp.
-     */
-    async moveJobToDelayed(id, timestamp, _token) {
-        if (this.embedded) {
-            const manager = getSharedManager();
-            const delay = Math.max(0, timestamp - Date.now());
-            await manager.changeDelay(jobId(id), delay);
-        }
-        else {
-            await this.tcp.send({ cmd: 'MoveToDelayed', id, timestamp });
-        }
+    getWaitingChildren(start, end) {
+        return bullmqCompatOps.getWaitingChildren(this.addCtx, start, end);
     }
-    /**
-     * Move job to waiting-children state (BullMQ v5 compatible).
-     * Job will wait for all children to complete before processing.
-     */
-    async moveJobToWaitingChildren(id, _token, _opts) {
-        if (this.embedded) {
-            // In embedded mode, this is handled automatically by the dependency system
-            // The job is already in waiting-children state if it has pending children
-            const manager = getSharedManager();
-            const job = await manager.getJob(jobId(id));
-            if (!job)
-                return false;
-            // Check if job has unprocessed children
-            const deps = await this.getJobDependencies(id);
-            return deps.unprocessed.length > 0;
-        }
-        return false;
-    }
-    /**
-     * Wait until job has finished (completed or failed).
-     * BullMQ v5 compatible method.
-     */
-    async waitJobUntilFinished(id, queueEvents, ttl) {
-        return new Promise((resolve, reject) => {
-            const timeout = ttl
-                ? setTimeout(() => {
-                    cleanup();
-                    reject(new Error(`Job ${id} timed out after ${ttl}ms`));
-                }, ttl)
-                : null;
-            // Cast queueEvents to expected interface
-            const events = queueEvents;
-            const completedHandler = (data) => {
-                if (data.jobId === id) {
-                    cleanup();
-                    resolve(data.returnvalue);
-                }
-            };
-            const failedHandler = (data) => {
-                if (data.jobId === id) {
-                    cleanup();
-                    reject(new Error(data.failedReason ?? 'Job failed'));
-                }
-            };
-            const cleanup = () => {
-                if (timeout)
-                    clearTimeout(timeout);
-                events.off('completed', completedHandler);
-                events.off('failed', failedHandler);
-            };
-            events.on('completed', completedHandler);
-            events.on('failed', failedHandler);
-            // Also check if job is already finished
-            void this.getJobState(id).then((state) => {
-                if (state === 'completed') {
-                    cleanup();
-                    // Get the result
-                    if (this.embedded) {
-                        const result = getSharedManager().getResult(jobId(id));
-                        resolve(result);
-                    }
-                    else {
-                        resolve(undefined);
-                    }
-                }
-                else if (state === 'failed') {
-                    cleanup();
-                    reject(new Error('Job already failed'));
-                }
-            });
-        });
+    getWaitingChildrenCount() {
+        return bullmqCompatOps.getWaitingChildrenCount(this.addCtx);
+    }
+    trimEvents(maxLength) {
+        return workersOps.trimEvents(this.ctx, maxLength);
+    }
+    // ============ Worker/Metrics Operations ============
+    getWorkers() {
+        return workersOps.getWorkers(this.ctx);
+    }
+    getWorkersCount() {
+        return workersOps.getWorkersCount(this.ctx);
+    }
+    getMetrics(type, start, end) {
+        return workersOps.getMetrics(this.ctx, type, start, end);
+    }
+    // ============ Connection ============
+    disconnect() {
+        this.close();
+        return Promise.resolve();
     }
     close() {
         if (this.tcpPool) {
@@ -1523,208 +424,5 @@ export class Queue {
                 this.tcpPool.close();
         }
     }
-    createJobProxy(id, name, data) {
-        const tcp = this.tcp;
-        const ts = Date.now();
-        return {
-            id,
-            name,
-            data,
-            queueName: this.name,
-            attemptsMade: 0,
-            timestamp: ts,
-            progress: 0,
-            // BullMQ v5 properties
-            delay: 0,
-            processedOn: undefined,
-            finishedOn: undefined,
-            stacktrace: null,
-            stalledCounter: 0,
-            priority: 0,
-            parentKey: undefined,
-            opts: {},
-            token: undefined,
-            processedBy: undefined,
-            deduplicationId: undefined,
-            repeatJobKey: undefined,
-            attemptsStarted: 0,
-            // Methods
-            updateProgress: async (progress, message) => {
-                await tcp.send({ cmd: 'Progress', id, progress, message });
-            },
-            log: async (message) => {
-                await tcp.send({ cmd: 'AddLog', id, message });
-            },
-            getState: () => this.getJobState(id),
-            remove: () => this.removeAsync(id),
-            retry: () => this.retryJob(id),
-            getChildrenValues: () => this.getChildrenValues(id),
-            // BullMQ v5 state check methods
-            isWaiting: async () => (await this.getJobState(id)) === 'waiting',
-            isActive: async () => (await this.getJobState(id)) === 'active',
-            isDelayed: async () => (await this.getJobState(id)) === 'delayed',
-            isCompleted: async () => (await this.getJobState(id)) === 'completed',
-            isFailed: async () => (await this.getJobState(id)) === 'failed',
-            isWaitingChildren: () => Promise.resolve(false),
-            // BullMQ v5 mutation methods
-            updateData: async (newData) => {
-                await tcp.send({ cmd: 'Update', id, data: newData });
-            },
-            promote: async () => {
-                await tcp.send({ cmd: 'Promote', id });
-            },
-            changeDelay: async (delay) => {
-                await tcp.send({ cmd: 'ChangeDelay', id, delay });
-            },
-            changePriority: async (opts) => {
-                await tcp.send({ cmd: 'ChangePriority', id, priority: opts.priority });
-            },
-            extendLock: async (_token, duration) => {
-                const res = await tcp.send({ cmd: 'ExtendLock', id, duration });
-                return res.ok ? duration : 0;
-            },
-            clearLogs: async () => {
-                await tcp.send({ cmd: 'ClearLogs', id });
-            },
-            // BullMQ v5 dependency methods
-            getDependencies: () => Promise.resolve({ processed: {}, unprocessed: [] }),
-            getDependenciesCount: () => Promise.resolve({ processed: 0, unprocessed: 0 }),
-            // BullMQ v5 serialization methods
-            toJSON: () => ({
-                id,
-                name,
-                data,
-                opts: {},
-                progress: 0,
-                delay: 0,
-                timestamp: ts,
-                attemptsMade: 0,
-                stacktrace: null,
-                queueQualifiedName: `bull:${this.name}`,
-            }),
-            asJSON: () => ({
-                id,
-                name,
-                data: JSON.stringify(data),
-                opts: '{}',
-                progress: '0',
-                delay: '0',
-                timestamp: String(ts),
-                attemptsMade: '0',
-                stacktrace: null,
-            }),
-            // BullMQ v5 move methods
-            moveToCompleted: async (returnValue) => {
-                await tcp.send({ cmd: 'ACK', id, result: returnValue });
-                return null;
-            },
-            moveToFailed: async (error) => {
-                await tcp.send({ cmd: 'FAIL', id, error: error.message });
-            },
-            moveToWait: async () => {
-                const res = await tcp.send({ cmd: 'MoveToWait', id });
-                return res.ok === true;
-            },
-            moveToDelayed: async (timestamp) => {
-                await tcp.send({ cmd: 'MoveToDelayed', id, timestamp });
-            },
-            moveToWaitingChildren: () => Promise.resolve(false),
-            waitUntilFinished: () => Promise.resolve(undefined),
-            // BullMQ v5 additional methods
-            discard: () => { },
-            getFailedChildrenValues: () => Promise.resolve({}),
-            getIgnoredChildrenFailures: () => Promise.resolve({}),
-            removeChildDependency: () => Promise.resolve(false),
-            removeDeduplicationKey: () => Promise.resolve(false),
-            removeUnprocessedChildren: () => Promise.resolve(),
-        };
-    }
-    createSimpleJob(id, name, data, timestamp) {
-        return {
-            id,
-            name,
-            data,
-            queueName: this.name,
-            attemptsMade: 0,
-            timestamp,
-            progress: 0,
-            // BullMQ v5 properties
-            delay: 0,
-            processedOn: undefined,
-            finishedOn: undefined,
-            stacktrace: null,
-            stalledCounter: 0,
-            priority: 0,
-            parentKey: undefined,
-            opts: {},
-            token: undefined,
-            processedBy: undefined,
-            deduplicationId: undefined,
-            repeatJobKey: undefined,
-            attemptsStarted: 0,
-            // Methods
-            updateProgress: async () => { },
-            log: async () => { },
-            getState: () => this.getJobState(id),
-            remove: () => this.removeAsync(id),
-            retry: () => this.retryJob(id),
-            getChildrenValues: () => this.getChildrenValues(id),
-            // BullMQ v5 state check methods
-            isWaiting: async () => (await this.getJobState(id)) === 'waiting',
-            isActive: async () => (await this.getJobState(id)) === 'active',
-            isDelayed: async () => (await this.getJobState(id)) === 'delayed',
-            isCompleted: async () => (await this.getJobState(id)) === 'completed',
-            isFailed: async () => (await this.getJobState(id)) === 'failed',
-            isWaitingChildren: () => Promise.resolve(false),
-            // BullMQ v5 mutation methods
-            updateData: async () => { },
-            promote: async () => { },
-            changeDelay: async () => { },
-            changePriority: async () => { },
-            extendLock: () => Promise.resolve(0),
-            clearLogs: async () => { },
-            // BullMQ v5 dependency methods
-            getDependencies: () => Promise.resolve({ processed: {}, unprocessed: [] }),
-            getDependenciesCount: () => Promise.resolve({ processed: 0, unprocessed: 0 }),
-            // BullMQ v5 serialization methods
-            toJSON: () => ({
-                id,
-                name,
-                data,
-                opts: {},
-                progress: 0,
-                delay: 0,
-                timestamp,
-                attemptsMade: 0,
-                stacktrace: null,
-                queueQualifiedName: `bull:${this.name}`,
-            }),
-            asJSON: () => ({
-                id,
-                name,
-                data: JSON.stringify(data),
-                opts: '{}',
-                progress: '0',
-                delay: '0',
-                timestamp: String(timestamp),
-                attemptsMade: '0',
-                stacktrace: null,
-            }),
-            // BullMQ v5 move methods
-            moveToCompleted: () => Promise.resolve(null),
-            moveToFailed: () => Promise.resolve(),
-            moveToWait: () => Promise.resolve(false),
-            moveToDelayed: () => Promise.resolve(),
-            moveToWaitingChildren: () => Promise.resolve(false),
-            waitUntilFinished: () => Promise.resolve(undefined),
-            // BullMQ v5 additional methods
-            discard: () => { },
-            getFailedChildrenValues: () => Promise.resolve({}),
-            getIgnoredChildrenFailures: () => Promise.resolve({}),
-            removeChildDependency: () => Promise.resolve(false),
-            removeDeduplicationKey: () => Promise.resolve(false),
-            removeUnprocessedChildren: () => Promise.resolve(),
-        };
-    }
 }
 //# sourceMappingURL=queue.js.map