bunqueue 2.8.54 → 2.8.56

package/dist/infrastructure/persistence/statements.d.ts

@@ -4,7 +4,7 @@
  */
 import type { Database } from 'bun:sqlite';
 /** Statement names */
-export type StatementName = 'insertJob' | 'updateJobState' | 'completeJob' | 'updateJobProgress' | 'deleteJob' | 'deleteJobResult' | 'getJob' | 'insertResult' | 'getResult' | 'insertDlq' | 'loadDlq' | 'deleteDlqEntry' | 'deleteDlqEntryForQueue' | 'clearDlqQueue' | 'insertCron' | 'updateCron' | 'upsertQueueState' | 'loadQueueState' | 'deleteQueueState';
+export type StatementName = 'insertJob' | 'updateJobState' | 'completeJob' | 'updateJobProgress' | 'deleteJob' | 'deleteJobResult' | 'getJob' | 'insertResult' | 'getResult' | 'insertDlq' | 'loadDlq' | 'deleteDlqEntry' | 'deleteDlqEntryForQueue' | 'clearDlqQueue' | 'deleteDependencyCompletionForAdmission' | 'deleteFlowFailuresForAdmission' | 'pinDependencyCompletionForAdmission' | 'insertCron' | 'updateCron' | 'upsertQueueState' | 'loadQueueState' | 'deleteQueueState';
 /** SQL statements */
 export declare const SQL_STATEMENTS: Record<StatementName, string>;
 /** Prepare all statements */
