bunqueue-client 0.1.8 → 0.2.0

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

@@ -0,0 +1,114 @@
+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 { RWLock } from "../../shared/lock.js";
+import type { BoundedMap, BoundedSet, LRUMap, MapLike, SetLike } from "../../shared/lru.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 QueueManagerState {
+    readonly config: typeof DEFAULT_CONFIG & {
+        dataPath?: string;
+    };
+    readonly storage: SqliteStorage | null;
+    readonly shards: Shard[];
+    readonly shardLocks: RWLock[];
+    readonly processingShards: Map<JobId, Job>[];
+    readonly processingLocks: RWLock[];
+    readonly jobIndex: Map<JobId, JobLocation>;
+    readonly completedJobs: BoundedSet<JobId>;
+    readonly jobResults: LRUMap<JobId, unknown>;
+    readonly jobResultQueues: Map<JobId, string>;
+    readonly dependencyResults: DependencyResultTracker;
+    readonly customIdMap: LRUMap<string, JobId>;
+    readonly jobLogs: LRUMap<JobId, JobLogEntry[]>;
+    readonly jobLogQueues: Map<JobId, string>;
+    readonly jobLocks: Map<JobId, JobLock>;
+    readonly timedOutJobs: MapLike<JobId, RetiredTimeoutGeneration>;
+    readonly retiredTimeoutLeaseTokens: MapLike<string, RetiredTimeoutGeneration>;
+    readonly retiredCronLeaseTokens: MapLike<JobId, string>;
+    readonly timeoutScheduler: JobTimeoutScheduler;
+    readonly clientJobs: Map<string, Set<JobId>>;
+    readonly stalledCandidates: Set<JobId>;
+    readonly pendingDepChecks: Set<JobId>;
+    readonly pendingQueueAdmissions: Map<string, number>;
+    readonly queueNamesCache: Set<string>;
+    readonly eventsManager: EventsManager;
+    readonly webhookManager: WebhookManager;
+    readonly metrics: QueueManagerMetrics;
+    readonly startTime: number;
+    readonly perQueueMetrics: MapLike<string, {
+        totalCompleted: bigint;
+        totalFailed: bigint;
+    }>;
+}
+export interface QueueManagerMetrics {
+    totalPushed: {
+        value: bigint;
+    };
+    totalPulled: {
+        value: bigint;
+    };
+    totalCompleted: {
+        value: bigint;
+    };
+    totalFailed: {
+        value: bigint;
+    };
+}
+export interface LockContext {
+    jobIndex: Map<JobId, JobLocation>;
+    jobLocks: Map<JobId, JobLock>;
+    retiredCronLeaseTokens: MapLike<JobId, string>;
+    clientJobs: Map<string, Set<JobId>>;
+    processingShards: Map<JobId, Job>[];
+    processingLocks: RWLock[];
+    shards: Shard[];
+    shardLocks: RWLock[];
+    eventsManager: EventsManager;
+    dashboardEmit?: (event: string, data: Record<string, unknown>) => void;
+    storage: SqliteStorage | null;
+    timeoutScheduler: JobTimeoutScheduler;
+}
+export interface BackgroundContext extends QueueManagerState {
+    fail: (jobId: JobId, error?: string, failureReason?: FailureReason) => Promise<void>;
+    registerQueueName: (queue: string) => void;
+    unregisterQueueName: (queue: string) => void;
+    dashboardEmit?: (event: string, data: Record<string, unknown>) => void;
+    workerManager: WorkerManager;
+    monitoringState: MonitoringState;
+    completedJobsData: BoundedMap<JobId, Job>;
+    depCompletions?: DependencyCompletionTracker;
+    maxDependencyCompletions: number;
+    timedOutJobs: BoundedMap<JobId, RetiredTimeoutGeneration>;
+    retiredTimeoutLeaseTokens: BoundedMap<string, RetiredTimeoutGeneration>;
+}
+export interface StatsContext {
+    storage?: SqliteStorage | null;
+    shards: Shard[];
+    processingShards: Map<JobId, Job>[];
+    completedJobs: SetLike<JobId>;
+    jobIndex: Map<JobId, JobLocation>;
+    jobResults: LRUMap<JobId, unknown>;
+    jobLogs: LRUMap<JobId, JobLogEntry[]>;
+    customIdMap: LRUMap<string, JobId>;
+    jobLocks: Map<JobId, JobLock>;
+    clientJobs: Map<string, Set<JobId>>;
+    pendingDepChecks: Set<JobId>;
+    stalledCandidates: Set<JobId>;
+    metrics: QueueManagerMetrics;
+    startTime: number;
+    perQueueMetrics?: MapLike<string, {
+        totalCompleted: bigint;
+        totalFailed: bigint;
+    }>;
+}

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

