bunqueue 2.8.53 → 2.8.56

package/dist/client/worker/ackOutcome.js

@@ -0,0 +1,58 @@
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function validatedIndices(value, size) {
+    if (!Array.isArray(value))
+        throw new Error('Invalid ACKB ignoredIndices response');
+    const seen = new Set();
+    for (const index of value) {
+        if (!Number.isInteger(index) || index < 0 || index >= size || seen.has(index)) {
+            throw new Error('Invalid ACKB ignoredIndices response');
+        }
+        seen.add(index);
+    }
+    return [...seen];
+}
+function validatedIds(value) {
+    if (!Array.isArray(value) || value.some((id) => typeof id !== 'string')) {
+        throw new Error('Invalid ACKB ignoredIds response');
+    }
+    return value;
+}
+/** Parse structured ACKB evidence, retaining duplicate job-ID positions. */
+export function ignoredAckIndices(data, batch) {
+    if (data === undefined)
+        return new Set();
+    const payload = record(data);
+    if (!payload)
+        throw new Error('Invalid ACKB response data');
+    const hasIndices = Object.hasOwn(payload, 'ignoredIndices');
+    const hasIds = Object.hasOwn(payload, 'ignoredIds');
+    if (hasIds && !hasIndices)
+        throw new Error('Invalid ACKB ignoredIndices response');
+    if (!hasIndices && !hasIds)
+        return new Set();
+    const ids = hasIds ? validatedIds(payload.ignoredIds) : null;
+    const indices = validatedIndices(payload.ignoredIndices, batch.length);
+    if (ids) {
+        if (ids.length !== indices.length)
+            throw new Error('Mismatched ACKB ignored evidence');
+        for (let offset = 0; offset < indices.length; offset++) {
+            if (batch[indices[offset]]?.id !== ids[offset]) {
+                throw new Error('Mismatched ACKB ignored evidence');
+            }
+        }
+    }
+    return new Set(indices);
+}
+/** Parse a single ACK response; normal historical responses carry no data. */
+export function outcomeWasApplied(data) {
+    if (data === undefined)
+        return true;
+    const payload = record(data);
+    if (payload?.applied === false && payload.reason === 'already-finalized')
+        return false;
+    throw new Error('Invalid ACK response data');
+}

package/dist/client/worker/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const FORCE_EMBEDDED: boolean;
+export declare const WORKER_CONSTANTS: {
+    readonly MAX_BACKOFF_MS: 30000;
+    readonly BASE_BACKOFF_MS: 100;
+    readonly MAX_POLL_TIMEOUT: 30000;
+    readonly DEFAULT_ACK_INTERVAL: 50;
+};

package/dist/client/worker/constants.js

@@ -0,0 +1,7 @@
+export const FORCE_EMBEDDED = Bun.env.BUNQUEUE_EMBEDDED === '1';
+export const WORKER_CONSTANTS = {
+    MAX_BACKOFF_MS: 30_000,
+    BASE_BACKOFF_MS: 100,
+    MAX_POLL_TIMEOUT: 30_000,
+    DEFAULT_ACK_INTERVAL: 50,
+};

package/dist/client/worker/groupConcurrency.js

