bunqueue 2.8.53 → 2.8.56

package/dist/application/background/dlq.d.ts

@@ -0,0 +1,2 @@
+import type { BackgroundContext } from '../types';
+export declare function performDlqMaintenance(ctx: BackgroundContext): void;

package/dist/application/background/dlq.js

@@ -0,0 +1,26 @@
+import { queueLog } from '../../shared/logger';
+import * as dlqOperations from '../dlqManager';
+export function performDlqMaintenance(ctx) {
+    const dlqContext = {
+        shards: ctx.shards,
+        jobIndex: ctx.jobIndex,
+        jobResults: ctx.jobResults,
+        jobLogs: ctx.jobLogs,
+        storage: ctx.storage,
+    };
+    for (const queueName of ctx.queueNamesCache) {
+        try {
+            const retried = dlqOperations.processAutoRetry(queueName, dlqContext);
+            if (retried > 0) {
+                ctx.dashboardEmit?.('dlq:auto-retried', { queue: queueName, count: retried });
+            }
+            const expired = dlqOperations.purgeExpiredDlq(queueName, dlqContext);
+            if (expired > 0) {
+                ctx.dashboardEmit?.('dlq:expired', { queue: queueName, count: expired });
+            }
+        }
+        catch (error) {
+            queueLog.error('DLQ maintenance failed', { queue: queueName, error: String(error) });
+        }
+    }
+}

package/dist/application/background/lifecycle.d.ts

@@ -0,0 +1,4 @@
+import type { CronScheduler } from '../../infrastructure/scheduler/cronScheduler';
+import type { BackgroundContext, BackgroundTaskHandles } from '../types';
+export declare function startBackgroundTasks(ctx: BackgroundContext, cronScheduler: CronScheduler): BackgroundTaskHandles;
+export declare function stopBackgroundTasks(handles: BackgroundTaskHandles): void;

package/dist/application/background/lifecycle.js

@@ -0,0 +1,90 @@
+import { cleanup } from '../cleanupTasks';
+import { processPendingDependencies } from '../dependencyProcessor';
+import { checkExpiredLocks } from '../lockManager';
+import { runMonitoringChecks } from '../monitoringChecks';
+import { checkStalledJobs } from '../stallDetection';
+import { handleTaskError, handleTaskSuccess } from '../taskErrorTracking';
+import { performDlqMaintenance } from './dlq';
+function getLockContext(ctx) {
+    return {
+        jobIndex: ctx.jobIndex,
+        jobLocks: ctx.jobLocks,
+        retiredCronLeaseTokens: ctx.retiredCronLeaseTokens,
+        clientJobs: ctx.clientJobs,
+        processingShards: ctx.processingShards,
+        processingLocks: ctx.processingLocks,
+        shards: ctx.shards,
+        shardLocks: ctx.shardLocks,
+        eventsManager: ctx.eventsManager,
+        dashboardEmit: ctx.dashboardEmit,
+        storage: ctx.storage,
+        timeoutScheduler: ctx.timeoutScheduler,
+    };
+}
+export function startBackgroundTasks(ctx, cronScheduler) {
+    const cleanupInterval = setInterval(() => {
+        cleanup(ctx)
+            .then(() => {
+            handleTaskSuccess('cleanup');
+            runMonitoringChecks({
+                queueNamesCache: ctx.queueNamesCache,
+                shards: ctx.shards,
+                processingShards: ctx.processingShards,
+                workerManager: ctx.workerManager,
+                storage: ctx.storage,
+                dashboardEmit: ctx.dashboardEmit,
+                state: ctx.monitoringState,
+            });
+        })
+            .catch((error) => {
+            handleTaskError('cleanup', error);
+        });
+    }, ctx.config.cleanupIntervalMs);
+    const timeoutScheduler = ctx.timeoutScheduler;
+    timeoutScheduler.start(ctx);
+    const depCheckInterval = setInterval(() => {
+        if (ctx.pendingDepChecks.size === 0)
+            return;
+        processPendingDependencies(ctx)
+            .then(() => {
+            handleTaskSuccess('dependency');
+        })
+            .catch((error) => {
+            handleTaskError('dependency', error);
+        });
+    }, ctx.config.dependencyCheckMs);
+    const stallCheckInterval = setInterval(() => {
+        checkStalledJobs(ctx);
+    }, ctx.config.stallCheckMs);
+    const dlqMaintenanceInterval = setInterval(() => {
+        performDlqMaintenance(ctx);
+    }, ctx.config.dlqMaintenanceMs);
+    const lockCheckInterval = setInterval(() => {
+        checkExpiredLocks(getLockContext(ctx))
+            .then(() => {
+            handleTaskSuccess('lockExpiration');
+        })
+            .catch((error) => {
+            handleTaskError('lockExpiration', error);
+        });
+    }, ctx.config.stallCheckMs);
+    cronScheduler.start();
+    return {
+        cleanupInterval,
+        timeoutScheduler,
+        depCheckInterval,
+        stallCheckInterval,
+        dlqMaintenanceInterval,
+        lockCheckInterval,
+        cronScheduler,
+    };
+}
+export function stopBackgroundTasks(handles) {
+    clearInterval(handles.cleanupInterval);
+    handles.timeoutScheduler.stop();
+    clearInterval(handles.depCheckInterval);
+    clearInterval(handles.stallCheckInterval);
+    clearInterval(handles.dlqMaintenanceInterval);
+    clearInterval(handles.lockCheckInterval);
+    handles.cronScheduler.stop();
+}