@@ -0,0 +1,7 @@
+export { DEFAULT_CONFIG } from "./config.js";
+export type { AckContext, BatchContext, ExtractedJob, FinalizeContext } from "./ack.js";
+export type { BackgroundTaskHandles } from "./background.js";
+export type { QueueManagerConfig } from "./config.js";
+export type { BackgroundContext, LockContext, QueueManagerMetrics, QueueManagerState, StatsContext, } from "./contexts.js";
+export type { QueueManagerRuntime, QueueManagerRuntimeApi, QueueManagerStateView, } from "./queueManager.js";
+export type { GetJobsContext, QueryContext } from "./query.js";

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

@@ -0,0 +1,23 @@
+import type { Shard } from "../../domain/queue/shard.js";
+import type { JobLocation } from "../../domain/types/queue.js";
+import type { Job, JobId } from "../../domain/types/job.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 { DependencyResultTracker } from "../dependencyResultTracker.js";
+export interface QueryContext {
+    storage: SqliteStorage | null;
+    shards: Shard[];
+    shardLocks: RWLock[];
+    processingShards: Map<JobId, Job>[];
+    processingLocks: RWLock[];
+    jobIndex: Map<JobId, JobLocation>;
+    completedJobs: SetLike<JobId>;
+    completedJobsData: MapLike<JobId, Job>;
+    jobResults: MapLike<JobId, unknown>;
+    dependencyResults: DependencyResultTracker;
+    customIdMap: MapLike<string, JobId>;
+}
+export interface GetJobsContext extends QueryContext {
+    shardCount: number;
+}

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