@@ -9,6 +9,9 @@ export class GroupConcurrencyLimiter {
     maxPerGroup;
     activeByGroup = new Map();
     constructor(groupKey, max) {
+        if (!Number.isInteger(max) || max <= 0) {
+            throw new RangeError('Worker group limiter max must be a positive integer');
+        }
         this.groupKey = groupKey;
         this.maxPerGroup = max;
     }

package/dist/client/worker/handlers/completion.d.ts

@@ -0,0 +1,28 @@
+import type { Job as InternalJob } from '../../../domain/types/job';
+import type { AckBatcher } from '../ackBatcher';
+import type { TcpConnection } from '../types';
+export declare function computeStackLines(error: Error): {
+    stackLines: string[];
+    wireStack: string[] | undefined;
+};
+interface MoveToFailedHandlerOptions {
+    embedded: boolean;
+    tcp: TcpConnection | null;
+    internalJob: InternalJob;
+    token: string | null | undefined;
+    removeOnFail: boolean | undefined;
+    onCalled: (error: Error) => void;
+    onIgnored: () => void;
+}
+export declare function createMoveToFailedHandler(options: MoveToFailedHandlerOptions): (id: string, error: Error, _lockToken?: string) => Promise<void>;
+interface MoveToCompletedHandlerOptions {
+    embedded: boolean;
+    ackBatcher: AckBatcher;
+    internalJob: InternalJob;
+    token: string | null | undefined;
+    removeOnComplete: boolean | undefined;
+    onCalled: (value: unknown) => void;
+    onIgnored: () => void;
+}
+export declare function createMoveToCompletedHandler(options: MoveToCompletedHandlerOptions): (id: string, returnValue: unknown, _lockToken?: string) => Promise<unknown>;
+export {};

package/dist/client/worker/handlers/completion.js

@@ -0,0 +1,68 @@
+import { UnrecoverableError } from '../../errors';
+import { getSharedManager } from '../../manager';
+import { outcomeWasApplied } from '../ackOutcome';
+export function computeStackLines(error) {
+    const stackLines = error.stack
+        ? error.stack
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean)
+        : [];
+    const wireStack = stackLines.length > 0 ? stackLines.slice(0, 50) : undefined;
+    return { stackLines, wireStack };
+}
+export function createMoveToFailedHandler(options) {
+    const { embedded, tcp, internalJob, token, removeOnFail, onCalled, onIgnored } = options;
+    return async (_id, error, _lockToken) => {
+        const { wireStack } = computeStackLines(error);
+        const unrecoverable = error instanceof UnrecoverableError;
+        let applied = true;
+        if (embedded) {
+            const manager = getSharedManager();
+            const outcome = await manager.fail(internalJob.id, error.message, token ?? undefined, unrecoverable, wireStack, removeOnFail);
+            applied = outcome?.applied !== false;
+        }
+        else if (tcp) {
+            const response = await tcp.send({
+                cmd: 'FAIL',
+                id: internalJob.id,
+                error: error.message,
+                ...(wireStack ? { stack: wireStack } : {}),
+                ...(token ? { token } : {}),
+                ...(unrecoverable ? { unrecoverable: true } : {}),
+                ...(removeOnFail ? { removeOnFail: true } : {}),
+            });
+            if (response.ok !== true) {
+                throw new Error(typeof response.error === 'string' ? response.error : 'FAIL failed');
+            }
+            applied = outcomeWasApplied(response.data);
+        }
+        if (!applied) {
+            onIgnored();
+            return;
+        }
+        onCalled(error);
+    };
+}
+export function createMoveToCompletedHandler(options) {
+    const { embedded, ackBatcher, internalJob, token, removeOnComplete, onCalled, onIgnored } = options;
+    return async (_id, returnValue, _lockToken) => {
+        let applied = true;
+        if (embedded) {
+            const manager = getSharedManager();
+            const outcome = await manager.ack(internalJob.id, returnValue, token ?? undefined, {
+                removeOnComplete,
+            });
+            applied = outcome?.applied !== false;
+        }
+        else {
+            applied = await ackBatcher.queue(String(internalJob.id), returnValue, token ?? undefined, removeOnComplete);
+        }
+        if (!applied) {
+            onIgnored();
+            return null;
+        }
+        onCalled(returnValue);
+        return null;
+    };
+}

package/dist/client/worker/handlers/dependencies.d.ts

