bunqueue 2.8.53 → 2.8.54

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

@@ -3,7 +3,7 @@
  */
 import type { TcpConnectionPool } from '../tcpPool';
 import type { Job, JobDependencies, JobDependenciesCount, GetDependenciesOpts } from '../types';
-interface BullMQContext<T = unknown> {
+interface CompatibilityContext<T = unknown> {
     name: string;
     embedded: boolean;
     tcp: TcpConnectionPool | null;
@@ -22,26 +22,36 @@ interface BullMQContext<T = unknown> {
     clearJobLogs: (id: string, keepLogs?: number) => Promise<void>;
     getJobDependencies: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependencies>;
     getJobDependenciesCount: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependenciesCount>;
+    getJobCountsAsync: () => Promise<{
+        prioritized: number;
+        'waiting-children': number;
+    }>;
     getWaitingAsync: (start?: number, end?: number) => Promise<Job<T>[]>;
     getPrioritizedAsync: (start?: number, end?: number) => Promise<Job<T>[]>;
+    getJobsAsync: (options: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }) => Promise<Job<T>[]>;
 }
 /** Get jobs in the "prioritized" state (priority > 0, BullMQ v5) */
-export declare function getPrioritized<T>(ctx: BullMQContext<T>, start?: number, end?: number): Promise<Job<T>[]>;
+export declare function getPrioritized<T>(ctx: CompatibilityContext<T>, start?: number, end?: number): Promise<Job<T>[]>;
 /** Get count of prioritized jobs (priority > 0) */
-export declare function getPrioritizedCount<T>(ctx: BullMQContext<T>): Promise<number>;
+export declare function getPrioritizedCount<T>(ctx: CompatibilityContext<T>): Promise<number>;
 /** Get jobs waiting for parent to complete */
-export declare function getWaitingChildren<T>(ctx: BullMQContext<T>, start?: number, end?: number): Promise<Job<T>[]>;
+export declare function getWaitingChildren<T>(ctx: CompatibilityContext<T>, start?: number, end?: number): Promise<Job<T>[]>;
 /** Get count of jobs waiting for parent */
-export declare function getWaitingChildrenCount<T>(ctx: BullMQContext<T>): Promise<number>;
+export declare function getWaitingChildrenCount<T>(ctx: CompatibilityContext<T>): Promise<number>;
 /** Get dependencies of a parent job */
-export declare function getDependencies(_ctx: BullMQContext, _parentId: string, _type?: 'processed' | 'unprocessed', _start?: number, _end?: number): Promise<{
+export declare function getDependencies(ctx: CompatibilityContext, parentId: string, type?: 'processed' | 'unprocessed', start?: number, end?: number): Promise<{
     processed?: Record<string, unknown>;
     unprocessed?: string[];
     nextProcessedCursor?: number;
     nextUnprocessedCursor?: number;
 }>;
 /** Get job dependencies (for Job instance method) */
-export declare function getJobDependencies(ctx: BullMQContext, id: string, _opts?: GetDependenciesOpts): Promise<JobDependencies>;
+export declare function getJobDependencies(ctx: CompatibilityContext, id: string, _opts?: GetDependenciesOpts): Promise<JobDependencies>;
 /** Get job dependencies count */
-export declare function getJobDependenciesCount(ctx: BullMQContext, id: string, _opts?: GetDependenciesOpts): Promise<JobDependenciesCount>;
+export declare function getJobDependenciesCount(ctx: CompatibilityContext, id: string, _opts?: GetDependenciesOpts): Promise<JobDependenciesCount>;
 export {};

package/dist/client/queue/bullmqCompat.js

@@ -2,95 +2,63 @@
 /**
  * BullMQ v5 Compatibility Operations
  */
-import { getSharedManager } from '../manager';
-import { toPublicJob } from '../types';
-import { jobId } from '../../domain/types/job';
+import { getFlowDependencies } from '../flowJobDependencies';
 /** Get jobs in the "prioritized" state (priority > 0, BullMQ v5) */
 export function getPrioritized(ctx, start = 0, end = -1) {
     return ctx.getPrioritizedAsync(start, end);
 }
 /** Get count of prioritized jobs (priority > 0) */
 export async function getPrioritizedCount(ctx) {
-    const jobs = await ctx.getPrioritizedAsync(0, 1000);
-    return jobs.length;
+    return (await ctx.getJobCountsAsync()).prioritized;
 }
 /** Get jobs waiting for parent to complete */
 export async function getWaitingChildren(ctx, start = 0, end = -1) {
-    if (ctx.embedded) {
-        const jobs = getSharedManager().getJobs(ctx.name, {
-            state: 'delayed',
-            start,
-            end: end === -1 ? 1000 : end,
-        });
-        return 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: ctx.getJobState,
-                remove: ctx.removeAsync,
-                retry: ctx.retryJob,
-                getChildrenValues: ctx.getChildrenValues,
-                updateData: ctx.updateJobData,
-                promote: ctx.promoteJob,
-                changeDelay: ctx.changeJobDelay,
-                changePriority: ctx.changeJobPriority,
-                extendLock: ctx.extendJobLock,
-                clearLogs: ctx.clearJobLogs,
-                getDependencies: ctx.getJobDependencies,
-                getDependenciesCount: ctx.getJobDependenciesCount,
-            });
-        });
-    }
-    return [];
+    return ctx.getJobsAsync({
+        state: 'waiting-children',
+        start,
+        end: end === -1 ? -1 : end + 1,
+        asc: true,
+    });
 }
 /** Get count of jobs waiting for parent */
 export async function getWaitingChildrenCount(ctx) {
-    const children = await getWaitingChildren(ctx);
-    return children.length;
+    return (await ctx.getJobCountsAsync())['waiting-children'];
 }
 /** Get dependencies of a parent job */