@@ -0,0 +1,98 @@
+import type { Shard } from "../../domain/queue/shard.js";
+import type { DlqEntry } from "../../domain/types/dlq.js";
+import type { FailureReason } from "../../domain/types/dlq.js";
+import type { Job, JobId, JobInput, 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 { CronScheduler } from "../../infrastructure/scheduler/cronScheduler.js";
+import type { RWLock } from "../../shared/lock.js";
+import type { BoundedMap, BoundedSet, LRUMap } from "../../shared/lru.js";
+import type { DependencyCompletionTracker } from "../dependencyCompletions.js";
+import type { DependencyResultTracker } from "../dependencyResultTracker.js";
+import type { EventsManager } from "../eventsManager.js";
+import type { OperationalMetrics } from "../metricsExporter.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";
+import type { AckOutcome } from "./ack.js";
+export interface QueueManagerStateView {
+    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>;
+    pendingDepChecks: Set<JobId>;
+    pendingQueueAdmissions: Map<string, number>;
+    stalledCandidates: Set<JobId>;
+    jobLocks: Map<JobId, JobLock>;
+    clientJobs: Map<string, Set<JobId>>;
+    repeatChain: Map<JobId, JobId>;
+    queueNamesCache: Set<string>;
+    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: LRUMap<string, {
+        totalCompleted: bigint;
+        totalFailed: bigint;
+    }>;
+    failedChildrenValues: Map<JobId, Record<string, string>>;
+    ignoredChildrenFailures: Map<JobId, Record<string, string>>;
+    cronScheduler: CronScheduler;
+    operationalMetricsProvider: (() => OperationalMetrics) | null;
+}
+export interface QueueManagerRuntimeApi {
+    push(queue: string, input: JobInput): Promise<Job>;
+    fail(jobId: JobId, error?: string): Promise<AckOutcome>;
+    failWithReason(jobId: JobId, error: string | undefined, reason: FailureReason): Promise<AckOutcome>;
+    registerQueueName(queue: string): void;
+    unregisterQueueName(queue: string): void;
+    onQueueAdmissionsDrained(queue: string): void;
+    onJobCompleted(jobId: JobId): void;
+    onJobFailed(jobId: JobId): void;
+    onJobsCompleted(jobIds: JobId[]): void;
+    hasPendingDeps(): boolean;
+    emitDashboardEvent(event: string, data: Record<string, unknown>): void;
+    failParentOnChildFailure(job: Job, error: string | undefined): Promise<void>;
+    onChildDependencyOption(job: Job, error: string | undefined): Promise<void>;
+    onDlqEvicted(entry: DlqEntry): void;
+}
+export type QueueManagerRuntime = QueueManagerStateView & QueueManagerRuntimeApi;

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

@@ -0,0 +1,47 @@
+/**
+ * Webhook Manager
+ * Manages webhooks and sends HTTP callbacks
+ */
+import { type Webhook, type WebhookId, type WebhookEvent } from "../domain/types/webhook.js";
+/**
+ * Webhook Manager
+ */
+export declare class WebhookManager {
+    private readonly webhooks;
+    private readonly maxRetries;
+    private readonly retryDelay;
+    private readonly validateUrls;
+    private dashboardEmit;
+    /** Running counter for enabled webhooks - avoids O(n) filter in getStats */
+    private enabledCount;
+    constructor(options?: {
+        validateUrls?: boolean;
+    });
+    /** Set the dashboard event emitter callback */
+    setDashboardEmit(callback: (event: string, data: Record<string, unknown>) => void): void;
+    /** Add a webhook (validates URL to prevent SSRF) */
+    add(url: string, events: string[], queue?: string, secret?: string): Webhook;
+    /** Remove a webhook */
+    remove(id: WebhookId): boolean;
+    /** Get webhook by ID */
+    get(id: WebhookId): Webhook | undefined;
+    /** Set webhook enabled state - properly maintains running counter */
+    setEnabled(id: WebhookId, enabled: boolean): boolean;
+    /** List all webhooks */
+    list(): Webhook[];
+    /** Trigger webhooks for an event */
+    trigger(event: WebhookEvent, jobId: string, queue: string, extra?: {
+        data?: unknown;
+        error?: string;
+        progress?: number;
+    }): Promise<void>;
+    /** Send webhook with retries */
+    private sendWebhook;
+    /** Check if there are any enabled webhooks - O(1) */
+    hasEnabledWebhooks(): boolean;
+    /** Get stats - O(1) using running counter */
+    getStats(): {
+        total: number;
+        enabled: number;
+    };
+}

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

@@ -0,0 +1,61 @@
+/**
+ * Worker Manager
+ * Tracks connected workers and their status
+ */
+import { type Worker, type WorkerId, type CreateWorkerOptions } from "../domain/types/worker.js";
+/**
+ * Worker Manager
+ */
+export declare class WorkerManager {
+    private readonly workers;
+    private cleanupInterval;
+    private dashboardEmit;
+    /** Running counters for O(1) stats - avoids O(n) reduce operations */
+    private totalProcessedCounter;
+    private totalFailedCounter;
+    private totalActiveJobsCounter;
+    constructor();
+    /** Set the dashboard event emitter callback */
+    setDashboardEmit(callback: (event: string, data: Record<string, unknown>) => void): void;
+    /** Register a new worker */
+    register(name: string, queues: string[], concurrency?: number, opts?: CreateWorkerOptions): Worker;
+    /** Unregister a worker */
+    unregister(id: WorkerId): boolean;
+    /** Unregister all workers associated with a TCP client ID */
+    unregisterByClientId(clientId: string): number;
+    /** Get worker by ID */
+    get(id: WorkerId): Worker | undefined;
+    /** Update worker last seen time and optionally client-reported stats */
+    heartbeat(id: WorkerId, stats?: {
+        activeJobs?: number;
+        processed?: number;
+        failed?: number;
+    }): boolean;
+    /** Increment active jobs count */
+    incrementActive(id: WorkerId, jobId?: string): void;
+    /** Decrement active jobs and increment processed */
+    jobCompleted(id: WorkerId): void;
+    /** Decrement active jobs and increment failed */
+    jobFailed(id: WorkerId): void;
+    /** List all workers */
+    list(): Worker[];
+    /** List active workers (seen recently) */
+    listActive(): Worker[];
+    /** Get workers for a specific queue (only active workers with recent heartbeat) */
+    getForQueue(queue: string): Worker[];
+    /** Start cleanup interval */
+    private startCleanup;
+    /** Remove stale workers */
+    private cleanupStale;
+    /** Stop cleanup */
+    stop(): void;
+    /** Get stats - O(n) only for active count, O(1) for other metrics */
+    getStats(): {
+        total: number;
+        active: number;
+        totalProcessed: number;
+        totalFailed: number;
+        activeJobs: number;
+        concurrencySlots: number;
+    };
+}

package/dist/types/src/client/bunqueue/aging.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Bunqueue — Priority Aging
+ * Automatically boosts priority of old waiting jobs.
+ */
+import type { Queue } from "../queue/queue.js";
+import type { PriorityAgingConfig } from "./types.js";
+export declare class PriorityAger<T = unknown> {
+    private timer;
+    private generation;
+    private readonly config;
+    private readonly queue;
+    constructor(config: PriorityAgingConfig, queue: Queue<T>);
+    start(): void;
+    private tick;
+    destroy(): void;
+}

package/dist/types/src/client/bunqueue/batch.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Bunqueue — Batch Processing
+ * Accumulates jobs and processes them in groups.
+ */
+import type { Processor } from "../types.js";
+import type { BatchConfig } from "./types.js";
+export declare class BatchAccumulator<T = unknown, R = unknown> {
+    private readonly buffer;
+    private timer;
+    private readonly config;
+    constructor(config: BatchConfig<T, R>);
+    /** Build a Processor that buffers jobs into batches */
+    buildProcessor(): Processor<T, R>;
+    flush(): void;
+    destroy(): void;
+}

package/dist/types/src/client/bunqueue/cancellation.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Bunqueue — Graceful Job Cancellation
+ * AbortController-based cancellation with optional grace period.
+ */
+export declare class CancellationManager {
+    private readonly currentByJob;
+    private readonly registrations;
+    /** Register a new AbortController for a job */
+    register(jobId: string): AbortController;
+    /** Remove a job's controller (on completion) */
+    unregister(jobId: string, controller?: AbortController): void;
+    /** Cancel a job with optional grace period */
+    cancel(jobId: string, gracePeriodMs?: number): void;
+    /** Check if a job is cancelled */
+    isCancelled(jobId: string): boolean;
+    /** Get the AbortSignal for a job */
+    getSignal(jobId: string): AbortSignal | null;
+    /** Cancel all and clear */
+    destroyAll(): void;
+    private clearTimer;
+}

package/dist/types/src/client/bunqueue/circuitBreaker.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Bunqueue — Circuit Breaker for worker protection
+ */
+import type { Worker } from "../worker/worker.js";
+import type { CircuitBreakerConfig, CircuitState } from "./types.js";
+export declare class WorkerCircuitBreaker {
+    private state;
+    private failures;
+    private timer;
+    private destroyed;
+    private readonly config;
+    private readonly worker;
+    constructor(config: CircuitBreakerConfig, worker: Worker);
+    get currentState(): CircuitState;
+    isOpen(): boolean;
+    onSuccess(): void;
+    onFailure(): void;
+    private open;
+    reset(): void;
+    destroy(): void;
+}

package/dist/types/src/client/bunqueue/dedupDebounce.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Bunqueue — Deduplication & Debounce defaults merger
+ */
+import type { JobOptions } from "../types.js";
+import type { BunqueueDeduplicationConfig, BunqueueDebounceConfig } from "./types.js";
+export declare class DedupDebounceMerger {
+    private readonly dedup;
+    private readonly debounce;
+    constructor(dedup: BunqueueDeduplicationConfig | null, debounce: BunqueueDebounceConfig | null);
+    get active(): boolean;
+    merge(name: string, opts?: JobOptions, data?: unknown): JobOptions | undefined;
+}

package/dist/types/src/client/bunqueue/dlqRateLimit.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Bunqueue — DLQ & Rate Limit helpers
+ * Mixin-style functions that delegate to Queue methods.
+ */
+import type { Queue } from "../queue/queue.js";
+import type { DlqConfig, DlqEntry, DlqStats, DlqFilter } from "../types.js";
+export declare class DlqRateLimitManager<T = unknown> {
+    private readonly queue;
+    constructor(queue: Queue<T>);
+    setDlqConfig(config: Partial<DlqConfig>): void;
+    setDlqConfigAsync(config: Partial<DlqConfig>): Promise<void>;
+    getDlqConfig(): DlqConfig;
+    getDlqConfigAsync(): Promise<DlqConfig>;
+    getDlq(filter?: DlqFilter): DlqEntry<T>[];
+    getDlqAsync(filter?: DlqFilter): Promise<DlqEntry<T>[]>;
+    getDlqStats(): DlqStats;
+    getDlqStatsAsync(): Promise<DlqStats>;
+    retryDlq(id?: string): number;
+    retryDlqAsync(id?: string): Promise<number>;
+    purgeDlq(): number;
+    purgeDlqAsync(): Promise<number>;
+    setGlobalRateLimit(max: number, duration?: number): void;
+    setGlobalRateLimitAsync(max: number, duration?: number): Promise<void>;
+    removeGlobalRateLimit(): void;
+    removeGlobalRateLimitAsync(): Promise<void>;
+}

package/dist/types/src/client/bunqueue/retry.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Bunqueue — Advanced Retry with backoff strategies
+ */
+import type { RetryConfig, RetryStrategy } from "./types.js";
+/** Calculate backoff delay based on strategy */
+export declare function calculateBackoff(strategy: RetryStrategy, attempt: number, baseDelay: number, error: Error, config: RetryConfig): number;
+/** Execute a function with retry logic */
+export declare function executeWithRetry<R>(fn: () => Promise<R>, config: RetryConfig, signal?: AbortSignal): Promise<R>;

package/dist/types/src/client/bunqueue/runtime.d.ts

@@ -0,0 +1,35 @@
+import { Queue } from "../queue/queue.js";
+import { Worker } from "../worker/worker.js";
+import { PriorityAger } from "./aging.js";
+import { BatchAccumulator } from "./batch.js";
+import { CancellationManager } from "./cancellation.js";
+import { WorkerCircuitBreaker } from "./circuitBreaker.js";
+import { DedupDebounceMerger } from "./dedupDebounce.js";
+import { DlqRateLimitManager } from "./dlqRateLimit.js";
+import { TriggerManager } from "./triggers.js";
+import { TtlChecker } from "./ttl.js";
+import type { BunqueueMiddleware, BunqueueOptions } from "./types.js";
+/** Construction and processing pipeline shared by the compact Bunqueue façade. */
+export declare abstract class BunqueueRuntime<T, R> {
+    readonly name: string;
+    readonly queue: Queue<T>;
+    readonly worker: Worker<T, R>;
+    private readonly middlewares;
+    private readonly baseProcessor;
+    protected readonly cb: WorkerCircuitBreaker | null;
+    private readonly retryConfig;
+    protected readonly triggerMgr: TriggerManager<T, R>;
+    protected readonly ager: PriorityAger<T> | null;
+    protected readonly cancellation: CancellationManager;
+    protected readonly ttlChecker: TtlChecker | null;
+    protected readonly batchAcc: BatchAccumulator<T, R> | null;
+    protected readonly merger: DedupDebounceMerger;
+    protected readonly dlqrl: DlqRateLimitManager<T>;
+    constructor(name: string, options: BunqueueOptions<T, R>);
+    private buildRouteProcessor;
+    private buildQueueOptions;
+    private buildWorkerOptions;
+    private processJob;
+    private runMiddlewareChain;
+    use(middleware: BunqueueMiddleware<T, R>): this;
+}

package/dist/types/src/client/bunqueue/triggers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Bunqueue — Event Triggers
+ * When a job completes/fails, automatically create another job.
+ */
+import type { Queue } from "../queue/queue.js";
+import type { Worker } from "../worker/worker.js";
+import type { TriggerRule } from "./types.js";
+export declare class TriggerManager<T = unknown, R = unknown> {
+    private readonly rules;
+    private active;
+    private readonly queue;
+    private readonly worker;
+    constructor(queue: Queue<T>, worker: Worker<T, R>);
+    add(rule: TriggerRule<T>): void;
+    private ensureActive;
+    private fire;
+}

package/dist/types/src/client/bunqueue/ttl.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Bunqueue — Job TTL (Time To Live)
+ * Expire unprocessed jobs based on configurable TTL.
+ */
+import type { JobTtlConfig } from "./types.js";
+export declare class TtlChecker {
+    private readonly config;
+    constructor(config: JobTtlConfig);
+    /** Get TTL for a specific job name */
+    getTtl(jobName: string): number;
+    /** Check if a job has expired */
+    isExpired(jobName: string, jobTimestamp: number): boolean;
+    /** Set default TTL */
+    setDefaultTtl(ttlMs: number): void;
+    /** Set TTL for a specific job name */
+    setNameTtl(jobName: string, ttlMs: number): void;
+}