@@ -0,0 +1,11 @@
+import { type Job as InternalJob } from '../../../domain/types/job';
+import type { JobDependencies, JobDependenciesCount } from '../../types';
+import type { PendingTransitionSettlement, TcpConnection } from '../types';
+export declare function createWaitUntilFinishedHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, _queueEvents: unknown, ttl?: number) => Promise<unknown>;
+export declare function createDiscardHandler(embedded: boolean, tcp: TcpConnection | null, options?: {
+    token?: string;
+    onPending?: (pending: Promise<PendingTransitionSettlement>) => void;
+}): (id: string) => void;
+export declare function createGetDependenciesHandler(embedded: boolean, tcp: TcpConnection | null, internalJob: InternalJob): (_id: string) => Promise<JobDependencies>;
+export declare function createGetDependenciesCountHandler(embedded: boolean, tcp: TcpConnection | null, internalJob: InternalJob): (_id: string) => Promise<JobDependenciesCount>;
+export declare function createRemoveDeduplicationKeyHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<boolean>;

package/dist/client/worker/handlers/dependencies.js

@@ -0,0 +1,107 @@
+import { jobId } from '../../../domain/types/job';
+import { removeJobDeduplicationKey } from '../../jobDeduplication';
+import { getSharedManager } from '../../manager';
+export function createWaitUntilFinishedHandler(embedded, tcp) {
+    return async (id, _queueEvents, ttl) => {
+        const timeout = ttl ?? 30000;
+        if (embedded) {
+            const manager = getSharedManager();
+            const job = await manager.getJob(jobId(id));
+            if (!job)
+                throw new Error(`Job ${id} not found`);
+            if (job.completedAt)
+                return manager.getResult(jobId(id));
+            const completed = await manager.waitForJobCompletion(jobId(id), timeout);
+            if (!completed)
+                throw new Error(`waitUntilFinished timed out after ${timeout}ms`);
+            return manager.getResult(jobId(id));
+        }
+        if (!tcp)
+            throw new Error('waitUntilFinished: no connection');
+        const response = await tcp.send({ cmd: 'WaitJob', id, timeout });
+        const result = response;
+        if (!result.completed)
+            throw new Error(`waitUntilFinished timed out after ${timeout}ms`);
+        return result.result;
+    };
+}
+export function createDiscardHandler(embedded, tcp, options = {}) {
+    let pending = null;
+    return (id) => {
+        if (pending)
+            return;
+        const operation = (async () => {
+            try {
+                if (embedded) {
+                    const applied = await getSharedManager().discard(jobId(id), options.token);
+                    return { status: applied ? 'applied' : 'ignored' };
+                }
+                if (!tcp)
+                    return { status: 'failed', error: new Error('Discard: no connection') };
+                const response = await tcp.send({
+                    cmd: 'Discard',
+                    id,
+                    ...(options.token === undefined ? {} : { token: options.token }),
+                });
+                if (response.ok === true)
+                    return { status: 'applied' };
+                const message = typeof response.error === 'string' ? response.error : 'Discard failed';
+                if (/not found|not active|not in processing/i.test(message))
+                    return { status: 'ignored' };
+                return { status: 'failed', error: new Error(message) };
+            }
+            catch (error) {
+                return {
+                    status: 'failed',
+                    error: error instanceof Error ? error : new Error(String(error)),
+                };
+            }
+        })();
+        pending = operation;
+        options.onPending?.(operation);
+    };
+}
+export function createGetDependenciesHandler(embedded, tcp, internalJob) {
+    return async () => {
+        const childIds = internalJob.childrenIds;
+        const processed = {};
+        const unprocessed = [];
+        for (const childId of childIds) {
+            let state = 'unknown';
+            let result;
+            if (embedded) {
+                const manager = getSharedManager();
+                state = await manager.getJobState(childId);
+                if (state === 'completed')
+                    result = manager.getResult(childId);
+            }
+            else if (tcp) {
+                const stateResponse = await tcp.send({ cmd: 'GetState', id: String(childId) });
+                state = stateResponse.state ?? 'unknown';
+                if (state === 'completed') {
+                    const resultResponse = await tcp.send({ cmd: 'GetResult', id: String(childId) });
+                    result = resultResponse.result;
+                }
+            }
+            const key = `${internalJob.queue}:${String(childId)}`;
+            if (state === 'completed' || state === 'failed')
+                processed[key] = result ?? null;
+            else
+                unprocessed.push(key);
+        }
+        return { processed, unprocessed };
+    };
+}
+export function createGetDependenciesCountHandler(embedded, tcp, internalJob) {
+    const getDependencies = createGetDependenciesHandler(embedded, tcp, internalJob);
+    return async (id) => {
+        const dependencies = await getDependencies(id);
+        return {
+            processed: Object.keys(dependencies.processed).length,
+            unprocessed: dependencies.unprocessed.length,
+        };
+    };
+}
+export function createRemoveDeduplicationKeyHandler(embedded, tcp) {
+    return (id) => removeJobDeduplicationKey(id, embedded, tcp);
+}