package/dist/application/background/recovery/active.d.ts

@@ -0,0 +1,4 @@
+import { type JobId } from '../../../domain/types/job';
+import type { BackgroundContext } from '../../types';
+export declare function restoreRecoveryPolicies(ctx: BackgroundContext, queueStates: ReturnType<NonNullable<BackgroundContext['storage']>['loadQueueState']>): void;
+export declare function recoverActiveJobs(ctx: BackgroundContext, dlqJobIds: Set<JobId>, now: number): void;

package/dist/application/background/recovery/active.js

@@ -0,0 +1,69 @@
+import { createDlqEntry, recordJobFailureAttempt } from '../../../domain/types/dlq';
+import { calculateBackoff } from '../../../domain/types/job';
+import { isCorruptDependsOn } from '../../../infrastructure/persistence/sqliteSerializer';
+import { shardIndex } from '../../../shared/hash';
+import { quarantineCorruptDependsOn, RECOVERY_BATCH_SIZE } from './shared';
+export function restoreRecoveryPolicies(ctx, queueStates) {
+    for (const queueState of queueStates) {
+        if (queueState.stallConfig) {
+            ctx.shards[shardIndex(queueState.name)].setStallConfig(queueState.name, queueState.stallConfig);
+        }
+        if (queueState.dlqConfig) {
+            ctx.shards[shardIndex(queueState.name)].setDlqConfig(queueState.name, queueState.dlqConfig);
+        }
+    }
+}
+export function recoverActiveJobs(ctx, dlqJobIds, now) {
+    if (!ctx.storage)
+        return;
+    while (true) {
+        const activeJobs = ctx.storage.loadActiveJobs(RECOVERY_BATCH_SIZE, 0);
+        if (activeJobs.length === 0)
+            break;
+        for (const job of activeJobs) {
+            const shard = ctx.shards[shardIndex(job.queue)];
+            const stallConfig = shard.getStallConfig(job.queue);
+            if (job.uniqueKey?.startsWith('cron:')) {
+                ctx.storage.deleteJob(job.id);
+                ctx.registerQueueName(job.queue);
+                continue;
+            }
+            if (dlqJobIds.has(job.id)) {
+                ctx.storage.deleteJob(job.id);
+                ctx.registerQueueName(job.queue);
+                continue;
+            }
+            if (isCorruptDependsOn(job)) {
+                quarantineCorruptDependsOn(ctx, job);
+                continue;
+            }
+            job.stallCount = (job.stallCount || 0) + 1;
+            job.attempts++;
+            job.lastHeartbeat = now;
+            const maxStalls = stallConfig.maxStalls ?? 3;
+            const attemptsExhausted = job.attempts >= job.maxAttempts;
+            const stallsExhausted = maxStalls > 0 && job.stallCount >= maxStalls;
+            if (attemptsExhausted || stallsExhausted) {
+                const reason = attemptsExhausted
+                    ? "max_attempts_exceeded" /* FailureReason.MaxAttemptsExceeded */
+                    : "stalled" /* FailureReason.Stalled */;
+                const error = attemptsExhausted
+                    ? `Job reached max attempts (${job.maxAttempts}) during startup recovery`
+                    : `Job stalled ${job.stallCount} times (recovered at startup)`;
+                const entry = createDlqEntry(job, reason, error, shard.getDlqConfig(job.queue));
+                job.startedAt = null;
+                ctx.storage.saveDlqEntry(entry);
+                ctx.storage.deleteJob(job.id);
+            }
+            else {
+                recordJobFailureAttempt(job, "stalled" /* FailureReason.Stalled */, 'Interrupted during recovery', now);
+                job.startedAt = null;
+                job.runAt = now + calculateBackoff(job);
+                ctx.storage.updateForRetry(job);
+            }
+            ctx.registerQueueName(job.queue);
+        }
+        if (activeJobs.length < RECOVERY_BATCH_SIZE)
+            break;
+    }
+}

