bunqueue 2.8.54 → 2.8.57

package/dist/application/queueTelemetryJournal.d.ts

@@ -0,0 +1,20 @@
+import type { QueueMetrics, QueueMetricType } from '../domain/types/metrics';
+import { type JobEvent } from '../domain/types/queue';
+import type { SqliteStorage } from '../infrastructure/persistence/sqlite';
+/** Per-queue bounded event journal and cumulative minute metrics. */
+export declare class QueueTelemetryJournal {
+    private readonly storage;
+    private readonly events;
+    private readonly metrics;
+    private readonly maxEvents;
+    private readonly maxMetricDataPoints;
+    constructor(storage: SqliteStorage | null, maxEvents: number, maxMetricDataPoints: number);
+    record(event: JobEvent): void;
+    getMetrics(queue: string, type: QueueMetricType, start?: number, end?: number): QueueMetrics;
+    trimEvents(queue: string, maxLength: number): number;
+    clearQueue(queue: string): void;
+    clearMemory(): void;
+    private getMemoryMetrics;
+    private pruneBuckets;
+    private expandBuckets;
+}

package/dist/application/queueTelemetryJournal.js

@@ -0,0 +1,133 @@
+function metricType(event) {
+    if (event.eventType === "completed" /* EventType.Completed */)
+        return 'completed';
+    if (event.eventType === "failed" /* EventType.Failed */ && event.terminal !== false)
+        return 'failed';
+    return null;
+}
+function assertNonNegativeInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError(`${name} must be a non-negative safe integer`);
+    }
+}
+/** Per-queue bounded event journal and cumulative minute metrics. */
+export class QueueTelemetryJournal {
+    storage;
+    events = new Map();
+    metrics = new Map();
+    maxEvents;
+    maxMetricDataPoints;
+    constructor(storage, maxEvents, maxMetricDataPoints) {
+        this.storage = storage;
+        assertNonNegativeInteger(maxEvents, 'maxQueueEvents');
+        assertNonNegativeInteger(maxMetricDataPoints, 'maxMetricDataPoints');
+        this.maxEvents = maxEvents;
+        this.maxMetricDataPoints = maxMetricDataPoints;
+    }
+    record(event) {
+        if (this.storage) {
+            this.storage.recordQueueEvent(event, this.maxEvents, this.maxMetricDataPoints);
+            return;
+        }
+        const queueEvents = this.events.get(event.queue) ?? [];
+        queueEvents.push(event);
+        if (queueEvents.length > this.maxEvents) {
+            queueEvents.splice(0, queueEvents.length - this.maxEvents);
+        }
+        this.events.set(event.queue, queueEvents);
+        const type = metricType(event);
+        if (!type)
+            return;
+        const queueMetrics = this.metrics.get(event.queue) ?? new Map();
+        const state = queueMetrics.get(type) ?? {
+            total: 0,
+            prevTS: 0,
+            prevCount: 0,
+            buckets: new Map(),
+        };
+        const minute = Math.floor(event.timestamp / 60_000);
+        const bucketCount = (state.buckets.get(minute) ?? 0) + 1;
+        state.buckets.set(minute, bucketCount);
+        state.total++;
+        state.prevTS = event.timestamp;
+        state.prevCount = bucketCount;
+        this.pruneBuckets(state.buckets);
+        queueMetrics.set(type, state);
+        this.metrics.set(event.queue, queueMetrics);
+    }
+    getMetrics(queue, type, start = 0, end = -1) {
+        assertNonNegativeInteger(start, 'start');
+        if (end !== -1)
+            assertNonNegativeInteger(end, 'end');
+        const full = this.storage
+            ? this.storage.getQueueMetrics(queue, type, this.maxMetricDataPoints)
+            : this.getMemoryMetrics(queue, type);
+        const count = full.data.length;
+        const exclusiveEnd = end === -1 ? count : Math.min(count, end + 1);
+        return {
+            meta: full.meta,
+            data: start >= exclusiveEnd ? [] : full.data.slice(start, exclusiveEnd),
+            count,
+        };
+    }
+    trimEvents(queue, maxLength) {
+        assertNonNegativeInteger(maxLength, 'maxLength');
+        if (this.storage)
+            return this.storage.trimQueueEvents(queue, maxLength);
+        const events = this.events.get(queue);
+        if (!events || events.length <= maxLength)
+            return 0;
+        const removed = events.length - maxLength;
+        events.splice(0, removed);
+        if (events.length === 0)
+            this.events.delete(queue);
+        return removed;
+    }
+    clearQueue(queue) {
+        this.events.delete(queue);
+        this.metrics.delete(queue);
+        this.storage?.clearQueueTelemetry(queue);
+    }
+    clearMemory() {
+        this.events.clear();
+        this.metrics.clear();
+    }
+    getMemoryMetrics(queue, type) {
+        const state = this.metrics.get(queue)?.get(type);
+        if (!state) {
+            return { meta: { count: 0, prevTS: 0, prevCount: 0 }, data: [] };
+        }
+        return {
+            meta: { count: state.total, prevTS: state.prevTS, prevCount: state.prevCount },
+            data: this.expandBuckets(state.buckets),
+        };
+    }
+    pruneBuckets(buckets) {
+        if (this.maxMetricDataPoints <= 0) {
+            buckets.clear();
+            return;
+        }
+        let newest = Number.NEGATIVE_INFINITY;
+        for (const minute of buckets.keys())
+            newest = Math.max(newest, minute);
+        const cutoff = newest - this.maxMetricDataPoints + 1;
+        for (const minute of buckets.keys()) {
+            if (minute < cutoff)
+                buckets.delete(minute);
+        }
+    }
+    expandBuckets(buckets) {
+        if (buckets.size === 0 || this.maxMetricDataPoints <= 0)
+            return [];
+        const minutes = [...buckets.keys()].sort((a, b) => b - a);
+        const newest = minutes[0];
+        const oldest = Math.max(minutes[minutes.length - 1], newest - this.maxMetricDataPoints + 1);
+        const data = new Array(newest - oldest + 1).fill(0);
+        for (const [minute, count] of buckets) {
+            const index = newest - minute;
+            if (index >= 0 && index < data.length)
+                data[index] = count;
+        }
+        return data;
+    }
+}

