bunqueue-client 0.1.8 → 0.2.0

package/dist/types/src/application/queue-manager/state.d.ts

@@ -0,0 +1,96 @@
+import type { Job, JobId, JobLock } from "../../domain/types/job.js";
+import type { JobLocation } from "../../domain/types/queue.js";
+import type { JobLogEntry } from "../../domain/types/worker.js";
+import { Shard } from "../../domain/queue/shard.js";
+import { SqliteStorage } from "../../infrastructure/persistence/sqlite.js";
+import { CronScheduler } from "../../infrastructure/scheduler/cronScheduler.js";
+import { RWLock } from "../../shared/lock.js";
+import { BoundedMap, BoundedSet, LRUMap } from "../../shared/lru.js";
+import { WebhookManager } from "../webhookManager.js";
+import { WorkerManager } from "../workerManager.js";
+import { EventsManager } from "../eventsManager.js";
+import { type MonitoringState } from "../monitoringChecks.js";
+import type { OperationalMetrics } from "../metricsExporter.js";
+import { DEFAULT_CONFIG, type QueueManagerConfig } from "../types/index.js";
+import * as bgTasks from "../backgroundTasks.js";
+import { ContextFactory } from "../contextFactory.js";
+import { DependencyResultTracker } from "../dependencyResultTracker.js";
+import { DependencyCompletionTracker } from "../dependencyCompletions.js";
+import { JobTimeoutScheduler } from "../background/timeouts.js";
+import type { RetiredTimeoutGeneration } from "../types/background.js";
+import { QueueTelemetryJournal } from "../queueTelemetryJournal.js";
+export type { QueueManagerConfig };
+export declare abstract class QueueManagerState {
+    protected readonly config: typeof DEFAULT_CONFIG & {
+        dataPath?: string;
+    };
+    protected readonly storage: SqliteStorage | null;
+    protected readonly shards: Shard[];
+    protected readonly shardLocks: RWLock[];
+    protected readonly customIdLock: RWLock;
+    protected readonly processingShards: Map<JobId, Job>[];
+    protected readonly processingLocks: RWLock[];
+    protected readonly jobIndex: Map<JobId, JobLocation>;
+    protected readonly completedJobs: BoundedSet<JobId>;
+    protected readonly completedJobsData: BoundedMap<JobId, Job>;
+    protected readonly depCompletions: DependencyCompletionTracker;
+    protected readonly timedOutJobs: BoundedMap<JobId, RetiredTimeoutGeneration>;
+    protected readonly retiredTimeoutLeaseTokens: BoundedMap<string, RetiredTimeoutGeneration>;
+    protected readonly retiredCronLeaseTokens: BoundedMap<JobId, string>;
+    protected readonly timeoutScheduler: JobTimeoutScheduler;
+    protected readonly jobResults: LRUMap<JobId, unknown>;
+    protected readonly jobResultQueues: Map<JobId, string>;
+    protected readonly dependencyResults: DependencyResultTracker;
+    protected readonly customIdMap: LRUMap<string, JobId>;
+    protected readonly jobLogs: LRUMap<JobId, JobLogEntry[]>;
+    protected readonly jobLogQueues: Map<JobId, string>;
+    protected readonly pendingDepChecks: Set<JobId>;
+    protected readonly pendingQueueAdmissions: Map<string, number>;
+    protected readonly pendingQueueObliterations: Set<string>;
+    protected readonly stalledCandidates: Set<JobId>;
+    protected depFlushScheduled: boolean;
+    protected depFlushRunning: boolean;
+    protected readonly jobLocks: Map<JobId, JobLock>;
+    protected readonly clientJobs: Map<string, Set<JobId>>;
+    protected readonly repeatChain: Map<JobId, JobId>;
+    protected readonly failedChildrenValues: Map<JobId, Record<string, string>>;
+    protected readonly ignoredChildrenFailures: Map<JobId, Record<string, string>>;
+    protected readonly cronScheduler: CronScheduler;
+    readonly webhookManager: WebhookManager;
+    readonly workerManager: WorkerManager;
+    protected readonly eventsManager: EventsManager;
+    protected dashboardEmit: ((event: string, data: Record<string, unknown>) => void) | null;
+    protected recoveryStats: {
+        queues: number;
+        jobs: number;
+    } | null;
+    protected readonly maxLogsPerJob = 100;
+    protected readonly metrics: {
+        totalPushed: {
+            value: bigint;
+        };
+        totalPulled: {
+            value: bigint;
+        };
+        totalCompleted: {
+            value: bigint;
+        };
+        totalFailed: {
+            value: bigint;
+        };
+    };
+    protected operationalMetricsProvider: (() => OperationalMetrics) | null;
+    protected readonly perQueueMetrics: LRUMap<string, {
+        totalCompleted: bigint;
+        totalFailed: bigint;
+    }>;
+    protected readonly telemetryJournal: QueueTelemetryJournal;
+    protected readonly startTime: number;
+    protected readonly backgroundTaskHandles: bgTasks.BackgroundTaskHandles | null;
+    protected readonly queueNamesCache: Set<string>;
+    protected readonly monitoringState: MonitoringState;
+    protected readonly contextFactory: ContextFactory;
+    protected scheduleJobTimeout(job: Job): void;
+    protected syncJobTimeout(jobId: JobId): void;
+    constructor(config?: QueueManagerConfig);
+}