package/dist/application/background/recovery/index.d.ts

@@ -0,0 +1,2 @@
+import type { BackgroundContext } from '../../types';
+export declare function recover(ctx: BackgroundContext): void;

package/dist/application/background/recovery/index.js

@@ -0,0 +1,22 @@
+import { reconcileDependencyCompletionPins } from '../../dependencyCompletions';
+import { recoverActiveJobs, restoreRecoveryPolicies } from './active';
+import { recoverPendingJobs } from './pending';
+import { recoverCompletedJobs, restoreDlq, restoreQueueState } from './restore';
+export function recover(ctx) {
+    if (!ctx.storage)
+        return;
+    const dependencyCompletions = ctx.storage.loadDependencyCompletions();
+    const completedInDatabase = ctx.storage.loadCompletedJobIds();
+    for (const record of dependencyCompletions)
+        completedInDatabase.add(record.jobId);
+    const dlqJobIds = ctx.storage.loadDlqJobIds();
+    const queueStates = ctx.storage.loadQueueState();
+    restoreRecoveryPolicies(ctx, queueStates);
+    const now = Date.now();
+    recoverActiveJobs(ctx, dlqJobIds, now);
+    recoverPendingJobs(ctx, completedInDatabase, now);
+    restoreDlq(ctx);
+    restoreQueueState(ctx, queueStates);
+    recoverCompletedJobs(ctx);
+    reconcileDependencyCompletionPins(ctx);
+}

package/dist/application/background/recovery/pending.d.ts

@@ -0,0 +1,3 @@
+import type { JobId } from '../../../domain/types/job';
+import type { BackgroundContext } from '../../types';
+export declare function recoverPendingJobs(ctx: BackgroundContext, completedInDatabase: Set<JobId>, now: number): void;

package/dist/application/background/recovery/pending.js