package/dist/application/repeatJobs.d.ts

@@ -0,0 +1,7 @@
+import type { Job, JobInput, RepeatConfig } from '../domain/types/job';
+/** Reject repeat definitions that cannot produce an unambiguous, independent chain. */
+export declare function validateRepeatJobInput(input: JobInput): void;
+/** Return the next absolute deadline, or null when the configured window is exhausted. */
+export declare function nextRepeatRun(repeat: RepeatConfig, now?: number): number | null;
+/** Clone every repeat-compatible policy while resetting execution-owned state. */
+export declare function buildRepeatSuccessor(job: Job, now?: number): JobInput | null;

package/dist/application/repeatJobs.js

@@ -0,0 +1,132 @@
+import { expandCronShortcut, getNextCronRun, validateCronExpression, } from '../infrastructure/scheduler/cronParser';
+function finiteDate(value, field) {
+    if (value !== undefined && !Number.isFinite(value)) {
+        throw new Error(`repeat.${field} must be a finite timestamp`);
+    }
+}
+/** Reject repeat definitions that cannot produce an unambiguous, independent chain. */
+export function validateRepeatJobInput(input) {
+    const repeat = input.repeat;
+    if (!repeat)
+        return;
+    const hasEvery = repeat.every !== undefined;
+    const hasPattern = repeat.pattern !== undefined && repeat.pattern.trim().length > 0;
+    if (hasEvery === hasPattern) {
+        throw new Error('repeat requires exactly one of every or pattern');
+    }
+    if (hasEvery && (!Number.isFinite(repeat.every) || repeat.every <= 0)) {
+        throw new Error('repeat.every must be a positive finite number');
+    }
+    if (hasPattern) {
+        const expression = expandCronShortcut(repeat.pattern);
+        const error = validateCronExpression(expression, repeat.tz);
+        if (error)
+            throw new Error(`Invalid repeat pattern: ${error}`);
+    }
+    finiteDate(repeat.startDate, 'startDate');
+    finiteDate(repeat.endDate, 'endDate');
+    finiteDate(repeat.prevMillis, 'prevMillis');
+    finiteDate(repeat.offset, 'offset');
+    if (input.customId) {
+        throw new Error('repeat jobs cannot use JobOptions.jobId; use repeat.jobId instead');
+    }
+    if (input.parentId || input.dependsOn?.length || input.childrenIds?.length) {
+        throw new Error('repeat jobs cannot participate in parent or dependency relationships');
+    }
+}
+function nextIntervalRun(repeat, now) {
+    const every = repeat.every;
+    const earliest = Math.max(now + 1, repeat.startDate ?? Number.NEGATIVE_INFINITY);
+    let next = repeat.prevMillis !== undefined
+        ? repeat.prevMillis + every
+        : repeat.startDate !== undefined && repeat.startDate > now
+            ? repeat.startDate + (repeat.offset ?? 0)
+            : now + every + (repeat.offset ?? 0);
+    if (next < earliest)
+        next += Math.ceil((earliest - next) / every) * every;
+    return next;
+}
+function nextPatternRun(repeat, now) {
+    const offset = repeat.offset ?? 0;
+    const shiftedStart = repeat.startDate !== undefined ? repeat.startDate - offset - 1 : Number.NEGATIVE_INFINITY;
+    const shiftedPrevious = repeat.prevMillis !== undefined ? repeat.prevMillis - offset : Number.NEGATIVE_INFINITY;
+    const from = Math.max(now - offset, shiftedStart, shiftedPrevious);
+    const expression = expandCronShortcut(repeat.pattern);
+    let baseRun = getNextCronRun(expression, from, repeat.tz);
+    let next = baseRun > 0 ? baseRun + offset : 0;
+    if (baseRun > 0 && next <= now) {
+        baseRun = getNextCronRun(expression, baseRun, repeat.tz);
+        next = baseRun > 0 ? baseRun + offset : 0;
+    }
+    return next;
+}
+/** Return the next absolute deadline, or null when the configured window is exhausted. */
+export function nextRepeatRun(repeat, now = Date.now()) {
+    const next = repeat.pattern ? nextPatternRun(repeat, now) : nextIntervalRun(repeat, now);
+    if (!Number.isFinite(next) || next <= 0)
+        return null;
+    if (repeat.startDate !== undefined && next < repeat.startDate)
+        return null;
+    if (repeat.endDate !== undefined && next > repeat.endDate)
+        return null;
+    return next;
+}
+function repeatSuccessorConfig(repeat, nextRun) {
+    return {
+        every: repeat.every,
+        limit: repeat.limit,
+        pattern: repeat.pattern,
+        count: repeat.count + 1,
+        startDate: repeat.startDate,
+        endDate: repeat.endDate,
+        tz: repeat.tz,
+        immediately: repeat.immediately,
+        prevMillis: nextRun,
+        offset: repeat.offset,
+        jobId: repeat.jobId,
+    };
+}
+/** Clone every repeat-compatible policy while resetting execution-owned state. */
+export function buildRepeatSuccessor(job, now = Date.now()) {
+    if (!job.repeat)
+        return null;
+    const nextRun = nextRepeatRun(job.repeat, now);
+    if (nextRun === null)
+        return null;
+    return {
+        name: job.name,
+        data: job.data,
+        priority: job.priority,
+        delay: Math.max(0, nextRun - now),
+        timestamp: now,
+        maxAttempts: job.maxAttempts,
+        backoff: job.backoffConfig ?? job.backoff,
+        ttl: job.ttl ?? undefined,
+        timeout: job.timeout ?? undefined,
+        uniqueKey: job.uniqueKey ?? undefined,
+        tags: job.tags,
+        groupId: job.groupId ?? undefined,
+        lifo: job.lifo,
+        removeOnComplete: job.removeOnComplete,
+        removeOnFail: job.removeOnFail,
+        stallTimeout: job.stallTimeout ?? undefined,
+        repeat: repeatSuccessorConfig(job.repeat, nextRun),
+        dedup: job.uniqueKey
+            ? {
+                ttl: job.deduplicationTtl ?? undefined,
+                extend: job.deduplicationExtend,
+                replace: job.deduplicationReplace,
+            }
+            : undefined,
+        durable: job.durable,
+        stackTraceLimit: job.stackTraceLimit,
+        keepLogs: job.keepLogs ?? undefined,
+        sizeLimit: job.sizeLimit ?? undefined,
+        failParentOnFailure: job.failParentOnFailure,
+        removeDependencyOnFailure: job.removeDependencyOnFailure,
+        continueParentOnFailure: job.continueParentOnFailure,
+        ignoreDependencyOnFailure: job.ignoreDependencyOnFailure,
+        debounceId: job.debounceId ?? undefined,
+        debounceTtl: job.debounceTtl ?? undefined,
+    };
+}