package/dist/client/worker/handlers/mutations.d.ts

@@ -0,0 +1,23 @@
+import { type Job as InternalJob } from '../../../domain/types/job';
+import type { ChangePriorityOpts } from '../../types';
+import type { TcpConnection } from '../types';
+export declare function createRemoveHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<void>;
+export declare function createRetryHandler(embedded: boolean, tcp: TcpConnection | null, options: {
+    internalJob: InternalJob;
+    token?: string;
+    onTransitionApplied?: () => void;
+}): (id: string) => Promise<void>;
+export declare function createUpdateDataHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, data: unknown) => Promise<void>;
+export declare function createPromoteHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<void>;
+export declare function createChangeDelayHandler(embedded: boolean, tcp: TcpConnection | null, token?: string, onTransitionApplied?: () => void): (id: string, delay: number) => Promise<void>;
+export declare function createChangePriorityHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, options: ChangePriorityOpts) => Promise<void>;
+export declare function createExtendLockHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, token: string, duration: number) => Promise<number>;
+export declare function createClearLogsHandler(embedded: boolean, tcp: TcpConnection | null): (id: string, keepLogs?: number) => Promise<void>;
+export declare function createMoveToWaitHandler(embedded: boolean, tcp: TcpConnection | null, onTransitionApplied?: () => void): (id: string, token?: string) => Promise<boolean>;
+export declare function createMoveToDelayedHandler(embedded: boolean, tcp: TcpConnection | null, onTransitionApplied?: () => void): (id: string, timestamp: number, token?: string) => Promise<void>;
+export declare function createMoveToWaitingChildrenHandler(embedded: boolean, tcp: TcpConnection | null, onTransitionApplied?: () => void): (id: string, token?: string, _opts?: {
+    child?: {
+        id: string;
+        queue: string;
+    };
+}) => Promise<boolean>;

package/dist/client/worker/handlers/mutations.js