-export function getDependencies(_ctx, _parentId, _type, _start, _end) {
-    return Promise.resolve({ processed: {}, unprocessed: [] });
+export function getDependencies(ctx, parentId, type, start = 0, end = -1) {
+    return getFlowDependencies(parentId, ctx.name, ctx.embedded, ctx.tcp).then((dependencies) => {
+        const unprocessed = [...dependencies.unprocessed].sort();
+        const processedEntries = Object.entries(dependencies.processed).sort(([a], [b]) => a.localeCompare(b));
+        const stop = end < 0 ? undefined : end + 1;
+        return {
+            processed: type === 'unprocessed' ? {} : Object.fromEntries(processedEntries.slice(start, stop)),
+            unprocessed: type === 'processed' ? [] : unprocessed.slice(start, stop),
+        };
+    });
 }
 /** Get job dependencies (for Job instance method) */
 export async function getJobDependencies(ctx, id, _opts) {
-    if (ctx.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 };
-    }
-    return { processed: {}, unprocessed: [] };
+    const dependencies = await getFlowDependencies(id, ctx.name, ctx.embedded, ctx.tcp);
+    const processedEntries = Object.entries(dependencies.processed).sort(([a], [b]) => a.localeCompare(b));
+    const unprocessed = [...dependencies.unprocessed].sort();
+    const processedCursor = _opts?.processed?.cursor ?? 0;
+    const processedCount = _opts?.processed?.count ?? processedEntries.length;
+    const unprocessedCursor = _opts?.unprocessed?.cursor ?? 0;
+    const unprocessedCount = _opts?.unprocessed?.count ?? unprocessed.length;
+    const processedEnd = Math.min(processedEntries.length, processedCursor + processedCount);
+    const unprocessedEnd = Math.min(unprocessed.length, unprocessedCursor + unprocessedCount);
+    return {
+        processed: Object.fromEntries(processedEntries.slice(processedCursor, processedEnd)),
+        unprocessed: unprocessed.slice(unprocessedCursor, unprocessedEnd),
+        nextProcessedCursor: processedEnd < processedEntries.length ? processedEnd : 0,
+        nextUnprocessedCursor: unprocessedEnd < unprocessed.length ? unprocessedEnd : 0,
+    };
 }
 /** Get job dependencies count */
 export async function getJobDependenciesCount(ctx, id, _opts) {
-    if (ctx.embedded) {
-        const deps = await getJobDependencies(ctx, id);
-        return {
-            processed: Object.keys(deps.processed).length,
-            unprocessed: deps.unprocessed.length,
-        };
-    }
-    return { processed: 0, unprocessed: 0 };
+    const deps = await getFlowDependencies(id, ctx.name, ctx.embedded, ctx.tcp);
+    return {
+        processed: Object.keys(deps.processed).length,
+        unprocessed: deps.unprocessed.length,
+    };
 }

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

@@ -1,9 +1,11 @@
 /**
  * Deduplication Operations
  */