@@ -0,0 +1,69 @@
+import { isCorruptDependsOn, persistedJobState, } from '../../../infrastructure/persistence/sqliteSerializer';
+import { shardIndex } from '../../../shared/hash';
+import { checkpointDependencyPromotion, dependencyReadyState } from '../../dependencyProcessor';
+import { quarantineCorruptDependsOn, RECOVERY_BATCH_SIZE } from './shared';
+export function recoverPendingJobs(ctx, completedInDatabase, now) {
+    if (!ctx.storage)
+        return;
+    let offset = 0;
+    const corruptPendingJobs = [];
+    while (true) {
+        const jobs = ctx.storage.loadPendingJobs(RECOVERY_BATCH_SIZE, offset);
+        if (jobs.length === 0)
+            break;
+        for (const job of jobs) {
+            const shardIndexValue = shardIndex(job.queue);
+            const shard = ctx.shards[shardIndexValue];
+            if (isCorruptDependsOn(job)) {
+                corruptPendingJobs.push(job);
+                continue;
+            }
+            const hasDependencies = job.dependsOn && job.dependsOn.length > 0;
+            const recoveredState = persistedJobState(job);
+            const wasAlreadyPromoted = recoveredState === 'waiting' ||
+                recoveredState === 'prioritized' ||
+                recoveredState === 'delayed';
+            const needsWaitingDeps = hasDependencies &&
+                !wasAlreadyPromoted &&
+                !job.dependsOn.every((dependencyId) => ctx.completedJobs.has(dependencyId) || completedInDatabase.has(dependencyId));
+            const manuallyWaitingChildren = recoveredState === 'waiting-children' && !hasDependencies;
+            if (manuallyWaitingChildren) {
+                shard.waitingChildren.set(job.id, job);
+            }
+            else if (needsWaitingDeps) {
+                shard.waitingDeps.set(job.id, job);
+                shard.registerDependencies(job.id, job.dependsOn);
+            }
+            else {
+                shard.getQueue(job.queue).push(job);
+                const state = dependencyReadyState(job, now);
+                const isDelayed = state === 'delayed';
+                shard.incrementQueued(job.id, isDelayed, job.createdAt, job.queue, job.runAt);
+                if (hasDependencies)
+                    checkpointDependencyPromotion(job, state, now, ctx.storage);
+            }
+            ctx.jobIndex.set(job.id, {
+                type: 'queue',
+                shardIdx: shardIndexValue,
+                queueName: job.queue,
+            });
+            ctx.dependencyResults.registerConsumer(job.id, job.dependsOn);
+            for (const dependencyId of job.dependsOn) {
+                if (ctx.jobResults.has(dependencyId)) {
+                    ctx.dependencyResults.retain(dependencyId, ctx.jobResults.get(dependencyId));
+                }
+            }
+            if (job.customId)
+                ctx.customIdMap.set(job.customId, job.id);
+            if (job.uniqueKey) {
+                shard.registerUniqueKeyWithTtl(job.queue, job.uniqueKey, job.id, job.deduplicationTtl ?? undefined);
+            }
+            ctx.registerQueueName(job.queue);
+        }
+        offset += jobs.length;
+        if (jobs.length < RECOVERY_BATCH_SIZE)
+            break;
+    }
+    for (const job of corruptPendingJobs)
+        quarantineCorruptDependsOn(ctx, job);
+}

package/dist/application/background/recovery/restore.d.ts

@@ -0,0 +1,5 @@
+import type { BackgroundContext } from '../../types';
+import { type QueueStateRecord } from './shared';
+export declare function restoreDlq(ctx: BackgroundContext): void;
+export declare function restoreQueueState(ctx: BackgroundContext, queueStates: QueueStateRecord[]): void;
+export declare function recoverCompletedJobs(ctx: BackgroundContext): void;

package/dist/application/background/recovery/restore.js