@@ -0,0 +1,211 @@
+import { jobId } from '../../../domain/types/job';
+import { getSharedManager } from '../../manager';
+import { assertFlowTcpOk } from '../../flowJobTypes';
+function tokenError(response) {
+    if (response.ok === false && /token/i.test(String(response.error))) {
+        return new Error(typeof response.error === 'string' ? response.error : 'Invalid lock token');
+    }
+    return null;
+}
+export function createRemoveHandler(embedded, tcp) {
+    return async (id) => {
+        if (embedded) {
+            await getSharedManager().cancel(jobId(id));
+            return;
+        }
+        if (!tcp)
+            return;
+        await tcp.send({ cmd: 'Cancel', id });
+    };
+}
+export function createRetryHandler(embedded, tcp, options) {
+    const { internalJob, token, onTransitionApplied } = options;
+    return async (id) => {
+        if (embedded) {
+            const manager = getSharedManager();
+            const state = await manager.getJobState(jobId(id));
+            if (state === 'failed') {
+                const count = manager.retryDlq(internalJob.queue, jobId(id));
+                if (count === 0)
+                    throw new Error(`Job ${id} is failed but not present in DLQ`);
+                onTransitionApplied?.();
+                return;
+            }
+            if (state === 'active') {
+                const ok = await manager.moveActiveToWait(jobId(id), token);
+                if (!ok)
+                    throw new Error(`Failed to retry active job ${id}`);
+                onTransitionApplied?.();
+                return;
+            }
+            if (state === 'waiting' || state === 'prioritized' || state === 'delayed')
+                return;
+            throw new Error(`Cannot retry job ${id} from state '${state}'`);
+        }
+        if (!tcp)
+            return;
+        const response = await tcp.send({
+            cmd: 'MoveToWait',
+            id,
+            ...(token === undefined ? {} : { token }),
+        });
+        if (response.ok !== true) {
+            const error = typeof response.error === 'string' ? response.error : 'retry failed';
+            throw new Error(error);
+        }
+        onTransitionApplied?.();
+    };
+}
+export function createUpdateDataHandler(embedded, tcp) {
+    return async (id, data) => {
+        if (embedded) {
+            await getSharedManager().updateJobData(jobId(id), data);
+            return;
+        }
+        if (!tcp)
+            return;
+        assertFlowTcpOk(await tcp.send({ cmd: 'Update', id, data }), 'Update');
+    };
+}
+export function createPromoteHandler(embedded, tcp) {
+    return async (id) => {
+        if (embedded) {
+            await getSharedManager().promote(jobId(id));
+            return;
+        }
+        if (!tcp)
+            return;
+        await tcp.send({ cmd: 'Promote', id });
+    };
+}
+export function createChangeDelayHandler(embedded, tcp, token, onTransitionApplied) {
+    return async (id, delay) => {
+        if (embedded) {
+            const changed = await getSharedManager().changeDelay(jobId(id), delay, token);
+            if (!changed)
+                throw new Error(`Failed to change delay for job ${id}`);
+            onTransitionApplied?.();
+            return;
+        }
+        if (!tcp)
+            return;
+        assertFlowTcpOk(await tcp.send({
+            cmd: 'ChangeDelay',
+            id,
+            delay,
+            ...(token === undefined ? {} : { token }),
+        }), 'ChangeDelay');
+        onTransitionApplied?.();
+    };
+}
+export function createChangePriorityHandler(embedded, tcp) {
+    return async (id, options) => {
+        if (embedded) {
+            await getSharedManager().changePriority(jobId(id), options.priority, options.lifo);
+            return;
+        }
+        if (!tcp)
+            return;
+        await tcp.send({
+            cmd: 'ChangePriority',
+            id,
+            priority: options.priority,
+            lifo: options.lifo,
+        });
+    };
+}
+export function createExtendLockHandler(embedded, tcp) {
+    return async (id, token, duration) => {
+        if (embedded) {
+            const ok = await getSharedManager().extendLock(jobId(id), token, duration);
+            return ok ? duration : 0;
+        }
+        if (!tcp)
+            return 0;
+        const response = await tcp.send({ cmd: 'ExtendLock', id, token, duration });
+        return response.ok === true ? duration : 0;
+    };
+}
+export function createClearLogsHandler(embedded, tcp) {
+    return async (id, keepLogs) => {
+        if (embedded) {
+            getSharedManager().clearLogs(jobId(id), keepLogs);
+            return;
+        }
+        if (!tcp)
+            return;
+        await tcp.send({ cmd: 'ClearLogs', id, keepLogs });
+    };
+}
+export function createMoveToWaitHandler(embedded, tcp, onTransitionApplied) {
+    return async (id, token) => {
+        if (embedded) {
+            const moved = await getSharedManager().moveActiveToWait(jobId(id), token);
+            if (moved)
+                onTransitionApplied?.();
+            return moved;
+        }
+        if (!tcp)
+            return false;
+        const response = await tcp.send({
+            cmd: 'MoveToWait',
+            id,
+            ...(token === undefined ? {} : { token }),
+        });
+        const error = tokenError(response);
+        if (error)
+            throw error;
+        const moved = response.ok === true;
+        if (moved)
+            onTransitionApplied?.();
+        return moved;
+    };
+}
+export function createMoveToDelayedHandler(embedded, tcp, onTransitionApplied) {
+    return async (id, timestamp, token) => {
+        const delay = Math.max(0, timestamp - Date.now());
+        if (embedded) {
+            const moved = await getSharedManager().moveToDelayed(jobId(id), delay, token);
+            if (!moved)
+                throw new Error(`Failed to move job ${id} to delayed`);
+            onTransitionApplied?.();
+            return;
+        }
+        if (!tcp)
+            return;
+        const response = await tcp.send({
+            cmd: 'MoveToDelayed',
+            id,
+            delay,
+            ...(token === undefined ? {} : { token }),
+        });
+        if (response.ok !== true) {
+            throw new Error(typeof response.error === 'string' ? response.error : 'Failed to move job to delayed');
+        }
+        onTransitionApplied?.();
+    };
+}
+export function createMoveToWaitingChildrenHandler(embedded, tcp, onTransitionApplied) {
+    return async (id, token) => {
+        if (embedded) {
+            const moved = await getSharedManager().moveToWaitingChildren(jobId(id), token);
+            if (moved)
+                onTransitionApplied?.();
+            return moved;
+        }
+        if (!tcp)
+            return false;
+        const response = await tcp.send({
+            cmd: 'MoveToWaitingChildren',
+            id,
+            ...(token === undefined ? {} : { token }),
+        });
+        const error = tokenError(response);
+        if (error)
+            throw error;
+        const moved = response.ok === true;
+        if (moved)
+            onTransitionApplied?.();
+        return moved;
+    };
+}