@@ -13,6 +13,7 @@ export declare function prepareStatements(db: Database): Map<StatementName, Retu
 export interface DbJob {
     id: string;
     queue: string;
+    name: string | null;
     data: Uint8Array;
     priority: number;
     created_at: number;
@@ -46,11 +47,14 @@ export interface DbJob {
     stall_count: number;
     timeline: Uint8Array | null;
     stacktrace: Uint8Array | null;
+    dlq_retry_state: Uint8Array | null;
+    extended_options: Uint8Array | null;
 }
 /** Database row type for cron jobs */
 export interface DbCron {
     name: string;
     queue: string;
+    job_name: string | null;
     data: Uint8Array;
     schedule: string | null;
     repeat_every: number | null;

package/dist/infrastructure/persistence/statements.js

@@ -12,20 +12,21 @@ export const SQL_STATEMENTS = {
     // no cascade side effects (unlike REPLACE = DELETE+INSERT).
     insertJob: `
     INSERT INTO jobs (
-      id, queue, data, priority, created_at, run_at, attempts,
+      id, queue, name, data, priority, created_at, run_at, attempts,
       max_attempts, backoff, ttl, timeout, unique_key, custom_id,
       depends_on, parent_id, children_ids, tags, state, lifo, group_id,
       remove_on_complete, remove_on_fail, fail_parent_on_failure,
       remove_dependency_on_failure, continue_parent_on_failure,
-      ignore_dependency_on_failure, stall_timeout, stall_count, timeline
+      ignore_dependency_on_failure, stall_timeout, stall_count, timeline,
+      dlq_retry_state, extended_options
     ) VALUES (
-      ?, ?, ?, ?, ?, ?, ?,
+      ?, ?, ?, ?, ?, ?, ?, ?,
       ?, ?, ?, ?, ?, ?,
       ?, ?, ?, ?, ?, ?, ?,
-      ?, ?, ?, ?, ?, ?, ?, ?, ?
+      ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
     )
     ON CONFLICT(id) DO UPDATE SET
-      queue=excluded.queue, data=excluded.data, priority=excluded.priority,
+      queue=excluded.queue, name=excluded.name, data=excluded.data, priority=excluded.priority,
       created_at=excluded.created_at, run_at=excluded.run_at, attempts=excluded.attempts,
       max_attempts=excluded.max_attempts, backoff=excluded.backoff, ttl=excluded.ttl,
       timeout=excluded.timeout, unique_key=excluded.unique_key, custom_id=excluded.custom_id,
@@ -37,7 +38,8 @@ export const SQL_STATEMENTS = {
       continue_parent_on_failure=excluded.continue_parent_on_failure,
       ignore_dependency_on_failure=excluded.ignore_dependency_on_failure,
       stall_timeout=excluded.stall_timeout, stall_count=excluded.stall_count,
-      timeline=excluded.timeline,
+      timeline=excluded.timeline, dlq_retry_state=excluded.dlq_retry_state,
+      extended_options=excluded.extended_options,
       -- Per-execution columns are NOT in the INSERT column list, so excluded.<col>
       -- resolves to each column's DEFAULT (NULL / 0) — i.e. the fresh-job value. Reset
       -- them too, otherwise an upsert over an ORPHAN row would leave a brand-new job
@@ -47,7 +49,7 @@ export const SQL_STATEMENTS = {
       last_heartbeat=excluded.last_heartbeat, stacktrace=excluded.stacktrace
   `,
     updateJobState: 'UPDATE jobs SET state = ?, started_at = ?, timeline = ? WHERE id = ?',
-    completeJob: 'UPDATE jobs SET state = ?, completed_at = ?, progress = 100, timeline = ? WHERE id = ?',
+    completeJob: 'UPDATE jobs SET state = ?, completed_at = ?, progress = 100, timeline = ?, dlq_retry_state = NULL WHERE id = ?',
     updateJobProgress: 'UPDATE jobs SET progress = ?, progress_msg = ?, last_heartbeat = ? WHERE id = ?',
     deleteJob: 'DELETE FROM jobs WHERE id = ?',
     deleteJobResult: 'DELETE FROM job_results WHERE job_id = ?',
@@ -59,10 +61,13 @@ export const SQL_STATEMENTS = {
     deleteDlqEntry: 'DELETE FROM dlq WHERE job_id = ?',
     deleteDlqEntryForQueue: 'DELETE FROM dlq WHERE job_id = ? AND queue = ?',
     clearDlqQueue: 'DELETE FROM dlq WHERE queue = ?',
+    deleteDependencyCompletionForAdmission: 'DELETE FROM dependency_completions WHERE job_id = ?',
+    deleteFlowFailuresForAdmission: 'DELETE FROM flow_failures WHERE parent_id = ? OR child_id = ?',
+    pinDependencyCompletionForAdmission: 'UPDATE dependency_completions SET pinned = 1 WHERE job_id = ?',
     insertCron: `
     INSERT OR REPLACE INTO cron_jobs
-    (name, queue, data, schedule, repeat_every, priority, next_run, executions, max_limit, timezone, unique_key, dedup, skip_missed_on_restart, skip_if_no_worker, prevent_overlap, job_options)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    (name, queue, job_name, data, schedule, repeat_every, priority, next_run, executions, max_limit, timezone, unique_key, dedup, skip_missed_on_restart, skip_if_no_worker, prevent_overlap, job_options)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `,
     updateCron: 'UPDATE cron_jobs SET executions = ?, next_run = ? WHERE name = ?',
     // Queue control-state persistence (#100): paused / rate-limit / concurrency.

package/dist/infrastructure/persistence/types/admission.d.ts

@@ -0,0 +1,8 @@
+import type { JobId } from '../../../domain/types/job';
+/** Extra persisted state carried by a two-phase job admission. */
+export interface DurableAdmissionMetadata {
+    /** Terminal generation replaced by the incoming deterministic job ID. */
+    readonly retireGenerationId?: JobId;
+    /** Payload-free completion records referenced by the incoming job. */
+    readonly completionPins?: readonly JobId[];
+}

package/dist/infrastructure/persistence/types/admission.js

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

package/dist/infrastructure/persistence/types/batch.d.ts

@@ -0,0 +1,12 @@
+import type { Job } from '../../../domain/types/job';
+export interface BatchInsertResult {
+    transient: Job[];
+    conflicts: Job[];
+    error?: Error;
+}
+export type WriteBufferErrorCallback = (error: Error, jobCount: number, retryInfo?: {
+    retryCount: number;
+    nextBackoffMs: number;
+    maxRetries: number;
+}) => void;
+export type CriticalErrorCallback = (jobs: Job[], lastError: Error, totalAttempts: number) => void;

package/dist/infrastructure/persistence/types/batch.js

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

package/dist/infrastructure/persistence/types/sqlite.d.ts

@@ -0,0 +1,17 @@
+import type { Job } from '../../../domain/types/job';
+export type SqliteCriticalLossCallback = (jobs: Job[], lastError: Error, attempts: number) => void;
+export interface SqliteCriticalLoss {
+    jobs: Job[];
+    error: string;
+    attempts: number;
+    at: number;
+}
+export interface SqliteConfig {
+    path: string;
+    walMode?: boolean;
+    synchronous?: 'OFF' | 'NORMAL' | 'FULL';
+    cacheSize?: number;
+    writeBufferSize?: number;
+    writeBufferFlushMs?: number;
+    onCriticalLoss?: SqliteCriticalLossCallback;
+}

package/dist/infrastructure/persistence/types/sqlite.js

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

package/dist/infrastructure/persistence/writeBuffer.d.ts

@@ -0,0 +1,38 @@
+import type { Job } from '../../domain/types/job';
+import type { BatchInsertManager } from './batchInsert';
+import type { CriticalErrorCallback, WriteBufferErrorCallback } from './types/batch';
+/** Double-buffered job insert queue with bounded exponential retry. */
+export declare class WriteBuffer {
+    private activeBuffer;
+    private flushBuffer;
+    private flushing;
+    private stopped;
+    private timer;
+    private readonly batchManager;
+    private readonly bufferSize;
+    private readonly onError;
+    private readonly onCriticalError?;
+    private retryCount;
+    private currentBackoffMs;
+    private readonly initialBackoffMs;
+    private readonly maxBackoffMs;
+    private readonly maxRetries;
+    private lastError;
+    private backoffTimer;
+    constructor(batchManager: BatchInsertManager, bufferSize: number, flushIntervalMs: number, onError: WriteBufferErrorCallback, onCriticalError?: CriticalErrorCallback);
+    add(job: Job): void;
+    addBatch(jobs: Job[]): void;
+    flush(): number;
+    private scheduleBackoffRetry;
+    get pendingCount(): number;
+    removePending(jobId: string): void;
+    hasPending(jobId: string): boolean;
+    stop(): void;
+    stopGracefully(timeoutMs?: number): Promise<number>;
+    private reportLostJobs;
+    getRetryState(): {
+        retryCount: number;
+        currentBackoffMs: number;
+        lastError: Error | null;
+    };
+}

package/dist/infrastructure/persistence/writeBuffer.js

@@ -0,0 +1,221 @@
+/** Double-buffered job insert queue with bounded exponential retry. */
+export class WriteBuffer {
+    activeBuffer = [];
+    flushBuffer = [];
+    flushing = false;
+    stopped = false;
+    timer = null;
+    batchManager;
+    bufferSize;
+    onError;
+    onCriticalError;
+    retryCount = 0;
+    currentBackoffMs = 100;
+    initialBackoffMs = 100;
+    maxBackoffMs = 30000;
+    maxRetries = 10;
+    lastError = null;
+    backoffTimer = null;
+    constructor(batchManager, bufferSize, flushIntervalMs, onError, onCriticalError) {
+        this.batchManager = batchManager;
+        this.bufferSize = bufferSize;
+        this.onError = onError;
+        this.onCriticalError = onCriticalError;
+        this.timer = setInterval(() => {
+            if (this.stopped || this.backoffTimer)
+                return;
+            try {
+                this.flush();
+            }
+            catch {
+                // Error already handled by flush.
+            }
+        }, flushIntervalMs);
+    }
+    add(job) {
+        this.activeBuffer.push(job);
+        if (this.activeBuffer.length >= this.bufferSize)
+            this.flush();
+    }
+    addBatch(jobs) {
+        for (const job of jobs)
+            this.activeBuffer.push(job);
+        if (this.activeBuffer.length >= this.bufferSize)
+            this.flush();
+    }
+    flush() {
+        if (this.stopped || this.flushing)
+            return 0;
+        if (this.activeBuffer.length === 0)
+            return 0;
+        this.flushing = true;
+        this.flushBuffer = this.activeBuffer;
+        this.activeBuffer = [];
+        const jobCount = this.flushBuffer.length;
+        try {
+            let result;
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- defensive against a non-conforming test double
+                result = this.batchManager.insertJobsBatch(this.flushBuffer) ?? {
+                    transient: [],
+                    conflicts: [],
+                };
+            }
+            catch (error) {
+                result = {
+                    transient: this.flushBuffer,
+                    conflicts: [],
+                    error: error instanceof Error ? error : new Error(String(error)),
+                };
+            }
+            const { transient, conflicts, error } = result;
+            this.flushBuffer = [];
+            if (conflicts.length > 0) {
+                this.onError(error ?? new Error('Constraint violation'), conflicts.length);
+            }
+            if (transient.length > 0) {
+                const flushError = error ?? new Error('Write buffer flush failed');
+                this.lastError = flushError;
+                this.retryCount++;
+                this.activeBuffer = transient.concat(this.activeBuffer);
+                if (this.retryCount >= this.maxRetries) {
+                    const lostJobs = [...this.activeBuffer];
+                    this.activeBuffer = [];
+                    if (this.onCriticalError) {
+                        this.onCriticalError(lostJobs, flushError, this.retryCount);
+                    }
+                    this.onError(flushError, lostJobs.length, {
+                        retryCount: this.retryCount,
+                        nextBackoffMs: 0,
+                        maxRetries: this.maxRetries,
+                    });
+                    this.retryCount = 0;
+                    this.currentBackoffMs = this.initialBackoffMs;
+                    this.lastError = null;
+                }
+                else {
+                    const nextBackoffMs = Math.min(this.currentBackoffMs * 2, this.maxBackoffMs);
+                    this.onError(flushError, transient.length, {
+                        retryCount: this.retryCount,
+                        nextBackoffMs,
+                        maxRetries: this.maxRetries,
+                    });
+                    this.scheduleBackoffRetry();
+                }
+                return jobCount - transient.length - conflicts.length;
+            }
+            this.retryCount = 0;
+            this.currentBackoffMs = this.initialBackoffMs;
+            this.lastError = null;
+            return jobCount - conflicts.length;
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+    scheduleBackoffRetry() {
+        if (this.backoffTimer)
+            clearTimeout(this.backoffTimer);
+        this.currentBackoffMs = Math.min(this.currentBackoffMs * 2, this.maxBackoffMs);
+        this.backoffTimer = setTimeout(() => {
+            this.backoffTimer = null;
+            try {
+                this.flush();
+            }
+            catch {
+                // Error already handled by flush.
+            }
+        }, this.currentBackoffMs);
+    }
+    get pendingCount() {
+        return this.activeBuffer.length + this.flushBuffer.length;
+    }
+    removePending(jobId) {
+        this.activeBuffer = this.activeBuffer.filter((job) => job.id !== jobId);
+        this.flushBuffer = this.flushBuffer.filter((job) => job.id !== jobId);
+    }
+    hasPending(jobId) {
+        for (const job of this.activeBuffer)
+            if (job.id === jobId)
+                return true;
+        for (const job of this.flushBuffer)
+            if (job.id === jobId)
+                return true;
+        return false;
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        if (this.pendingCount > 0) {
+            try {
+                this.flush();
+            }
+            catch {
+                // Remaining jobs are reported below.
+            }
+        }
+        this.stopped = true;
+        if (this.backoffTimer) {
+            clearTimeout(this.backoffTimer);
+            this.backoffTimer = null;
+        }
+        this.reportLostJobs();
+    }
+    async stopGracefully(timeoutMs = 5000) {
+        if (this.backoffTimer) {
+            clearTimeout(this.backoffTimer);
+            this.backoffTimer = null;
+        }
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        const pending = this.pendingCount;
+        if (pending === 0) {
+            this.stopped = true;
+            return 0;
+        }
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                this.stopped = true;
+                this.reportLostJobs();
+                resolve(-1);
+            }, timeoutMs);
+            try {
+                const flushed = this.flush();
+                clearTimeout(timeout);
+                this.stopped = true;
+                if (this.pendingCount > 0)
+                    this.reportLostJobs();
+                resolve(flushed);
+            }
+            catch {
+                if (this.backoffTimer) {
+                    clearTimeout(this.backoffTimer);
+                    this.backoffTimer = null;
+                }
+                clearTimeout(timeout);
+                this.stopped = true;
+                this.reportLostJobs();
+                resolve(0);
+            }
+        });
+    }
+    reportLostJobs() {
+        const remaining = this.activeBuffer.concat(this.flushBuffer);
+        if (remaining.length > 0 && this.onCriticalError) {
+            this.onCriticalError(remaining, this.lastError ?? new Error('Flush failed during shutdown'), this.retryCount);
+            this.activeBuffer = [];
+            this.flushBuffer = [];
+        }
+    }
+    getRetryState() {
+        return {
+            retryCount: this.retryCount,
+            currentBackoffMs: this.currentBackoffMs,
+            lastError: this.lastError,
+        };
+    }
+}

package/dist/infrastructure/scheduler/cron/execution.d.ts

@@ -0,0 +1,12 @@
+import { CronRuntime } from './runtime';
+/** Due-job execution and scheduler statistics. */
+export declare class CronExecution extends CronRuntime {
+    protected tick(): Promise<void>;
+    private getSkipReason;
+    private fireCronJob;
+    getStats(): {
+        total: number;
+        pending: number;
+        nextRun: number | null;
+    };
+}

package/dist/infrastructure/scheduler/cron/execution.js

@@ -0,0 +1,150 @@
+import { isAtLimit } from '../../../domain/types/cron';
+import { cronLog } from '../../../shared/logger';
+import { expandCronShortcut, getNextCronRun, getNextIntervalRun } from '../cronParser';
+import { CronRuntime } from './runtime';
+/** Due-job execution and scheduler statistics. */
+export class CronExecution extends CronRuntime {
+    async tick() {
+        if (!this.pushJob)
+            return;
+        const now = Date.now();
+        const toReinsert = [];
+        const toRemove = [];
+        while (!this.cronHeap.isEmpty) {
+            const entry = this.cronHeap.peek();
+            if (!entry || entry.cron.nextRun > now)
+                break;
+            this.cronHeap.pop();
+            const current = this.cronJobs.get(entry.cron.name);
+            if (current?.generation !== entry.generation)
+                continue;
+            const cron = entry.cron;
+            if (isAtLimit(cron)) {
+                toRemove.push(cron.name);
+                continue;
+            }
+            try {
+                const newExecutions = cron.executions + 1;
+                const executionTime = Date.now();
+                const scheduledRun = cron.nextRun;
+                let newNextRun;
+                if (cron.schedule) {
+                    newNextRun = getNextCronRun(expandCronShortcut(cron.schedule), executionTime, cron.timezone ?? undefined);
+                }
+                else if (cron.repeatEvery) {
+                    newNextRun = getNextIntervalRun(cron.repeatEvery, scheduledRun);
+                }
+                else {
+                    newNextRun = executionTime;
+                }
+                const skipReason = this.getSkipReason(cron, now);
+                if (skipReason) {
+                    if (this.persistCron) {
+                        try {
+                            this.persistCron(cron.name, cron.executions, newNextRun);
+                        }
+                        catch (error) {
+                            cronLog.error('Failed to persist cron nextRun on skip', {
+                                name: cron.name,
+                                error: String(error),
+                            });
+                        }
+                    }
+                    cron.nextRun = newNextRun;
+                    this.dashboardEmit?.('cron:skipped', {
+                        name: cron.name,
+                        queue: cron.queue,
+                        reason: skipReason,
+                    });
+                    toReinsert.push(entry);
+                    continue;
+                }
+                if (this.persistCron) {
+                    try {
+                        this.persistCron(cron.name, newExecutions, newNextRun);
+                    }
+                    catch (error) {
+                        cronLog.error('Failed to persist cron state, skipping job push', {
+                            name: cron.name,
+                            error: String(error),
+                        });
+                        this.dashboardEmit?.('cron:missed', {
+                            name: cron.name,
+                            queue: cron.queue,
+                            error: String(error),
+                        });
+                        toReinsert.push(entry);
+                        continue;
+                    }
+                }
+                cron.executions = newExecutions;
+                cron.nextRun = newNextRun;
+                await this.fireCronJob(cron, now);
+                toReinsert.push(entry);
+            }
+            catch (error) {
+                cronLog.error('Failed to push cron job (state already persisted)', {
+                    name: cron.name,
+                    error: String(error),
+                });
+                this.dashboardEmit?.('cron:missed', {
+                    name: cron.name,
+                    queue: cron.queue,
+                    error: String(error),
+                });
+                toReinsert.push(entry);
+            }
+        }
+        for (const entry of toReinsert)
+            this.cronHeap.push(entry);
+        for (const name of toRemove)
+            this.cronJobs.delete(name);
+        this.scheduleNext();
+    }
+    getSkipReason(cron, now) {
+        if (cron.skipIfNoWorker && this.hasWorkers && !this.hasWorkers(cron.queue)) {
+            return 'no-worker';
+        }
+        const lastFire = this.lastFiredAt.get(cron.name);
+        const interval = cron.repeatEvery ?? 60000;
+        if (lastFire && now - lastFire < interval * 0.8)
+            return 'overlap';
+        return null;
+    }
+    async fireCronJob(cron, now) {
+        const effectiveUniqueKey = cron.uniqueKey ?? (cron.preventOverlap ? `cron:${cron.name}` : undefined);
+        const options = cron.jobOptions;
+        await this.pushJob(cron.queue, {
+            name: cron.jobName,
+            data: cron.data,
+            priority: cron.priority,
+            uniqueKey: effectiveUniqueKey,
+            dedup: cron.dedup ?? undefined,
+            maxAttempts: options?.maxAttempts,
+            backoff: options?.backoff,
+            timeout: options?.timeout,
+            delay: options?.delay,
+            stallTimeout: options?.stallTimeout,
+            removeOnComplete: options?.removeOnComplete,
+            removeOnFail: options?.removeOnFail,
+        });
+        this.lastFiredAt.set(cron.name, now);
+        this.dashboardEmit?.('cron:fired', { name: cron.name, queue: cron.queue });
+    }
+    getStats() {
+        let nextRun = null;
+        const entry = this.cronHeap.peek();
+        if (entry) {
+            const current = this.cronJobs.get(entry.cron.name);
+            if (current?.generation === entry.generation && !isAtLimit(entry.cron)) {
+                nextRun = entry.cron.nextRun;
+            }
+        }
+        let pending = 0;
+        for (const { cron } of this.cronJobs.values()) {
+            if (!isAtLimit(cron))
+                pending++;
+        }
+        return { total: this.cronJobs.size, pending, nextRun };
+    }
+}

package/dist/infrastructure/scheduler/cron/runtime.d.ts

@@ -0,0 +1,31 @@
+import { type CronJob, type CronJobInput } from '../../../domain/types/cron';
+import { MinHeap } from '../../../shared/minHeap';
+import type { CronHeapEntry, CronRegistryEntry, CronSchedulerConfig, PersistCronCallback, PushJobCallback } from '../types/cronScheduler';
+/** Registry, timers, and schedule mutation shared with cron execution. */
+export declare abstract class CronRuntime {
+    protected readonly cronJobs: Map<string, CronRegistryEntry>;
+    protected readonly cronHeap: MinHeap<CronHeapEntry>;
+    protected generation: number;
+    protected nextTimer: ReturnType<typeof setTimeout> | null;
+    protected safetyInterval: ReturnType<typeof setInterval> | null;
+    protected started: boolean;
+    protected pushJob: PushJobCallback | null;
+    protected persistCron: PersistCronCallback | null;
+    protected hasWorkers: ((queue: string) => boolean) | null;
+    protected dashboardEmit: ((event: string, data: Record<string, unknown>) => void) | null;
+    protected readonly lastFiredAt: Map<string, number>;
+    protected abstract tick(): Promise<void>;
+    constructor(config?: CronSchedulerConfig);
+    setPushCallback(callback: PushJobCallback): void;
+    setPersistCallback(callback: PersistCronCallback): void;
+    setWorkerCheckCallback(callback: (queue: string) => boolean): void;
+    setDashboardEmit(callback: (event: string, data: Record<string, unknown>) => void): void;
+    start(): void;
+    stop(): void;
+    add(input: CronJobInput): CronJob;
+    remove(name: string): boolean;
+    get(name: string): CronJob | undefined;
+    list(): CronJob[];
+    load(crons: CronJob[]): void;
+    protected scheduleNext(): void;
+}