@@ -0,0 +1,58 @@
+import { shardIndex } from '../../../shared/hash';
+import { RECOVERY_BATCH_SIZE } from './shared';
+export function restoreDlq(ctx) {
+    if (!ctx.storage)
+        return;
+    const dlqEntries = ctx.storage.loadDlq();
+    for (const [queue, entries] of dlqEntries) {
+        const shard = ctx.shards[shardIndex(queue)];
+        for (const entry of entries) {
+            shard.restoreDlqEntry(queue, entry);
+            ctx.jobIndex.set(entry.job.id, { type: 'dlq', queueName: queue });
+        }
+        ctx.registerQueueName(queue);
+    }
+}
+export function restoreQueueState(ctx, queueStates) {
+    for (const queueState of queueStates) {
+        const shard = ctx.shards[shardIndex(queueState.name)];
+        if (queueState.paused)
+            shard.pause(queueState.name);
+        if (queueState.rateLimit !== null) {
+            const remainingTtl = queueState.rateLimitExpiresAt === null
+                ? undefined
+                : queueState.rateLimitExpiresAt - Date.now();
+            if (remainingTtl === undefined || remainingTtl > 0) {
+                shard.setRateLimit(queueState.name, queueState.rateLimit, queueState.rateLimitDuration ?? undefined, remainingTtl);
+            }
+        }
+        if (queueState.concurrencyLimit !== null) {
+            shard.setConcurrency(queueState.name, queueState.concurrencyLimit);
+        }
+        ctx.registerQueueName(queueState.name);
+    }
+}
+export function recoverCompletedJobs(ctx) {
+    if (!ctx.storage)
+        return;
+    const completedCap = ctx.config.maxCompletedJobs;
+    let completedLoaded = 0;
+    let completedOffset = 0;
+    while (completedLoaded < completedCap) {
+        const remaining = completedCap - completedLoaded;
+        const batchSize = Math.min(RECOVERY_BATCH_SIZE, remaining);
+        const completedBatch = ctx.storage.loadCompletedJobs(batchSize, completedOffset);
+        if (completedBatch.length === 0)
+            break;
+        for (const job of completedBatch) {
+            ctx.jobIndex.set(job.id, { type: 'completed', queueName: job.queue });
+            ctx.completedJobs.add(job.id);
+            ctx.completedJobsData.set(job.id, job);
+            ctx.registerQueueName(job.queue);
+        }
+        completedLoaded += completedBatch.length;
+        completedOffset += completedBatch.length;
+        if (completedBatch.length < batchSize)
+            break;
+    }
+}

package/dist/application/background/recovery/shared.d.ts

@@ -0,0 +1,6 @@
+import type { Job } from '../../../domain/types/job';
+import type { BackgroundContext } from '../../types';
+export declare const RECOVERY_BATCH_SIZE = 10000;
+export type RecoveryStorage = NonNullable<BackgroundContext['storage']>;
+export type QueueStateRecord = ReturnType<RecoveryStorage['loadQueueState']>[number];
+export declare function quarantineCorruptDependsOn(ctx: BackgroundContext, job: Job): void;

package/dist/application/background/recovery/shared.js

@@ -0,0 +1,15 @@
+import { createDlqEntry } from '../../../domain/types/dlq';
+import { queueLog } from '../../../shared/logger';
+export const RECOVERY_BATCH_SIZE = 10000;
+export function quarantineCorruptDependsOn(ctx, job) {
+    if (!ctx.storage)
+        return;
+    const entry = createDlqEntry(job, "unknown" /* FailureReason.Unknown */, 'corrupt-dependency-metadata');
+    ctx.storage.saveDlqEntry(entry);
+    ctx.storage.deleteJob(job.id);
+    ctx.registerQueueName(job.queue);
+    queueLog.error('Recovered job with corrupt depends_on metadata -> routed to DLQ', {
+        jobId: String(job.id),
+        queue: job.queue,
+    });
+}

package/dist/application/background/timeouts.d.ts

@@ -0,0 +1,25 @@
+import type { Job, JobId } from '../../domain/types/job';
+import type { BackgroundContext } from '../types';
+export declare const MAX_TIMER_DELAY_MS = 2147483647;
+export declare function timeoutTimerDelay(deadline: number, now?: number): number;
+/** Compatibility entry point for explicit timeout checks in tests and tooling. */
+export declare function checkJobTimeouts(ctx: BackgroundContext): Promise<void>;
+/** One timer tracks the earliest active processing deadline. */
+export declare class JobTimeoutScheduler {
+    private readonly active;
+    private readonly deadlines;
+    private timer;
+    private armedDeadline;
+    private stopped;
+    private ctx;
+    get pendingCount(): number;
+    start(ctx: BackgroundContext): void;
+    schedule(job: Job): void;
+    cancel(jobId: JobId): void;
+    stop(): void;
+    private isCurrent;
+    private pruneStaleRoots;
+    private maybeCompact;
+    private armNext;
+    private expireDue;
+}

package/dist/application/background/timeouts.js