package/dist/client/worker/handlers/queries.d.ts

@@ -0,0 +1,15 @@
+import type { EventEmitter } from 'events';
+import type { FlowJobData, Job, JobStateType } from '../../types';
+import type { TcpConnection } from '../types';
+export declare function createProgressHandler<T extends FlowJobData>(embedded: boolean, tcp: TcpConnection | null, emitter: EventEmitter, jobHolder: {
+    current: Job<T> | null;
+}): (id: string, progress: number, message?: string) => Promise<void>;
+export declare function createLogHandler<T extends FlowJobData>(embedded: boolean, tcp: TcpConnection | null, emitter: EventEmitter, jobHolder: {
+    current: Job<T> | null;
+}): (id: string, message: string) => Promise<void>;
+export declare function createGetStateHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<JobStateType>;
+export declare function createGetChildrenValuesHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<Record<string, unknown>>;
+export declare function createGetFailedChildrenValuesHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<Record<string, string>>;
+export declare function createGetIgnoredChildrenFailuresHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<Record<string, string>>;
+export declare function createRemoveChildDependencyHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<boolean>;
+export declare function createRemoveUnprocessedChildrenHandler(embedded: boolean, tcp: TcpConnection | null): (id: string) => Promise<void>;

package/dist/client/worker/handlers/queries.js