+import type { TcpConnectionPool } from '../tcpPool';
 interface DeduplicationContext {
     name: string;
     embedded: boolean;
+    tcp: TcpConnectionPool | null;
 }
 /** Get the job ID associated with a deduplication key */
 export declare function getDeduplicationJobId(ctx: DeduplicationContext, deduplicationId: string): Promise<string | null>;

package/dist/client/queue/deduplication.js

@@ -3,21 +3,30 @@
  */
 import { getSharedManager } from '../manager';
 /** Get the job ID associated with a deduplication key */
-export function getDeduplicationJobId(ctx, deduplicationId) {
+export async function getDeduplicationJobId(ctx, deduplicationId) {
     if (ctx.embedded) {
-        const job = getSharedManager().getJobByCustomId(deduplicationId);
-        return Promise.resolve(job ? String(job.id) : null);
+        return getSharedManager().getDeduplicationJobId(ctx.name, deduplicationId);
     }
-    return Promise.resolve(null);
+    if (!ctx.tcp)
+        return null;
+    const response = await ctx.tcp.send({
+        cmd: 'GetDeduplicationJobId',
+        queue: ctx.name,
+        deduplicationId,
+    });
+    return response.data.jobId;
 }
 /** Remove a deduplication key */
-export function removeDeduplicationKey(ctx, deduplicationId) {
+export async function removeDeduplicationKey(ctx, deduplicationId) {
     if (ctx.embedded) {
-        const job = getSharedManager().getJobByCustomId(deduplicationId);
-        if (job) {
-            return Promise.resolve(1);
-        }
-        return Promise.resolve(0);
+        return getSharedManager().removeDeduplicationKey(ctx.name, deduplicationId);
     }
-    return Promise.resolve(0);
+    if (!ctx.tcp)
+        return 0;
+    const response = await ctx.tcp.send({
+        cmd: 'RemoveDeduplicationKey',
+        queue: ctx.name,
+        deduplicationId,
+    });
+    return response.data.count;
 }

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

@@ -4,7 +4,7 @@
  */
 import type { TcpConnectionPool } from '../tcpPool';
 import type { Job, DlqConfig, DlqEntry, DlqStats, DlqFilter } from '../types';
-import { type SimpleJobContext } from './jobProxy';
+import { type DlqJobContext } from './dlqJobMethods';
 interface DlqContext {
     name: string;
     embedded: boolean;
@@ -19,16 +19,19 @@ export declare function getDlqConfig(ctx: DlqContext): DlqConfig;
 /** Get DLQ configuration (async, works in TCP mode) */
 export declare function getDlqConfigAsync(ctx: DlqContext): Promise<DlqConfig>;
 /** Get DLQ entries */
-export declare function getDlq<T>(ctx: DlqContext, filter?: DlqFilter): DlqEntry<T>[];
-type DlqQueryContext = DlqContext & Pick<SimpleJobContext, 'getJobState' | 'removeAsync' | 'retryJob' | 'getChildrenValues'>;
+export declare function getDlq<T>(ctx: DlqQueryContext, filter?: DlqFilter): DlqEntry<T>[];
+type DlqQueryContext = DlqJobContext;
+/** Read full DLQ metadata from the selected broker runtime. */
+export declare function getDlqAsync<T>(ctx: DlqQueryContext, filter?: DlqFilter): Promise<DlqEntry<T>[]>;
 /**
- * Get the dead jobs in the DLQ, working over TCP too (wire command `Dlq`).
- * Returns public Job objects; the wire does not carry DlqEntry metadata
- * (reason, enteredAt, attempts) — that stays embedded-only via getDlq().
+ * Get only the public jobs from the DLQ. Use getDlqAsync() when the full entry
+ * metadata is needed; both views work over TCP through the same command.
  */
 export declare function getDlqJobsAsync<T>(ctx: DlqQueryContext, count?: number): Promise<Job<T>[]>;
 /** Get DLQ stats */
 export declare function getDlqStats(ctx: DlqContext): DlqStats;
+/** Read authoritative DLQ statistics from the selected broker runtime. */
+export declare function getDlqStatsAsync(ctx: DlqContext): Promise<DlqStats>;
 /** Retry DLQ entries */
 export declare function retryDlq(ctx: DlqContext, id?: string): number;
 /**
@@ -39,6 +42,8 @@ export declare function retryDlq(ctx: DlqContext, id?: string): number;
 export declare function retryDlqAsync(ctx: DlqContext, id?: string): Promise<number>;
 /** Retry DLQ entries by filter */
 export declare function retryDlqByFilter(ctx: DlqContext, filter: DlqFilter): number;
+/** Retry matching DLQ entries and return the applied count. */
+export declare function retryDlqByFilterAsync(ctx: DlqContext, filter: DlqFilter): Promise<number>;
 /** Purge DLQ */
 export declare function purgeDlq(ctx: DlqContext): number;
 /**

package/dist/client/queue/dlq.js

@@ -6,6 +6,8 @@ import { getSharedManager } from '../manager';
 import { jobId } from '../../domain/types/job';
 import { createSimpleJob } from './jobProxy';
 import * as dlqOps from './dlqOps';
+import { toDlqEntry } from '../jobConversion';
+import { createDlqJobMethods } from './dlqJobMethods';
 /** Client-side cache for TCP mode */
 const tcpDlqConfigCache = new Map();
 /** Set DLQ configuration */
@@ -56,12 +58,31 @@ export async function getDlqConfigAsync(ctx) {
 export function getDlq(ctx, filter) {
     if (!ctx.embedded)
         return [];
-    return dlqOps.getDlqEntries(ctx.name, filter);
+    const entries = getSharedManager().getDlqEntries(ctx.name, filter);
+    const methods = createDlqJobMethods(ctx);
+    return entries.map((entry) => toDlqEntry(entry, methods));
+}
+/** Read full DLQ metadata from the selected broker runtime. */
+export async function getDlqAsync(ctx, filter) {
+    let entries;
+    if (ctx.embedded) {
+        entries = getSharedManager().getDlqEntries(ctx.name, filter);
+    }
+    else if (ctx.tcp) {
+        const response = await ctx.tcp.send({ cmd: 'Dlq', queue: ctx.name, filter });
+        if (!response.ok)
+            return [];
+        entries = (response.entries ?? []);
+    }
+    else {
+        return [];
+    }
+    const methods = createDlqJobMethods(ctx);
+    return entries.map((entry) => toDlqEntry(entry, methods));
 }
 /**
- * Get the dead jobs in the DLQ, working over TCP too (wire command `Dlq`).
- * Returns public Job objects; the wire does not carry DlqEntry metadata
- * (reason, enteredAt, attempts) — that stays embedded-only via getDlq().
+ * Get only the public jobs from the DLQ. Use getDlqAsync() when the full entry
+ * metadata is needed; both views work over TCP through the same command.
  */
 export async function getDlqJobsAsync(ctx, count) {
     let raw;
@@ -104,6 +125,17 @@ export function getDlqStats(ctx) {
     }
     return dlqOps.getDlqStatsEmbedded(ctx.name);
 }
+/** Read authoritative DLQ statistics from the selected broker runtime. */
+export async function getDlqStatsAsync(ctx) {
+    if (ctx.embedded)
+        return dlqOps.getDlqStatsEmbedded(ctx.name);
+    if (!ctx.tcp)
+        return getDlqStats(ctx);
+    const response = await ctx.tcp.send({ cmd: 'GetDlqStats', queue: ctx.name });
+    if (!response.ok)
+        return getDlqStats(ctx);
+    return response.data.stats;
+}
 /** Retry DLQ entries */
 export function retryDlq(ctx, id) {
     if (ctx.embedded)
@@ -133,6 +165,17 @@ export function retryDlqByFilter(ctx, filter) {
         return 0;
     return dlqOps.retryDlqByFilterEmbedded(ctx.name, filter);
 }
+/** Retry matching DLQ entries and return the applied count. */
+export async function retryDlqByFilterAsync(ctx, filter) {
+    if (ctx.embedded)
+        return dlqOps.retryDlqByFilterEmbedded(ctx.name, filter);
+    if (!ctx.tcp)
+        return 0;
+    const response = await ctx.tcp.send({ cmd: 'RetryDlq', queue: ctx.name, filter });
+    if (!response.ok)
+        return 0;
+    return (response.count ?? 0);
+}
 /** Purge DLQ */
 export function purgeDlq(ctx) {
     if (ctx.embedded)

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

@@ -0,0 +1,9 @@
+import type { PublicJobMethodContext } from '../jobConversionTypes';
+import type { TcpConnectionPool } from '../tcpPool';
+import type { SimpleJobContext } from './jobProxy';
+export interface DlqJobContext extends Pick<SimpleJobContext, 'getJobState' | 'removeAsync' | 'retryJob' | 'getChildrenValues'> {
+    name: string;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+}
+export declare function createDlqJobMethods(ctx: DlqJobContext): PublicJobMethodContext;

package/dist/client/queue/dlqJobMethods.js

@@ -0,0 +1,176 @@
+import { jobId } from '../../domain/types/job';
+import { getFlowDependencies } from '../flowJobDependencies';
+import { getSharedManager } from '../manager';
+import { removeJobDeduplicationKey } from '../jobDeduplication';
+import { buildFailCommand, failEmbeddedArgs } from './failWire';
+function assertCommand(response, operation) {
+    if (response.ok === true)
+        return;
+    throw new Error(typeof response.error === 'string' ? response.error : `${operation} failed`);
+}
+export function createDlqJobMethods(ctx) {
+    const manager = getSharedManager();
+    const send = async (command, operation) => {
+        if (!ctx.tcp)
+            throw new Error(`${operation}: no connection`);
+        const response = await ctx.tcp.send(command);
+        assertCommand(response, operation);
+        return response;
+    };
+    const dependencies = (id) => getFlowDependencies(id, ctx.name, ctx.embedded, ctx.tcp);
+    return {
+        updateProgress: async (id, progress, message) => {
+            if (ctx.embedded) {
+                if (!(await manager.updateProgress(jobId(id), progress, message))) {
+                    throw new Error(`Job ${id} is not active`);
+                }
+            }
+            else
+                await send({ cmd: 'Progress', id, progress, message }, 'Progress');
+        },
+        log: async (id, message) => {
+            if (ctx.embedded)
+                manager.addLog(jobId(id), message);
+            else
+                await send({ cmd: 'AddLog', id, message }, 'AddLog');
+        },
+        getState: ctx.getJobState,
+        remove: ctx.removeAsync,
+        retry: ctx.retryJob,
+        getChildrenValues: ctx.getChildrenValues,
+        updateData: async (id, data) => {
+            if (ctx.embedded)
+                await manager.updateJobData(jobId(id), data);
+            else
+                await send({ cmd: 'Update', id, data }, 'Update');
+        },
+        promote: async (id) => {
+            if (ctx.embedded)
+                await manager.promote(jobId(id));
+            else
+                await send({ cmd: 'Promote', id }, 'Promote');
+        },
+        changeDelay: async (id, delay) => {
+            if (ctx.embedded)
+                await manager.changeDelay(jobId(id), delay);
+            else
+                await send({ cmd: 'ChangeDelay', id, delay }, 'ChangeDelay');
+        },
+        changePriority: async (id, options) => {
+            if (ctx.embedded)
+                await manager.changePriority(jobId(id), options.priority, options.lifo);
+            else {
+                await send({ cmd: 'ChangePriority', id, priority: options.priority, lifo: options.lifo }, 'ChangePriority');
+            }
+        },
+        extendLock: async (id, token, duration) => {
+            if (ctx.embedded)
+                return (await manager.extendLock(jobId(id), token, duration)) ? duration : 0;
+            const response = await send({ cmd: 'ExtendLock', id, token, duration }, 'ExtendLock');
+            return response.ok === true ? duration : 0;
+        },
+        clearLogs: async (id, keepLogs) => {
+            if (ctx.embedded)
+                manager.clearLogs(jobId(id), keepLogs);
+            else
+                await send({ cmd: 'ClearLogs', id, keepLogs }, 'ClearLogs');
+        },
+        getDependencies: async (id) => dependencies(id),
+        getDependenciesCount: async (id) => {
+            const value = await dependencies(id);
+            return {
+                processed: Object.keys(value.processed).length,
+                unprocessed: value.unprocessed.length,
+            };
+        },
+        moveToCompleted: async (id, result, token) => {
+            if (ctx.embedded)
+                await manager.ack(jobId(id), result, token);
+            else
+                await send({ cmd: 'ACK', id, result, token }, 'ACK');
+            return null;
+        },
+        moveToFailed: async (id, error, token) => {
+            if (ctx.embedded)
+                await manager.fail(jobId(id), ...failEmbeddedArgs(error, token));
+            else
+                await send(buildFailCommand(id, error, token), 'FAIL');
+        },
+        moveToWait: async (id) => {
+            if (ctx.embedded) {
+                const state = await manager.getJobState(jobId(id));
+                if (state === 'failed')
+                    return manager.retryDlq(ctx.name, jobId(id)) > 0;
+                if (state === 'active')
+                    return manager.moveActiveToWait(jobId(id));
+                if (state === 'delayed')
+                    return manager.promote(jobId(id));
+                return state === 'waiting' || state === 'prioritized';
+            }
+            const response = await send({ cmd: 'MoveToWait', id }, 'MoveToWait');
+            return response.ok === true;
+        },
+        moveToDelayed: async (id, timestamp) => {
+            const delay = Math.max(0, timestamp - Date.now());
+            if (ctx.embedded)
+                await manager.moveToDelayed(jobId(id), delay);
+            else
+                await send({ cmd: 'MoveToDelayed', id, delay }, 'MoveToDelayed');
+        },
+        moveToWaitingChildren: async (id) => {
+            if (ctx.embedded)
+                return manager.moveToWaitingChildren(jobId(id));
+            await send({ cmd: 'MoveToWaitingChildren', id }, 'MoveToWaitingChildren');
+            return true;
+        },
+        waitUntilFinished: async (id, _events, ttl) => {
+            const timeout = ttl ?? 30_000;
+            if (ctx.embedded) {
+                const current = await manager.getJob(jobId(id));
+                if (!current)
+                    throw new Error(`Job ${id} not found`);
+                if (current.completedAt)
+                    return manager.getResult(jobId(id));
+                if (!(await manager.waitForJobCompletion(jobId(id), timeout))) {
+                    throw new Error(`Job ${id} timed out after ${timeout}ms`);
+                }
+                return manager.getResult(jobId(id));
+            }
+            const response = await send({ cmd: 'WaitJob', id, timeout }, 'WaitJob');
+            if (!response.completed)
+                throw new Error(`Job ${id} timed out after ${timeout}ms`);
+            return response.result;
+        },
+        discard: (id) => {
+            if (ctx.embedded)
+                void manager.discard(jobId(id));
+            else if (ctx.tcp)
+                void ctx.tcp.send({ cmd: 'Discard', id });
+        },
+        getFailedChildrenValues: async (id) => {
+            if (ctx.embedded)
+                return manager.getFailedChildrenValues(jobId(id));
+            const response = await send({ cmd: 'GetFailedChildrenValues', id }, 'GetFailedChildrenValues');
+            return response.values ?? {};
+        },
+        getIgnoredChildrenFailures: async (id) => {
+            if (ctx.embedded)
+                return manager.getIgnoredChildrenFailures(jobId(id));
+            const response = await send({ cmd: 'GetIgnoredChildrenFailures', id }, 'GetIgnoredChildrenFailures');
+            return response.values ?? {};
+        },
+        removeChildDependency: async (id) => {
+            if (ctx.embedded)
+                return manager.removeChildDependency(jobId(id));
+            const response = await send({ cmd: 'RemoveChildDependency', id }, 'RemoveChildDependency');
+            return response.removed ?? false;
+        },
+        removeDeduplicationKey: (id) => removeJobDeduplicationKey(id, ctx.embedded, ctx.tcp),
+        removeUnprocessedChildren: async (id) => {
+            if (ctx.embedded)
+                await manager.removeUnprocessedChildren(jobId(id));
+            else
+                await send({ cmd: 'RemoveUnprocessedChildren', id }, 'RemoveUnprocessedChildren');
+        },
+    };
+}

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

@@ -3,12 +3,13 @@
  * Dead Letter Queue management for embedded mode
  */
 import type { DlqConfig, DlqEntry, DlqStats, DlqFilter, StallConfig } from '../types';
+import type { PublicJobMethodContext } from '../jobConversionTypes';
 /** Set DLQ configuration (embedded only) */
 export declare function setDlqConfig(queue: string, config: Partial<DlqConfig>): void;
 /** Get DLQ configuration (embedded only) */
 export declare function getDlqConfigEmbedded(queue: string): DlqConfig;
 /** Get DLQ entries (embedded only) */
-export declare function getDlqEntries<T>(queue: string, filter?: DlqFilter): DlqEntry<T>[];
+export declare function getDlqEntries<T>(queue: string, methods: PublicJobMethodContext, filter?: DlqFilter): DlqEntry<T>[];
 /** Get DLQ statistics (embedded only) */
 export declare function getDlqStatsEmbedded(queue: string): DlqStats;
 /** Retry DLQ jobs by filter (embedded only) */

package/dist/client/queue/dlqOps.js

@@ -18,11 +18,11 @@ export function getDlqConfigEmbedded(queue) {
     return dlqOps.getDlqConfig(queue, ctx);
 }
 /** Get DLQ entries (embedded only) */
-export function getDlqEntries(queue, filter) {
+export function getDlqEntries(queue, methods, filter) {
     const manager = getSharedManager();
     const ctx = getDlqContext(manager);
     const entries = dlqOps.getDlqEntries(queue, ctx, toDomainFilter(filter));
-    return entries.map((entry) => toDlqEntry(entry));
+    return entries.map((entry) => toDlqEntry(entry, methods));
 }
 /** Get DLQ statistics (embedded only) */
 export function getDlqStatsEmbedded(queue) {

package/dist/client/queue/jobMove.js

@@ -104,7 +104,12 @@ export async function moveJobToWaitingChildren(ctx, id, _token, _opts) {
         const manager = getSharedManager();
         return manager.moveToWaitingChildren(jobId(id));
     }
-    return false;
+    if (!ctx.tcp)
+        return false;
+    const response = await ctx.tcp.send({ cmd: 'MoveToWaitingChildren', id });
+    if (!response.ok)
+        return false;
+    return response.data?.moved ?? true;
 }
 /** Wait until job has finished */
 export async function waitJobUntilFinished(ctx, id, queueEvents, ttl) {

package/dist/client/queue/jobProxy.js

@@ -5,6 +5,7 @@
 import { getSharedManager } from '../manager';
 import { jobId } from '../../domain/types/job';
 import { buildFailCommand, failEmbeddedArgs } from './failWire';
+import { removeJobDeduplicationKey } from '../jobDeduplication';
 function reflectFields(id, queueName, meta) {
     const opts = meta?.opts ?? {};
     const p = opts.parent;
@@ -142,8 +143,9 @@ export function createJobProxy(id, name, data, ctx, meta) {
             const delay = Math.max(0, timestamp - Date.now());
             await tcp.send({ cmd: 'MoveToDelayed', id, delay });
         },
-        moveToWaitingChildren: () => {
-            return Promise.reject(new Error('moveToWaitingChildren is not supported in TCP mode — no server command available'));
+        moveToWaitingChildren: async () => {
+            const response = await tcp.send({ cmd: 'MoveToWaitingChildren', id });
+            return response.ok === true;
         },
         waitUntilFinished: async (_queueEvents, ttl) => {
             const timeout = ttl ?? 30000;
@@ -169,7 +171,7 @@ export function createJobProxy(id, name, data, ctx, meta) {
             const res = await tcp.send({ cmd: 'RemoveChildDependency', id });
             return res.removed ?? false;
         },
-        removeDeduplicationKey: () => Promise.reject(new Error('removeDeduplicationKey is not implemented — no server primitive available')),
+        removeDeduplicationKey: () => removeJobDeduplicationKey(id, false, tcp),
         removeUnprocessedChildren: async () => {
             await tcp.send({ cmd: 'RemoveUnprocessedChildren', id });
         },
@@ -398,7 +400,10 @@ export function createSimpleJob(id, name, data, timestamp, ctx) {
             if (embedded) {
                 return await getSharedManager().moveToWaitingChildren(jobId(id));
             }
-            throw new Error('moveToWaitingChildren is not supported in TCP mode — no server command available');
+            if (!tcp)
+                return false;
+            const response = await tcp.send({ cmd: 'MoveToWaitingChildren', id });
+            return response.ok === true;
         },
         waitUntilFinished: async (_qe, ttl) => {
             const timeout = ttl ?? 30000;
@@ -457,7 +462,7 @@ export function createSimpleJob(id, name, data, timestamp, ctx) {
             const res = await tcp.send({ cmd: 'RemoveChildDependency', id });
             return res.removed ?? false;
         },
-        removeDeduplicationKey: () => Promise.reject(new Error('removeDeduplicationKey is not implemented — no server primitive available')),
+        removeDeduplicationKey: () => removeJobDeduplicationKey(id, embedded ?? false, tcp),
         removeUnprocessedChildren: async () => {
             if (embedded) {
                 await getSharedManager().removeUnprocessedChildren(jobId(id));