@@ -0,0 +1,191 @@
+import { MinHeap } from '../../shared/minHeap';
+import { queueLog } from '../../shared/logger';
+export const MAX_TIMER_DELAY_MS = 2_147_483_647;
+export function timeoutTimerDelay(deadline, now = Date.now()) {
+    return Math.max(1, Math.min(MAX_TIMER_DELAY_MS, deadline - now));
+}
+function deadlineFor(job) {
+    if (!job.timeout || job.startedAt === null)
+        return null;
+    const deadline = job.startedAt + job.timeout;
+    return Number.isSafeInteger(deadline) ? deadline : Number.MAX_SAFE_INTEGER;
+}
+function processingJob(ctx, id) {
+    const location = ctx.jobIndex.get(id);
+    if (location?.type !== 'processing')
+        return null;
+    return ctx.processingShards[location.shardIdx].get(id) ?? null;
+}
+async function failTimedOutJob(ctx, job) {
+    await ctx.fail(job.id, 'Job timeout exceeded', "timeout" /* FailureReason.Timeout */);
+    ctx.dashboardEmit?.('job:timeout', {
+        jobId: String(job.id),
+        queue: job.queue,
+        timeout: job.timeout,
+    });
+}
+/** Compatibility entry point for explicit timeout checks in tests and tooling. */
+export async function checkJobTimeouts(ctx) {
+    const now = Date.now();
+    const timedOut = [];
+    for (const processingShard of ctx.processingShards) {
+        for (const job of processingShard.values()) {
+            const deadline = deadlineFor(job);
+            if (deadline !== null && now >= deadline)
+                timedOut.push({ deadline, job });
+        }
+    }
+    timedOut.sort((a, b) => a.deadline - b.deadline);
+    for (const { job } of timedOut) {
+        if (processingJob(ctx, job.id) !== job)
+            continue;
+        try {
+            await failTimedOutJob(ctx, job);
+        }
+        catch (error) {
+            queueLog.error('Failed to mark timed out job as failed', {
+                jobId: String(job.id),
+                error: String(error),
+            });
+        }
+    }
+}
+/** One timer tracks the earliest active processing deadline. */
+export class JobTimeoutScheduler {
+    active = new Map();
+    deadlines = new MinHeap((a, b) => {
+        if (a.deadline !== b.deadline)
+            return a.deadline - b.deadline;
+        return String(a.jobId).localeCompare(String(b.jobId));
+    });
+    timer = null;
+    armedDeadline = null;
+    stopped = true;
+    ctx = null;
+    get pendingCount() {
+        return this.active.size;
+    }
+    start(ctx) {
+        if (!this.stopped)
+            return;
+        this.ctx = ctx;
+        this.stopped = false;
+        this.armNext();
+    }
+    schedule(job) {
+        if (this.stopped)
+            return;
+        const deadline = deadlineFor(job);
+        const startedAt = job.startedAt;
+        if (deadline === null || startedAt === null) {
+            this.cancel(job.id);
+            return;
+        }
+        const current = this.active.get(job.id);
+        if (current?.deadline === deadline && current.startedAt === startedAt)
+            return;
+        const entry = { deadline, jobId: job.id, startedAt };
+        this.active.set(job.id, entry);
+        this.deadlines.push(entry);
+        this.maybeCompact();
+        if (this.armedDeadline === null || deadline < this.armedDeadline)
+            this.armNext();
+    }
+    cancel(jobId) {
+        const current = this.active.get(jobId);
+        if (!current)
+            return;
+        this.active.delete(jobId);
+        this.maybeCompact();
+        if (current.deadline === this.armedDeadline)
+            this.armNext();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        this.armedDeadline = null;
+        this.active.clear();
+        this.deadlines.clear();
+        this.ctx = null;
+    }
+    isCurrent(entry) {
+        return this.active.get(entry.jobId) === entry;
+    }
+    pruneStaleRoots() {
+        while (true) {
+            const next = this.deadlines.peek();
+            if (!next || this.isCurrent(next))
+                return;
+            this.deadlines.pop();
+        }
+    }
+    maybeCompact() {
+        const stale = this.deadlines.size - this.active.size;
+        if (stale >= 256 && stale >= this.active.size) {
+            this.deadlines.buildFrom([...this.active.values()]);
+        }
+    }
+    armNext() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        this.armedDeadline = null;
+        if (this.stopped)
+            return;
+        this.pruneStaleRoots();
+        const next = this.deadlines.peek();
+        if (!next)
+            return;
+        this.armedDeadline = next.deadline;
+        this.timer = setTimeout(() => void this.expireDue(), timeoutTimerDelay(next.deadline));
+    }
+    async expireDue() {
+        this.timer = null;
+        this.armedDeadline = null;
+        const ctx = this.ctx;
+        if (this.stopped || !ctx)
+            return;
+        const now = Date.now();
+        const due = [];
+        this.pruneStaleRoots();
+        while (true) {
+            const next = this.deadlines.peek();
+            if (!next || next.deadline > now)
+                break;
+            const entry = this.deadlines.pop();
+            if (!entry)
+                break;
+            if (!this.isCurrent(entry))
+                continue;
+            this.active.delete(entry.jobId);
+            due.push(entry);
+        }
+        for (const entry of due) {
+            const job = processingJob(ctx, entry.jobId);
+            const deadline = job ? deadlineFor(job) : null;
+            if (!job || job.startedAt !== entry.startedAt || deadline === null || deadline > now)
+                continue;
+            try {
+                await failTimedOutJob(ctx, job);
+            }
+            catch (error) {
+                queueLog.error('Failed to mark timed out job as failed', {
+                    jobId: String(entry.jobId),
+                    error: String(error),
+                });
+                const current = processingJob(ctx, entry.jobId);
+                if (current?.startedAt === entry.startedAt) {
+                    const retry = {
+                        ...entry,
+                        deadline: Date.now() + ctx.config.jobTimeoutCheckMs,
+                    };
+                    this.active.set(entry.jobId, retry);
+                    this.deadlines.push(retry);
+                }
+            }
+        }
+        this.armNext();
+    }
+}