@@ -0,0 +1,100 @@
+import { jobId } from '../../../domain/types/job';
+import { getSharedManager } from '../../manager';
+export function createProgressHandler(embedded, tcp, emitter, jobHolder) {
+    return async (id, progress, message) => {
+        if (embedded) {
+            const manager = getSharedManager();
+            await manager.updateProgress(jobId(id), progress, message);
+        }
+        else if (tcp) {
+            await tcp.send({ cmd: 'Progress', id, progress, message });
+        }
+        emitter.emit('progress', jobHolder.current, progress);
+    };
+}
+export function createLogHandler(embedded, tcp, emitter, jobHolder) {
+    return async (id, message) => {
+        if (embedded) {
+            const manager = getSharedManager();
+            manager.addLog(jobId(id), message);
+        }
+        else if (tcp) {
+            await tcp.send({ cmd: 'AddLog', id, message });
+        }
+        emitter.emit('log', jobHolder.current, message);
+    };
+}
+export function createGetStateHandler(embedded, tcp) {
+    return async (id) => {
+        if (embedded) {
+            const manager = getSharedManager();
+            return (await manager.getJobState(jobId(id)));
+        }
+        else if (tcp) {
+            const response = await tcp.send({ cmd: 'GetState', id });
+            return (response.state ?? 'unknown');
+        }
+        return 'unknown';
+    };
+}
+export function createGetChildrenValuesHandler(embedded, tcp) {
+    return async (id) => {
+        if (embedded) {
+            const manager = getSharedManager();
+            return manager.getChildrenValues(jobId(id));
+        }
+        else if (tcp) {
+            const response = await tcp.send({ cmd: 'GetChildrenValues', id });
+            const data = response.data;
+            return data?.values ?? {};
+        }
+        return {};
+    };
+}
+export function createGetFailedChildrenValuesHandler(embedded, tcp) {
+    return async (id) => {
+        if (embedded) {
+            const manager = getSharedManager();
+            return manager.getFailedChildrenValues(jobId(id));
+        }
+        if (!tcp)
+            return {};
+        const response = await tcp.send({ cmd: 'GetFailedChildrenValues', id });
+        return response.values ?? {};
+    };
+}
+export function createGetIgnoredChildrenFailuresHandler(embedded, tcp) {
+    return async (id) => {
+        if (embedded) {
+            const manager = getSharedManager();
+            return manager.getIgnoredChildrenFailures(jobId(id));
+        }
+        if (!tcp)
+            return {};
+        const response = await tcp.send({ cmd: 'GetIgnoredChildrenFailures', id });
+        return response.values ?? {};
+    };
+}
+export function createRemoveChildDependencyHandler(embedded, tcp) {
+    return async (id) => {
+        if (embedded) {
+            const manager = getSharedManager();
+            return manager.removeChildDependency(jobId(id));
+        }
+        if (!tcp)
+            return false;
+        const response = await tcp.send({ cmd: 'RemoveChildDependency', id });
+        return response.ok === true;
+    };
+}
+export function createRemoveUnprocessedChildrenHandler(embedded, tcp) {
+    return async (id) => {
+        if (embedded) {
+            const manager = getSharedManager();
+            return manager.removeUnprocessedChildren(jobId(id));
+        }
+        if (!tcp)
+            return;
+        await tcp.send({ cmd: 'RemoveUnprocessedChildren', id });
+    };
+}

package/dist/client/worker/index.d.ts

@@ -2,8 +2,8 @@
  * Worker Module
  * Re-exports all worker components
  */
-export type { PendingAck, ExtendedWorkerOptions, TcpConnection } from './types';
-export { FORCE_EMBEDDED, WORKER_CONSTANTS } from './types';
+export type { PendingAck, ExtendedWorkerOptions, ManualJob, TcpConnection } from './types';
+export { FORCE_EMBEDDED, WORKER_CONSTANTS } from './constants';
 export { AckBatcher, type AckBatcherConfig } from './ackBatcher';
 export { parseJobFromResponse } from './jobParser';
 export { processJob, type ProcessorConfig } from './processor';

package/dist/client/worker/index.js

@@ -2,7 +2,7 @@
  * Worker Module
  * Re-exports all worker components
  */
-export { FORCE_EMBEDDED, WORKER_CONSTANTS } from './types';
+export { FORCE_EMBEDDED, WORKER_CONSTANTS } from './constants';
 export { AckBatcher } from './ackBatcher';
 export { parseJobFromResponse } from './jobParser';
 export { processJob } from './processor';