bunqueue 2.8.0 → 2.8.2

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

@@ -68,6 +68,9 @@ export async function add(ctx, jobName, data, opts = {}) {
             sizeLimit: merged.sizeLimit,
             failParentOnFailure: merged.failParentOnFailure,
             removeDependencyOnFailure: merged.removeDependencyOnFailure,
+            continueParentOnFailure: merged.continueParentOnFailure,
+            ignoreDependencyOnFailure: merged.ignoreDependencyOnFailure,
+            timestamp: merged.timestamp,
             debounceId: merged.debounce?.id,
             debounceTtl: merged.debounce?.ttl,
         });
@@ -94,25 +97,9 @@ export async function add(ctx, jobName, data, opts = {}) {
             waitUntilFinished: (jid, queueEvents, ttl) => ctx.waitJobUntilFinished(jid, queueEvents, ttl),
         });
     }
-    // TCP mode
+    // TCP mode — forward the full option set so nothing is silently dropped (#88)
     const tcp = ctx.tcp;
-    const response = await tcp.send({
-        cmd: 'PUSH',
-        queue: ctx.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,
-    });
+    const response = await tcp.send(buildPushPayload(ctx.name, jobData, merged));
     if (!response.ok) {
         throw new Error(response.error ?? 'Failed to add job');
     }
@@ -124,27 +111,111 @@ export async function add(ctx, jobName, data, opts = {}) {
         removeAsync: ctx.removeAsync,
         retryJob: ctx.retryJob,
         getChildrenValues: ctx.getChildrenValues,
+    }, { priority: merged.priority, delay: merged.delay, opts: merged });
+}
+/**
+ * Strip undefined-valued keys so the msgpack frame stays compact. Sending a
+ * field as `undefined` still serializes a nil entry; for large batches this
+ * bloats the frame (and intermittently trips large-frame delivery). Omitting
+ * undefined keeps option-less jobs minimal while still forwarding real options.
+ */
+function compact(obj) {
+    const out = {};
+    for (const k in obj) {
+        if (obj[k] !== undefined)
+            out[k] = obj[k];
+    }
+    return out;
+}
+/** Build the compacted PUSH command payload, forwarding the full option set (#88) */
+function buildPushPayload(queue, jobData, m) {
+    return compact({
+        cmd: 'PUSH',
+        queue,
+        data: jobData,
+        priority: m.priority,
+        delay: m.delay,
+        maxAttempts: m.attempts,
+        backoff: m.backoff,
+        ttl: m.ttl,
+        timeout: m.timeout,
+        jobId: m.jobId,
+        uniqueKey: m.deduplication?.id,
+        dedup: m.deduplication
+            ? {
+                ttl: m.deduplication.ttl,
+                extend: m.deduplication.extend,
+                replace: m.deduplication.replace,
+            }
+            : undefined,
+        dependsOn: m.dependsOn,
+        tags: m.tags,
+        groupId: m.groupId,
+        lifo: m.lifo,
+        // Coerce to boolean for parity with embedded (which ignores non-boolean). #90
+        removeOnComplete: typeof m.removeOnComplete === 'boolean' ? m.removeOnComplete : undefined,
+        removeOnFail: typeof m.removeOnFail === 'boolean' ? m.removeOnFail : undefined,
+        stallTimeout: m.stallTimeout,
+        stackTraceLimit: m.stackTraceLimit,
+        keepLogs: m.keepLogs,
+        sizeLimit: m.sizeLimit,
+        failParentOnFailure: m.failParentOnFailure,
+        removeDependencyOnFailure: m.removeDependencyOnFailure,
+        continueParentOnFailure: m.continueParentOnFailure,
+        ignoreDependencyOnFailure: m.ignoreDependencyOnFailure,
+        debounceId: m.debounce?.id,
+        debounceTtl: m.debounce?.ttl,
+        timestamp: m.timestamp,
+        durable: m.durable,
+        repeat: m.repeat,
+        parentId: m.parent?.id,
     });
 }