package/dist/application/backgroundTasks.d.ts

@@ -1,31 +1,7 @@
-/**
- * Background Tasks - Periodic maintenance operations
- * Orchestrates stall detection, cleanup, recovery, DLQ maintenance
- */
-import { processPendingDependencies } from './dependencyProcessor';
-import { getTaskErrorStats } from './taskErrorTracking';
-import type { BackgroundContext } from './types';
-import type { CronScheduler } from '../infrastructure/scheduler/cronScheduler';
-export { getTaskErrorStats };
-/** Background task handles for cleanup */
-export interface BackgroundTaskHandles {
-    cleanupInterval: ReturnType<typeof setInterval>;
-    timeoutInterval: ReturnType<typeof setInterval>;
-    depCheckInterval: ReturnType<typeof setInterval>;
-    stallCheckInterval: ReturnType<typeof setInterval>;
-    dlqMaintenanceInterval: ReturnType<typeof setInterval>;
-    lockCheckInterval: ReturnType<typeof setInterval>;
-    cronScheduler: CronScheduler;
-}
-/**
- * Start all background tasks
- * Returns handles that can be used to stop tasks later
- */
-export declare function startBackgroundTasks(ctx: BackgroundContext, cronScheduler: CronScheduler): BackgroundTaskHandles;
-/**
- * Stop all background tasks
- */
-export declare function stopBackgroundTasks(handles: BackgroundTaskHandles): void;
-export declare function checkJobTimeouts(ctx: BackgroundContext): void;
-export declare function recover(ctx: BackgroundContext): void;
-export { processPendingDependencies };
+/** Stable background-task import surface. */
+export { startBackgroundTasks, stopBackgroundTasks } from './background/lifecycle';
+export { recover } from './background/recovery';
+export { checkJobTimeouts } from './background/timeouts';
+export { processPendingDependencies } from './dependencyProcessor';
+export { getTaskErrorStats } from './taskErrorTracking';
+export type { BackgroundTaskHandles } from './types/background';