package/dist/types/src/application/queue-manager/stats.d.ts

@@ -0,0 +1,28 @@
+import * as statsMgr from "../statsManager.js";
+import { QueueManagerJobManagement } from "./job-management.js";
+export declare class QueueManagerStats extends QueueManagerJobManagement {
+    getStats(): statsMgr.QueueStats;
+    getQueuesSummary(): Array<{
+        name: string;
+        paused: boolean;
+        counts: {
+            waiting: number;
+            prioritized: number;
+            active: number;
+            completed: number;
+            failed: number;
+            delayed: number;
+        };
+    }>;
+    getAllQueueJobCounts(): Map<string, statsMgr.QueueJobCounts>;
+    getQueueJobCountsBatch(queueNames: Iterable<string>): Map<string, statsMgr.QueueJobCounts>;
+    getQueueJobCounts(queueName: string): statsMgr.QueueJobCounts;
+    getMemoryStats(): statsMgr.MemoryStats;
+    getStorageStatus(): {
+        diskFull: boolean;
+        error: string | null;
+        since: number | null;
+    };
+    flushPersistence(): number;
+    compactMemory(): void;
+}

package/dist/types/src/application/queueManager.d.ts

@@ -0,0 +1,5 @@
+/** Public QueueManager façade. Implementation lives in queue-manager/. */
+import { QueueManagerLifecycle } from "./queue-manager/lifecycle.js";
+export type { QueueManagerConfig } from "./types/index.js";
+export declare class QueueManager extends QueueManagerLifecycle {
+}

package/dist/types/src/application/queueStatsAggregator.d.ts

@@ -0,0 +1,23 @@
+import type { StatsContext } from "./types/index.js";
+export interface PerQueueStats {
+    waiting: number;
+    prioritized: number;
+    delayed: number;
+    active: number;
+    dlq: number;
+}
+export interface QueueJobCounts {
+    waiting: number;
+    prioritized: number;
+    delayed: number;
+    active: number;
+    completed: number;
+    failed: number;
+    'waiting-children': number;
+    totalCompleted: number;
+    totalFailed: number;
+}
+/** Aggregate all requested queues in one pass over every global collection. */
+export declare function getAllQueueJobCounts(queueNames: Iterable<string>, ctx: StatsContext): Map<string, QueueJobCounts>;
+export declare function getPerQueueStats(ctx: StatsContext, queueNames: Set<string>): Map<string, PerQueueStats>;
+export declare function getQueueJobCounts(queueName: string, ctx: StatsContext): QueueJobCounts;

package/dist/types/src/application/queueTelemetryJournal.d.ts

@@ -0,0 +1,24 @@
+import type { QueueMetrics, QueueMetricType } from "../domain/types/metrics.js";
+import { type JobEvent } from "../domain/types/queue.js";
+import type { SqliteStorage } from "../infrastructure/persistence/sqlite.js";
+/** Per-queue bounded event journal and cumulative minute metrics. */
+export declare class QueueTelemetryJournal {
+    private readonly storage;
+    private readonly eventCounts;
+    private readonly metrics;
+    private readonly maxEvents;
+    private readonly maxMetricDataPoints;
+    constructor(storage: SqliteStorage | null, maxEvents: number, maxMetricDataPoints: number);
+    record(event: JobEvent): void;
+    /** Persist a lifecycle batch atomically, with scalar fallback on write failure. */
+    recordBatch(events: readonly JobEvent[]): void;
+    getMetrics(queue: string, type: QueueMetricType, start?: number, end?: number): QueueMetrics;
+    trimEvents(queue: string, maxLength: number): number;
+    clearQueue(queue: string): void;
+    clearQueueMemory(queue: string): void;
+    clearQueueEventsMemory(queue: string): void;
+    clearMemory(): void;
+    private getMemoryMetrics;
+    private pruneBuckets;
+    private expandBuckets;
+}