+/** Build the data payload for a bulk job, injecting parent refs when present */
+function buildBulkData(name, data, m) {
+    const jobData = { name, ...data };
+    if (m.parent) {
+        jobData.__parentId = m.parent.id;
+        jobData.__parentQueue = m.parent.queue;
+    }
+    return jobData;
+}
+/** Reflection meta so the returned bulk Job reflects the requested options (#88) */
+function reflectionMeta(m) {
+    return { priority: m.priority, delay: m.delay, opts: m };
+}
 /** Add multiple jobs in bulk */
 export async function addBulk(ctx, jobs) {
     if (jobs.length === 0)
         return [];
     const now = Date.now();
+    // Merge defaults once per job so input building and reflection stay in sync
+    const merged = jobs.map(({ opts }) => ({
+        ...ctx.opts.defaultJobOptions,
+        ...opts,
+    }));
     if (ctx.embedded) {
         const manager = getSharedManager();
-        const inputs = jobs.map(({ name, data, opts }) => {
-            const m = { ...ctx.opts.defaultJobOptions, ...opts };
+        const inputs = jobs.map(({ name, data }, i) => {
+            const m = merged[i];
             const removeOnComplete = typeof m.removeOnComplete === 'boolean' ? m.removeOnComplete : false;
             const removeOnFail = typeof m.removeOnFail === 'boolean' ? m.removeOnFail : false;
             return {
-                data: { name, ...data },
+                data: buildBulkData(name, data, m),
                 priority: m.priority,
                 delay: m.delay,
                 maxAttempts: m.attempts,
                 backoff: m.backoff,
                 timeout: m.timeout,
+                ttl: m.ttl,
                 customId: m.jobId,
+                uniqueKey: m.deduplication?.id,
+                dependsOn: m.dependsOn?.map((id) => jobId(id)),
+                parentId: m.parent ? jobId(m.parent.id) : undefined,
+                tags: m.tags,
+                groupId: m.groupId,
+                stallTimeout: m.stallTimeout,
+                timestamp: m.timestamp,
                 removeOnComplete,
                 removeOnFail,
                 repeat: m.repeat
@@ -170,6 +241,15 @@ export async function addBulk(ctx, jobs) {
                 sizeLimit: m.sizeLimit,
                 failParentOnFailure: m.failParentOnFailure,
                 removeDependencyOnFailure: m.removeDependencyOnFailure,
+                continueParentOnFailure: m.continueParentOnFailure,
+                ignoreDependencyOnFailure: m.ignoreDependencyOnFailure,
+                dedup: m.deduplication
+                    ? {
+                        ttl: m.deduplication.ttl,
+                        extend: m.deduplication.extend,
+                        replace: m.deduplication.replace,
+                    }
+                    : undefined,
                 debounceId: m.debounce?.id,
                 debounceTtl: m.debounce?.ttl,
             };
@@ -177,18 +257,23 @@ export async function addBulk(ctx, jobs) {
         const ids = await manager.pushBatch(ctx.name, inputs);
         return ids.map((id, i) => createSimpleJob(String(id), jobs[i].name, jobs[i].data, now, {
             queueName: ctx.name,
+            embedded: ctx.embedded,
+            tcp: ctx.tcp,
             getJobState: ctx.getJobState,
             removeAsync: ctx.removeAsync,
             retryJob: ctx.retryJob,
             getChildrenValues: ctx.getChildrenValues,
+            meta: reflectionMeta(merged[i]),
         }));
     }
     // TCP mode
     const tcp = ctx.tcp;
-    const batchJobs = jobs.map(({ name, data, opts }) => {
-        const m = { ...ctx.opts.defaultJobOptions, ...opts };
-        return {
-            data: { name, ...data },
+    const batchJobs = jobs.map(({ name, data }, i) => {
+        const m = merged[i];
+        const removeOnComplete = typeof m.removeOnComplete === 'boolean' ? m.removeOnComplete : false;
+        const removeOnFail = typeof m.removeOnFail === 'boolean' ? m.removeOnFail : false;
+        return compact({
+            data: buildBulkData(name, data, m),
             priority: m.priority,
             delay: m.delay,
             maxAttempts: m.attempts,
@@ -198,6 +283,8 @@ export async function addBulk(ctx, jobs) {
             customId: m.jobId,
             tags: m.tags,
             groupId: m.groupId,
+            dependsOn: m.dependsOn?.map((id) => jobId(id)),
+            parentId: m.parent ? jobId(m.parent.id) : undefined,
             uniqueKey: m.deduplication?.id,
             dedup: m.deduplication
                 ? {
@@ -208,6 +295,9 @@ export async function addBulk(ctx, jobs) {
                 : undefined,
             lifo: m.lifo,
             stallTimeout: m.stallTimeout,
+            timestamp: m.timestamp,
+            removeOnComplete,
+            removeOnFail,
             repeat: m.repeat,
             durable: m.durable,
             stackTraceLimit: m.stackTraceLimit,
@@ -215,17 +305,24 @@ export async function addBulk(ctx, jobs) {
             sizeLimit: m.sizeLimit,
             failParentOnFailure: m.failParentOnFailure,
             removeDependencyOnFailure: m.removeDependencyOnFailure,
+            continueParentOnFailure: m.continueParentOnFailure,
+            ignoreDependencyOnFailure: m.ignoreDependencyOnFailure,
             debounceId: m.debounce?.id,
             debounceTtl: m.debounce?.ttl,
-        };
+        });
     });
     const response = await tcp.send({
         cmd: 'PUSHB',
         queue: ctx.name,
         jobs: batchJobs,
     });
-    if (!response.ok)
-        return [];
+    // Mirror the single-PUSH path (~line 168): a rejected response (e.g. auth
+    // failure) must propagate as a thrown error so the AddBatcher rejects the
+    // queued callers, instead of resolving them with undefined jobs. An OK
+    // response with zero jobs is a legitimate empty result and is NOT an error.
+    if (!response.ok) {
+        throw new Error(response.error ?? 'Failed to add jobs');
+    }
     const ids = (response.ids ?? []);
     return ids.map((id, i) => createJobProxy(id, jobs[i].name, jobs[i].data, {
         queueName: ctx.name,
@@ -234,7 +331,7 @@ export async function addBulk(ctx, jobs) {
         removeAsync: ctx.removeAsync,
         retryJob: ctx.retryJob,
         getChildrenValues: ctx.getChildrenValues,
-    }));
+    }, reflectionMeta(merged[i])));
 }
 function parseDate(date) {
     if (date instanceof Date)
@@ -243,4 +340,3 @@ function parseDate(date) {
         return new Date(date).getTime();
     return date;
 }
-//# sourceMappingURL=add.js.map

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

@@ -23,4 +23,3 @@ export declare function isPausedAsync(ctx: ControlContext): Promise<boolean>;
 /** Wait until queue is ready */
 export declare function waitUntilReady(ctx: ControlContext): Promise<void>;
 export {};
-//# sourceMappingURL=control.d.ts.map

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

@@ -53,4 +53,3 @@ export async function waitUntilReady(ctx) {
     if (ctx.tcp)
         await ctx.tcp.send({ cmd: 'Ping' });
 }
-//# sourceMappingURL=control.js.map

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

@@ -40,4 +40,3 @@ export declare function getCountsPerPriority(ctx: CountsContext): Record<number,
 /** Get counts grouped by priority (async) */
 export declare function getCountsPerPriorityAsync(ctx: CountsContext): Promise<Record<number, number>>;
 export {};
-//# sourceMappingURL=counts.d.ts.map

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

@@ -121,4 +121,3 @@ export async function getCountsPerPriorityAsync(ctx) {
         return {};
     return (response.counts ?? {});
 }
-//# sourceMappingURL=counts.js.map

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

@@ -7,4 +7,3 @@ export * from './query';
 export * from './counts';
 export * from './control';
 export * from './management';
-//# sourceMappingURL=index.d.ts.map

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

@@ -7,4 +7,3 @@ export * from './query';
 export * from './counts';
 export * from './control';
 export * from './management';
-//# sourceMappingURL=index.js.map

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

@@ -12,7 +12,7 @@ interface ManagementContext {
 export declare function remove(ctx: ManagementContext, id: string): void;
 /** Remove a job (async) */
 export declare function removeAsync(ctx: ManagementContext, id: string): Promise<void>;
-/** Retry a specific job */
+/** Retry a specific job — BullMQ contract: failed → waiting. */
 export declare function retryJob(ctx: ManagementContext, id: string): Promise<void>;
 /** Retry jobs matching criteria */
 export declare function retryJobs(ctx: ManagementContext, opts?: {
@@ -53,4 +53,3 @@ export declare function changeJobPriority(ctx: ManagementContext, id: string, op
 /** Extend job lock */
 export declare function extendJobLock(ctx: ManagementContext, id: string, token: string, duration: number): Promise<number>;
 export {};
-//# sourceMappingURL=management.d.ts.map

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

@@ -22,13 +22,32 @@ export async function removeAsync(ctx, id) {
     await ctx.tcp.send({ cmd: 'Cancel', id });
 }
 // ============ Retry Operations ============
-/** Retry a specific job */
+/** Retry a specific job — BullMQ contract: failed → waiting. */
 export async function retryJob(ctx, id) {
     if (ctx.embedded) {
-        getSharedManager().retryDlq(ctx.name, jobId(id));
-        return;
+        const mgr = getSharedManager();
+        const state = await mgr.getJobState(jobId(id));
+        if (state === 'failed') {
+            const count = mgr.retryDlq(ctx.name, jobId(id));
+            if (count === 0)
+                throw new Error(`Job ${id} is failed but not present in DLQ`);
+            return;
+        }
+        if (state === 'active') {
+            const ok = await mgr.moveActiveToWait(jobId(id));
+            if (!ok)
+                throw new Error(`Failed to retry active job ${id}`);
+            return;
+        }
+        if (state === 'waiting' || state === 'prioritized' || state === 'delayed')
+            return;
+        throw new Error(`Cannot retry job ${id} from state '${state}'`);
+    }
+    const res = await ctx.tcp.send({ cmd: 'MoveToWait', id });
+    if (res.ok !== true) {
+        const err = typeof res.error === 'string' ? res.error : 'retry failed';
+        throw new Error(err);
     }
-    await ctx.tcp.send({ cmd: 'RetryDlq', queue: ctx.name, id });
 }
 /** Retry jobs matching criteria */
 export async function retryJobs(ctx, opts) {
@@ -47,8 +66,7 @@ export async function retryJobs(ctx, opts) {
 export function clean(ctx, grace, limit, type) {
     if (!ctx.embedded)
         return [];
-    const count = getSharedManager().clean(ctx.name, grace, type, limit);
-    return new Array(count).fill('');
+    return getSharedManager().clean(ctx.name, grace, type, limit);
 }
 /** Clean old jobs (async) */
 export async function cleanAsync(ctx, grace, limit, type) {
@@ -156,7 +174,7 @@ export async function updateJobData(ctx, id, data) {
 /** Change job delay */
 export async function changeJobDelay(ctx, id, delay) {
     if (ctx.embedded) {
-        // Not directly supported in embedded mode
+        await getSharedManager().changeDelay(jobId(id), delay);
         return;
     }
     await ctx.tcp.send({ cmd: 'ChangeDelay', id, delay });
@@ -164,10 +182,10 @@ export async function changeJobDelay(ctx, id, delay) {
 /** Change job priority */
 export async function changeJobPriority(ctx, id, opts) {
     if (ctx.embedded) {
-        await getSharedManager().changePriority(jobId(id), opts.priority);
+        await getSharedManager().changePriority(jobId(id), opts.priority, opts.lifo);
         return;
     }
-    await ctx.tcp.send({ cmd: 'ChangePriority', id, priority: opts.priority });
+    await ctx.tcp.send({ cmd: 'ChangePriority', id, priority: opts.priority, lifo: opts.lifo });
 }
 /** Extend job lock */
 export async function extendJobLock(ctx, id, token, duration) {
@@ -178,4 +196,3 @@ export async function extendJobLock(ctx, id, token, duration) {
     const response = await ctx.tcp.send({ cmd: 'ExtendLock', id, token, duration });
     return response.ok ? duration : 0;
 }
-//# sourceMappingURL=management.js.map

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

@@ -17,11 +17,23 @@ interface QueryContext {
     changeJobDelay?: (id: string, delay: number) => Promise<void>;
     changeJobPriority?: (id: string, opts: {
         priority: number;
+        lifo?: boolean;
     }) => Promise<void>;
     extendJobLock?: (id: string, token: string, duration: number) => Promise<number>;
     clearJobLogs?: (id: string, keepLogs?: number) => Promise<void>;
     getJobDependencies?: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependencies>;
     getJobDependenciesCount?: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependenciesCount>;
+    moveJobToCompleted?: (id: string, returnValue: unknown, token?: string) => Promise<unknown>;
+    moveJobToFailed?: (id: string, error: Error, token?: string) => Promise<void>;
+    moveJobToWait?: (id: string, token?: string) => Promise<boolean>;
+    moveJobToDelayed?: (id: string, timestamp: number, token?: string) => Promise<void>;
+    moveJobToWaitingChildren?: (id: string, token?: string, opts?: {
+        child?: {
+            id: string;
+            queue: string;
+        };
+    }) => Promise<boolean>;
+    waitJobUntilFinished?: (id: string, queueEvents: unknown, ttl?: number) => Promise<unknown>;
 }
 /** Get a single job by ID */
 export declare function getJob<T>(ctx: QueryContext, id: string): Promise<Job<T> | null>;
@@ -55,4 +67,3 @@ export declare function getCompletedAsync<T>(ctx: QueryContext, start?: number,
 export declare function getFailed<T>(ctx: QueryContext, start?: number, end?: number): Job<T>[];
 export declare function getFailedAsync<T>(ctx: QueryContext, start?: number, end?: number): Promise<Job<T>[]>;
 export {};
-//# sourceMappingURL=query.d.ts.map

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

@@ -7,6 +7,12 @@ import { getSharedManager } from '../../manager';
 import { toPublicJob } from '../../types';
 import { jobId } from '../../../domain/types/job';
 import { createSimpleJob } from '../jobProxy';
+import { buildJobOpts } from '../../jobHelpers';
+/** Build reflection meta (priority/delay/opts) from an internal job shape */
+function metaFromJob(job) {
+    const opts = buildJobOpts(job);
+    return { priority: job.priority ?? 0, delay: opts.delay ?? 0, opts };
+}
 /** Get a single job by ID */
 export async function getJob(ctx, id) {
     if (ctx.embedded) {
@@ -14,8 +20,9 @@ export async function getJob(ctx, id) {
         if (!job)
             return null;
         const name = job.data?.name ?? 'unknown';
-        // Use toPublicJob if extended context is available (for full opts support)
+        // Use toPublicJob with full wiring (all callbacks route to the shared manager)
         if (ctx.updateJobData) {
+            const mgr = getSharedManager();
             return toPublicJob({
                 job,
                 name,
@@ -31,15 +38,37 @@ export async function getJob(ctx, id) {
                 clearLogs: ctx.clearJobLogs,
                 getDependencies: ctx.getJobDependencies,
                 getDependenciesCount: ctx.getJobDependenciesCount,
+                // Move / wait callbacks
+                moveToCompleted: ctx.moveJobToCompleted,
+                moveToFailed: ctx.moveJobToFailed,
+                moveToWait: ctx.moveJobToWait,
+                moveToDelayed: ctx.moveJobToDelayed
+                    ? (jid, ts, tok) => ctx.moveJobToDelayed(jid, ts, tok)
+                    : undefined,
+                moveToWaitingChildren: ctx.moveJobToWaitingChildren,
+                waitUntilFinished: ctx.waitJobUntilFinished,
+                // Direct-to-manager callbacks (no server primitive or Queue-level wrapper)
+                discard: (jid) => {
+                    void mgr.discard(jobId(jid));
+                },
+                getFailedChildrenValues: (jid) => mgr.getFailedChildrenValues(jobId(jid)),
+                getIgnoredChildrenFailures: (jid) => mgr.getIgnoredChildrenFailures(jobId(jid)),
+                removeChildDependency: (jid) => mgr.removeChildDependency(jobId(jid)),
+                removeUnprocessedChildren: async (jid) => {
+                    await mgr.removeUnprocessedChildren(jobId(jid));
+                },
             });
         }
-        // Fallback to simple job
+        // Fallback to simple job — reflect priority/delay/opts from the real job (#88)
         return createSimpleJob(String(job.id), name, job.data, job.createdAt, {
             queueName: ctx.name,
+            embedded: ctx.embedded,
+            tcp: ctx.tcp,
             getJobState: ctx.getJobState,
             removeAsync: ctx.removeAsync,
             retryJob: ctx.retryJob,
             getChildrenValues: ctx.getChildrenValues,
+            meta: metaFromJob(job),
         });
     }
     const response = await ctx.tcp.send({ cmd: 'GetJob', id });
@@ -47,12 +76,15 @@ export async function getJob(ctx, id) {
         return null;
     const j = response.job;
     const name = j.data?.name ?? 'unknown';
-    const result = createSimpleJob(j.id, name, j.data, Date.now(), {
+    const result = createSimpleJob(String(j.id), name, j.data, j.createdAt ?? Date.now(), {
         queueName: ctx.name,
+        embedded: ctx.embedded,
+        tcp: ctx.tcp,
         getJobState: ctx.getJobState,
         removeAsync: ctx.removeAsync,
         retryJob: ctx.retryJob,
         getChildrenValues: ctx.getChildrenValues,
+        meta: metaFromJob(j),
     });
     if (j.progress !== undefined)
         result.progress = j.progress;
@@ -112,6 +144,8 @@ export function getJobs(ctx, options = {}) {
         const name = j.data?.name ?? 'unknown';
         return createSimpleJob(String(j.id), name, j.data, j.createdAt, {
             queueName: ctx.name,
+            embedded: ctx.embedded,
+            tcp: ctx.tcp,
             getJobState: ctx.getJobState,
             removeAsync: ctx.removeAsync,
             retryJob: ctx.retryJob,
@@ -136,16 +170,22 @@ export async function getJobsAsync(ctx, options = {}) {
     if (!response.ok || !Array.isArray(response.jobs)) {
         return [];
     }
+    // handleGetJobs returns the full internal job per element ({ ...job, state }),
+    // so reflect the complete opts via metaFromJob instead of a slim subset (#90).
     const jobs = response.jobs;
     const now = Date.now();
     return jobs.map((j) => {
         const name = j.data?.name ?? 'unknown';
-        const result = createSimpleJob(j.id, name, j.data, j.createdAt ?? now, {
+        const createdAt = j.createdAt ?? now;
+        const result = createSimpleJob(String(j.id), name, j.data, createdAt, {
             queueName: ctx.name,
+            embedded: ctx.embedded,
+            tcp: ctx.tcp,
             getJobState: ctx.getJobState,
             removeAsync: ctx.removeAsync,
             retryJob: ctx.retryJob,
             getChildrenValues: ctx.getChildrenValues,
+            meta: metaFromJob(j),
         });
         if (j.progress !== undefined)
             result.progress = j.progress;
@@ -191,4 +231,3 @@ export function getFailed(ctx, start = 0, end = 100) {
 export async function getFailedAsync(ctx, start = 0, end = 100) {
     return getJobsAsync(ctx, { state: 'failed', start, end });
 }
-//# sourceMappingURL=query.js.map

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

@@ -171,4 +171,3 @@ export declare class Queue<T = unknown> {
     disconnect(): Promise<void>;
     close(): void;
 }
-//# sourceMappingURL=queue.d.ts.map

package/dist/client/queue/queue.js

@@ -146,6 +146,13 @@ export class Queue {
             clearJobLogs: (id, keep) => this.clearJobLogs(id, keep),
             getJobDependencies: (id, o) => this.getJobDependencies(id, o),
             getJobDependenciesCount: (id, o) => this.getJobDependenciesCount(id, o),
+            // Move / wait callbacks
+            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),
         };
     }
     get moveCtx() {
@@ -388,7 +395,7 @@ export class Queue {
     }
     // ============ Scheduler Operations ============
     upsertJobScheduler(schedulerId, repeatOpts, jobTemplate) {
-        return schedulerOps.upsertJobScheduler(this.ctx, schedulerId, repeatOpts, jobTemplate);
+        return schedulerOps.upsertJobScheduler({ ...this.ctx, defaultJobOptions: this.opts.defaultJobOptions }, schedulerId, repeatOpts, jobTemplate);
     }
     removeJobScheduler(schedulerId) {
         return schedulerOps.removeJobScheduler(this.ctx, schedulerId);
@@ -491,4 +498,3 @@ export class Queue {
         }
     }
 }
-//# sourceMappingURL=queue.js.map

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

@@ -31,4 +31,3 @@ export interface TcpResponse {
     data?: unknown;
     [key: string]: unknown;
 }
-//# sourceMappingURL=queueTypes.d.ts.map

package/dist/client/queue/queueTypes.js

@@ -3,4 +3,3 @@
  * Shared types for queue module operations
  */
 export {};
-//# sourceMappingURL=queueTypes.js.map

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

@@ -29,4 +29,3 @@ export declare function getRateLimitTtl(_ctx: RateLimitContext, _maxJobs?: numbe
 /** Check if queue is at max capacity */
 export declare function isMaxed(_ctx: RateLimitContext): Promise<boolean>;
 export {};
-//# sourceMappingURL=rateLimit.d.ts.map

package/dist/client/queue/rateLimit.js

@@ -66,4 +66,3 @@ export function getRateLimitTtl(_ctx, _maxJobs) {
 export function isMaxed(_ctx) {
     return Promise.resolve(false);
 }
-//# sourceMappingURL=rateLimit.js.map

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

@@ -14,6 +14,8 @@ interface SchedulerContext {
      * cannot collide on the global cron-name PRIMARY KEY.
      */
     prefixKey?: string;
+    /** Queue-level default job options, merged under the scheduler template opts. */
+    defaultJobOptions?: JobOptions;
 }
 export interface RepeatOpts {
     pattern?: string;
@@ -55,4 +57,3 @@ export declare function getJobSchedulers(ctx: SchedulerContext, _start?: number,
 /** Get count of job schedulers */
 export declare function getJobSchedulersCount(ctx: SchedulerContext): Promise<number>;
 export {};
-//# sourceMappingURL=scheduler.d.ts.map

package/dist/client/queue/scheduler.js

@@ -22,6 +22,31 @@ function buildCronData(jobTemplate) {
         ? { name: jobTemplate.name, ...(jobTemplate.data ?? {}) }
         : (jobTemplate.data ?? {});
 }
+/**
+ * Build the job options carried by every cron-spawned job (issue #86).
+ * Queue defaultJobOptions are the base; per-scheduler template opts override.
+ * Returns undefined when nothing relevant is set so the server keeps its
+ * own JOB_DEFAULTS fallback.
+ */
+function buildCronJobOptions(defaultJobOptions, jobTemplate) {
+    const merged = { ...defaultJobOptions, ...jobTemplate?.opts };
+    const opts = {};
+    if (merged.attempts !== undefined)
+        opts.maxAttempts = merged.attempts;
+    if (merged.backoff !== undefined)
+        opts.backoff = merged.backoff;
+    if (merged.timeout !== undefined)
+        opts.timeout = merged.timeout;
+    if (merged.delay !== undefined)
+        opts.delay = merged.delay;
+    if (merged.stallTimeout !== undefined)
+        opts.stallTimeout = merged.stallTimeout;
+    if (typeof merged.removeOnComplete === 'boolean')
+        opts.removeOnComplete = merged.removeOnComplete;
+    if (typeof merged.removeOnFail === 'boolean')
+        opts.removeOnFail = merged.removeOnFail;
+    return Object.keys(opts).length > 0 ? opts : undefined;
+}
 /** Extract dedup config from job template */
 function buildCronDedup(jobTemplate) {
     const dedup = jobTemplate?.opts?.deduplication;
@@ -38,6 +63,7 @@ export async function upsertJobScheduler(ctx, schedulerId, repeatOpts, jobTempla
     const repeatEvery = repeatOpts.every;
     const data = buildCronData(jobTemplate);
     const dedupFields = buildCronDedup(jobTemplate);
+    const jobOptions = buildCronJobOptions(ctx.defaultJobOptions, jobTemplate);
     const cronName = toCronName(ctx, schedulerId);
     if (ctx.embedded) {
         const manager = getSharedManager();
@@ -52,6 +78,7 @@ export async function upsertJobScheduler(ctx, schedulerId, repeatOpts, jobTempla
             immediately: repeatOpts.immediately,
             skipIfNoWorker: repeatOpts.skipIfNoWorker,
             preventOverlap: repeatOpts.preventOverlap,
+            jobOptions,
             ...dedupFields,
         });
         return {
@@ -72,6 +99,7 @@ export async function upsertJobScheduler(ctx, schedulerId, repeatOpts, jobTempla
         immediately: repeatOpts.immediately,
         skipIfNoWorker: repeatOpts.skipIfNoWorker,
         preventOverlap: repeatOpts.preventOverlap,
+        jobOptions,
         ...dedupFields,
     });
     if (!response.ok)
@@ -156,4 +184,3 @@ export async function getJobSchedulersCount(ctx) {
     const schedulers = await getJobSchedulers(ctx);
     return schedulers.length;
 }
-//# sourceMappingURL=scheduler.js.map

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

@@ -16,4 +16,3 @@ export declare function getStallConfig(ctx: StallContext): StallConfig;
 /** Get stall detection configuration (async, works in TCP mode) */
 export declare function getStallConfigAsync(ctx: StallContext): Promise<StallConfig>;
 export {};
-//# sourceMappingURL=stall.d.ts.map