package/dist/application/stallDetection.js

@@ -3,6 +3,7 @@
  * Uses two-phase detection (like BullMQ) to prevent false positives
  */
 import { calculateBackoff, MAX_TIMELINE_ENTRIES } from '../domain/types/job';
+import { recordJobFailureAttempt } from '../domain/types/dlq';
 import { getStallAction, incrementStallCount } from '../domain/types/stall';
 import { queueLog } from '../shared/logger';
 import { shardIndex, processingShardIndex, SHARD_COUNT } from '../shared/hash';
@@ -108,6 +109,7 @@ async function handleStalledJob(job, action, ctx) {
 /** Move stalled job to DLQ */
 function moveStalliedJobToDlq(job, ctx, shard, procIdx, attemptsExhausted) {
     ctx.processingShards[procIdx].delete(job.id);
+    ctx.timeoutScheduler.cancel(job.id);
     shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
     // Discard cron jobs with preventOverlap instead of sending to DLQ (#73).
     if (job.uniqueKey?.startsWith('cron:')) {
@@ -132,6 +134,7 @@ function retryStalliedJob(job, ctx, shard, procIdx, idx) {
     // The cron scheduler will re-create them at the next scheduled tick.
     if (job.uniqueKey?.startsWith('cron:')) {
         ctx.processingShards[procIdx].delete(job.id);
+        ctx.timeoutScheduler.cancel(job.id);
         shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
         ctx.jobIndex.delete(job.id);
         ctx.storage?.deleteJob(job.id);
@@ -139,8 +142,9 @@ function retryStalliedJob(job, ctx, shard, procIdx, idx) {
     }
     incrementStallCount(job);
     job.attempts++;
-    job.startedAt = null;
     const stallNow = Date.now();
+    recordJobFailureAttempt(job, "stalled" /* FailureReason.Stalled */, 'stalled', stallNow);
+    job.startedAt = null;
     job.runAt = stallNow + calculateBackoff(job);
     job.lastHeartbeat = stallNow;
     if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
@@ -153,6 +157,7 @@ function retryStalliedJob(job, ctx, shard, procIdx, idx) {
         job.timeline.push({ state: 'waiting', timestamp: stallNow, attempt: job.attempts + 1 });
     }
     ctx.processingShards[procIdx].delete(job.id);
+    ctx.timeoutScheduler.cancel(job.id);
     shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
     shard.getQueue(job.queue).push(job);
     const isDelayed = job.runAt > Date.now();

package/dist/application/types/ack.d.ts

@@ -0,0 +1,132 @@
+import type { Shard } from '../../domain/queue/shard';
+import type { FlowFailureRecord } from '../../domain/types/flow';
+import type { FailureReason } from '../../domain/types/dlq';
+import type { Job, JobId } from '../../domain/types/job';
+import type { EventType, JobLocation } from '../../domain/types/queue';
+import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
+import type { RWLock } from '../../shared/lock';
+import type { MapLike, SetLike } from '../../shared/lru';
+import type { DependencyCompletionTracker } from '../dependencyCompletions';
+import type { DependencyResultTracker } from '../dependencyResultTracker';
+export interface AckContext {
+    storage: SqliteStorage | null;
+    shards: Shard[];
+    shardLocks: RWLock[];
+    processingShards: Map<JobId, Job>[];
+    processingLocks: RWLock[];
+    completedJobs: SetLike<JobId>;
+    completedJobsData: MapLike<JobId, Job>;
+    retiredCronLeaseTokens?: MapLike<JobId, string>;
+    depCompletions?: DependencyCompletionTracker;
+    maxDependencyCompletions: number;
+    jobResults: MapLike<JobId, unknown>;
+    dependencyResults: DependencyResultTracker;
+    jobIndex: Map<JobId, JobLocation>;
+    customIdMap?: MapLike<string, JobId>;
+    totalCompleted: {
+        value: bigint;
+    };
+    totalFailed: {
+        value: bigint;
+    };
+    perQueueMetrics?: MapLike<string, {
+        totalCompleted: bigint;
+        totalFailed: bigint;
+    }>;
+    broadcast: (event: {
+        eventType: EventType;
+        queue: string;
+        jobId: JobId;
+        timestamp: number;
+        data?: unknown;
+        error?: string;
+        prev?: string;
+        terminal?: boolean;
+    }) => void;
+    onJobCompleted: (jobId: JobId) => void;
+    onJobFailed?: (jobId: JobId) => void;
+    onJobsCompleted?: (jobIds: JobId[]) => void;
+    needsBroadcast?: () => boolean;
+    emitDashboardEvent?: (event: string, data: Record<string, unknown>) => void;
+    hasPendingDeps?: () => boolean;
+    onRepeat?: (job: Job) => void;
+    onChildTerminalFailure?: (childJob: Job, error: string | undefined) => Promise<void>;
+    onChildDependencyOption?: (childJob: Job, error: string | undefined) => Promise<void>;
+}
+export interface ExtractedJob<T = unknown> {
+    id: JobId;
+    job: Job;
+    result?: T;
+    removeOnComplete?: boolean;
+}
+export interface CompletionOptions {
+    removeOnComplete?: boolean;
+    /** Internal lease identity used only to match a retired cron generation. */
+    leaseToken?: string;
+}
+export interface AckAlreadyFinalized {
+    readonly applied: false;
+    readonly reason: 'already-finalized';
+}
+/** Normal ACKs preserve the historical undefined return value. */
+export type AckOutcome = undefined | AckAlreadyFinalized;
+export interface AckBatchIgnored {
+    readonly ignoredIds: JobId[];
+    /** Input positions preserve generation identity when a job ID is repeated. */
+    readonly ignoredIndices: number[];
+}
+export type AckBatchOutcome = undefined | AckBatchIgnored;
+export interface BatchContext {
+    processingShards: Map<JobId, Job>[];
+    processingLocks: RWLock[];
+    shards: Shard[];
+    shardLocks: RWLock[];
+}
+export interface FinalizeContext {
+    storage: SqliteStorage | null;
+    shards: Shard[];
+    completedJobs: SetLike<JobId>;
+    completedJobsData: MapLike<JobId, Job>;
+    depCompletions?: DependencyCompletionTracker;
+    maxDependencyCompletions: number;
+    jobResults: MapLike<JobId, unknown>;
+    dependencyResults?: DependencyResultTracker;
+    jobIndex: Map<JobId, JobLocation>;
+    customIdMap?: MapLike<string, JobId>;
+    totalCompleted: {
+        value: bigint;
+    };
+    perQueueMetrics?: MapLike<string, {
+        totalCompleted: bigint;
+        totalFailed: bigint;
+    }>;
+    broadcast: (event: {
+        eventType: EventType;
+        queue: string;
+        jobId: JobId;
+        timestamp: number;
+        data?: unknown;
+    }) => void;
+    onJobCompleted: (jobId: JobId) => void;
+    onJobsCompleted?: (jobIds: JobId[]) => void;
+    needsBroadcast?: () => boolean;
+    hasPendingDeps?: () => boolean;
+    onRepeat?: (job: Job) => void;
+}
+export interface TerminalFailureInput {
+    job: Job;
+    jobId: JobId;
+    error: string | undefined;
+    shard: Shard;
+    ctx: AckContext;
+    flowFailure: FlowFailureRecord | null;
+    reason: FailureReason;
+}
+export interface FailJobOptions {
+    unrecoverable?: boolean;
+    stack?: string[];
+    failureReason?: FailureReason;
+    removeOnFail?: boolean;
+    /** Runs synchronously while the exact processing generation is claimed. */
+    onClaim?: (job: Job) => void;
+}

package/dist/application/types/ack.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,18 @@
+import type { CronScheduler } from '../../infrastructure/scheduler/cronScheduler';
+import type { JobId } from '../../domain/types/job';
+import type { JobTimeoutScheduler } from '../background/timeouts';
+/** A processing generation whose timeout transition won before its worker outcome. */
+export interface RetiredTimeoutGeneration {
+    readonly jobId: JobId;
+    readonly startedAt: number;
+    readonly token?: string;
+}
+export interface BackgroundTaskHandles {
+    cleanupInterval: ReturnType<typeof setInterval>;
+    timeoutScheduler: JobTimeoutScheduler;
+    depCheckInterval: ReturnType<typeof setInterval>;
+    stallCheckInterval: ReturnType<typeof setInterval>;
+    dlqMaintenanceInterval: ReturnType<typeof setInterval>;
+    lockCheckInterval: ReturnType<typeof setInterval>;
+    cronScheduler: CronScheduler;
+}

package/dist/application/types/background.js

@@ -0,0 +1 @@
+export {};

package/dist/application/types/config.d.ts

@@ -0,0 +1,37 @@
+/** Queue Manager configuration. */
+export interface QueueManagerConfig {
+    dataPath?: string;
+    maxCompletedJobs?: number;
+    maxJobResults?: number;
+    maxJobLogs?: number;
+    maxCustomIds?: number;
+    maxWaitingDeps?: number;
+    /** Maximum queue label values emitted in one Prometheus scrape; zero disables them. */
+    maxPrometheusQueues?: number;
+    /** Maximum retained lifecycle events per queue. */
+    maxQueueEvents?: number;
+    /** Maximum retained one-minute metric buckets per queue and terminal state. */
+    maxMetricDataPoints?: number;
+    cleanupIntervalMs?: number;
+    /** Retry delay after a processing-timeout transition fails. */
+    jobTimeoutCheckMs?: number;
+    dependencyCheckMs?: number;
+    stallCheckMs?: number;
+    dlqMaintenanceMs?: number;
+    validateWebhookUrls?: boolean;
+}
+export declare const DEFAULT_CONFIG: {
+    maxCompletedJobs: number;
+    maxJobResults: number;
+    maxJobLogs: number;
+    maxCustomIds: number;
+    maxWaitingDeps: number;
+    maxPrometheusQueues: number;
+    maxQueueEvents: number;
+    maxMetricDataPoints: number;
+    cleanupIntervalMs: number;
+    jobTimeoutCheckMs: number;
+    dependencyCheckMs: number;
+    stallCheckMs: number;
+    dlqMaintenanceMs: number;
+};

package/dist/application/{types.js → types/config.js}

@@ -1,6 +1,3 @@
-/**
- * Shared types for QueueManager modules
- */
 export const DEFAULT_CONFIG = {
     maxCompletedJobs: 50_000,
     maxJobResults: 10_000,
@@ -8,9 +5,11 @@ export const DEFAULT_CONFIG = {
     maxCustomIds: 50_000,
     maxWaitingDeps: 10_000,
     maxPrometheusQueues: 100,
+    maxQueueEvents: 10_000,
+    maxMetricDataPoints: 20_160,
     cleanupIntervalMs: 10_000,
     jobTimeoutCheckMs: 5_000,
-    dependencyCheckMs: 30_000, // Safety fallback only; event-driven handles fast path
+    dependencyCheckMs: 30_000,
     stallCheckMs: 5_000,
     dlqMaintenanceMs: 60_000,
 };

package/dist/application/types/contextFactory.d.ts

@@ -0,0 +1,83 @@
+import type { Shard } from '../../domain/queue/shard';
+import type { FailureReason } from '../../domain/types/dlq';
+import type { Job, JobId, JobLock } from '../../domain/types/job';
+import type { JobLocation } from '../../domain/types/queue';
+import type { JobLogEntry } from '../../domain/types/worker';
+import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
+import type { BoundedMap, BoundedSet, LRUMap, MapLike } from '../../shared/lru';
+import type { RWLock } from '../../shared/lock';
+import type { DependencyCompletionTracker } from '../dependencyCompletions';
+import type { DependencyResultTracker } from '../dependencyResultTracker';
+import type { EventsManager } from '../eventsManager';
+import type { MonitoringState } from '../monitoringChecks';
+import type { WebhookManager } from '../webhookManager';
+import type { WorkerManager } from '../workerManager';
+import type { DEFAULT_CONFIG } from './config';
+import type { JobTimeoutScheduler } from '../background/timeouts';
+import type { RetiredTimeoutGeneration } from './background';
+export interface ContextDependencies {
+    config: typeof DEFAULT_CONFIG & {
+        dataPath?: string;
+    };
+    storage: SqliteStorage | null;
+    shards: Shard[];
+    shardLocks: RWLock[];
+    customIdLock: RWLock;
+    processingShards: Map<JobId, Job>[];
+    processingLocks: RWLock[];
+    jobIndex: Map<JobId, JobLocation>;
+    completedJobs: BoundedSet<JobId>;
+    completedJobsData: BoundedMap<JobId, Job>;
+    depCompletions?: DependencyCompletionTracker;
+    timedOutJobs: BoundedMap<JobId, RetiredTimeoutGeneration>;
+    retiredTimeoutLeaseTokens: BoundedMap<string, RetiredTimeoutGeneration>;
+    retiredCronLeaseTokens: BoundedMap<JobId, string>;
+    timeoutScheduler: JobTimeoutScheduler;
+    jobResults: LRUMap<JobId, unknown>;
+    dependencyResults: DependencyResultTracker;
+    customIdMap: LRUMap<string, JobId>;
+    jobLogs: LRUMap<JobId, JobLogEntry[]>;
+    jobLocks: Map<JobId, JobLock>;
+    clientJobs: Map<string, Set<JobId>>;
+    stalledCandidates: Set<JobId>;
+    pendingDepChecks: Set<JobId>;
+    queueNamesCache: Set<string>;
+    repeatChain: Map<JobId, JobId>;
+    eventsManager: EventsManager;
+    webhookManager: WebhookManager;
+    workerManager: WorkerManager;
+    monitoringState: MonitoringState;
+    metrics: {
+        totalPushed: {
+            value: bigint;
+        };
+        totalPulled: {
+            value: bigint;
+        };
+        totalCompleted: {
+            value: bigint;
+        };
+        totalFailed: {
+            value: bigint;
+        };
+    };
+    startTime: number;
+    maxLogsPerJob: number;
+    perQueueMetrics: MapLike<string, {
+        totalCompleted: bigint;
+        totalFailed: bigint;
+    }>;
+}
+export interface ContextCallbacks {
+    fail: (jobId: JobId, error?: string, failureReason?: FailureReason) => Promise<void>;
+    registerQueueName: (queue: string) => void;
+    unregisterQueueName: (queue: string) => void;
+    onJobCompleted: (completedId: JobId) => void;
+    onJobFailed?: (failedId: JobId) => void;
+    onJobsCompleted: (completedIds: JobId[]) => void;
+    hasPendingDeps: () => boolean;
+    onRepeat: (job: Job) => void;
+    emitDashboardEvent?: (event: string, data: Record<string, unknown>) => void;
+    onChildTerminalFailure?: (childJob: Job, error: string | undefined) => Promise<void>;
+    onChildDependencyOption?: (childJob: Job, error: string | undefined) => Promise<void>;
+}

package/dist/application/types/contextFactory.js

@@ -0,0 +1 @@
+export {};