package/dist/types/src/application/repeatJobs.d.ts

@@ -0,0 +1,7 @@
+import type { Job, JobInput, RepeatConfig } from "../domain/types/job.js";
+/** 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/types/src/application/stallDetection.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Stall Detection - Job stall detection and recovery
+ * Uses two-phase detection (like BullMQ) to prevent false positives
+ */
+import type { BackgroundContext } from "./types/index.js";
+/**
+ * Check for stalled jobs and handle them
+ * Uses two-phase detection to prevent false positives
+ */
+export declare function checkStalledJobs(ctx: BackgroundContext): void;

package/dist/types/src/application/statsManager.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Stats Manager - Queue statistics and memory management
+ * Provides system metrics and memory compaction utilities
+ */
+import type { StatsContext } from "./types/index.js";
+export { getAllQueueJobCounts, getPerQueueStats, getQueueJobCounts } from "./queueStatsAggregator.js";
+export type { PerQueueStats, QueueJobCounts } from "./queueStatsAggregator.js";
+export interface QueueStats {
+    waiting: number;
+    prioritized: number;
+    delayed: number;
+    active: number;
+    dlq: number;
+    completed: number;
+    'waiting-children': number;
+    totalPushed: bigint;
+    totalPulled: bigint;
+    totalCompleted: bigint;
+    totalFailed: bigint;
+    uptime: number;
+    cronJobs: number;
+    cronPending: number;
+}
+export interface MemoryStats {
+    jobIndex: number;
+    completedJobs: number;
+    jobResults: number;
+    jobLogs: number;
+    customIdMap: number;
+    jobLocks: number;
+    clientJobs: number;
+    clientJobsTotal: number;
+    pendingDepChecks: number;
+    stalledCandidates: number;
+    processingTotal: number;
+    queuedTotal: number;
+    waitingDepsTotal: number;
+    temporalIndexTotal: number;
+    delayedHeapTotal: number;
+}
+/**
+ * Get queue statistics - uses running counters + priority scan
+ */
+export declare function getStats(ctx: StatsContext, cronScheduler: {
+    getStats(): {
+        total: number;
+        pending: number;
+    };
+}): QueueStats;
+/**
+ * Get detailed memory statistics for debugging memory issues.
+ * Returns counts of entries in all major collections.
+ */
+export declare function getMemoryStats(ctx: StatsContext): MemoryStats;
+/**
+ * Force compact all collections to reduce memory usage.
+ * Use after large batch operations or when memory pressure is high.
+ */
+export declare function compactMemory(ctx: StatsContext): void;

package/dist/types/src/application/taskErrorTracking.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Task Error Tracking - Circuit breaker for background tasks
+ * Extracted for reuse by both backgroundTasks.ts and queueManager.ts
+ */
+/** Track consecutive failures per task type */
+export interface TaskErrorState {
+    consecutiveFailures: number;
+    lastError?: string;
+    lastFailureAt?: number;
+}
+/**
+ * Handle task error with tracking and circuit breaker pattern
+ */
+export declare function handleTaskError(taskName: string, err: unknown): void;
+/**
+ * Reset error state on successful task completion
+ */
+export declare function handleTaskSuccess(taskName: string): void;
+/**
+ * Get error statistics for monitoring
+ */
+export declare function getTaskErrorStats(): Record<string, TaskErrorState>;

package/dist/types/src/application/throughputTracker.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Throughput Tracker
+ * Tracks per-second throughput rates using exponential moving average (EMA)
+ * O(1) per observation, no allocations
+ */
+/** EMA-based rate tracker */
+declare class RateTracker {
+    private count;
+    private lastRate;
+    private lastCalcTime;
+    /** EMA smoothing factor (0-1). Lower = smoother. 0.3 gives ~3 sample memory */
+    private readonly alpha;
+    constructor(alpha?: number);
+    /** Record one event */
+    increment(n?: number): void;
+    /** Calculate current rate (calls per second) */
+    getRate(): number;
+}
+export declare class ThroughputTracker {
+    readonly pushRate: RateTracker;
+    readonly pullRate: RateTracker;
+    readonly completeRate: RateTracker;
+    readonly failRate: RateTracker;
+    /** Get all rates (per second) */
+    getRates(): {
+        pushPerSec: number;
+        pullPerSec: number;
+        completePerSec: number;
+        failPerSec: number;
+    };
+}
+/** Global singleton */
+export declare const throughputTracker: ThroughputTracker;
+export {};

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

@@ -0,0 +1,136 @@
+import type { Shard } from "../../domain/queue/shard.js";
+import type { FlowFailureRecord } from "../../domain/types/flow.js";
+import type { FailureReason } from "../../domain/types/dlq.js";
+import type { Job, JobId } from "../../domain/types/job.js";
+import type { EventType, JobEvent, JobLocation } from "../../domain/types/queue.js";
+import type { SqliteStorage } from "../../infrastructure/persistence/sqlite.js";
+import type { RWLock } from "../../shared/lock.js";
+import type { MapLike, SetLike } from "../../shared/lru.js";
+import type { DependencyCompletionTracker } from "../dependencyCompletions.js";
+import type { DependencyResultTracker } from "../dependencyResultTracker.js";
+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>;
+    jobResultQueues: Map<JobId, string>;
+    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;
+    broadcastBatch?: (events: readonly JobEvent[]) => 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>;
+    jobResultQueues: Map<JobId, string>;
+    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;
+    broadcastBatch?: (events: readonly JobEvent[]) => 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/types/src/application/types/background.d.ts

@@ -0,0 +1,18 @@
+import type { CronScheduler } from "../../infrastructure/scheduler/cronScheduler.js";
+import type { JobId } from "../../domain/types/job.js";
+import type { JobTimeoutScheduler } from "../background/timeouts.js";
+/** 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/types/src/application/types/config.d.ts

@@ -0,0 +1,41 @@
+/** Queue Manager configuration. */
+export interface QueueManagerConfig {
+    dataPath?: string;
+    maxCompletedJobs?: number;
+    /** Delete retained completed jobs after this age; null/undefined disables automatic retention. */
+    completedRetentionMs?: number | null;
+    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;
+    completedRetentionMs: number | null;
+    maxJobResults: number;
+    maxJobLogs: number;
+    maxCustomIds: number;
+    maxWaitingDeps: number;
+    maxPrometheusQueues: number;
+    maxQueueEvents: number;
+    maxMetricDataPoints: number;
+    cleanupIntervalMs: number;
+    jobTimeoutCheckMs: number;
+    dependencyCheckMs: number;
+    stallCheckMs: number;
+    dlqMaintenanceMs: number;
+};
+export declare function normalizeCompletedRetentionMs(value: number | null | undefined): number | null;

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

@@ -0,0 +1,87 @@
+import type { Shard } from "../../domain/queue/shard.js";
+import type { FailureReason } from "../../domain/types/dlq.js";
+import type { Job, JobId, JobLock } from "../../domain/types/job.js";
+import type { JobLocation } from "../../domain/types/queue.js";
+import type { JobLogEntry } from "../../domain/types/worker.js";
+import type { SqliteStorage } from "../../infrastructure/persistence/sqlite.js";
+import type { BoundedMap, BoundedSet, LRUMap, MapLike } from "../../shared/lru.js";
+import type { RWLock } from "../../shared/lock.js";
+import type { DependencyCompletionTracker } from "../dependencyCompletions.js";
+import type { DependencyResultTracker } from "../dependencyResultTracker.js";
+import type { EventsManager } from "../eventsManager.js";
+import type { MonitoringState } from "../monitoringChecks.js";
+import type { WebhookManager } from "../webhookManager.js";
+import type { WorkerManager } from "../workerManager.js";
+import type { DEFAULT_CONFIG } from "./config.js";
+import type { JobTimeoutScheduler } from "../background/timeouts.js";
+import type { RetiredTimeoutGeneration } from "./background.js";
+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>;
+    jobResultQueues: Map<JobId, string>;
+    dependencyResults: DependencyResultTracker;
+    customIdMap: LRUMap<string, JobId>;
+    jobLogs: LRUMap<JobId, JobLogEntry[]>;
+    jobLogQueues: Map<JobId, string>;
+    jobLocks: Map<JobId, JobLock>;
+    clientJobs: Map<string, Set<JobId>>;
+    stalledCandidates: Set<JobId>;
+    pendingDepChecks: Set<JobId>;
+    pendingQueueAdmissions: Map<string, number>;
+    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;
+    onQueueAdmissionsDrained: (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>;
+}