bunqueue 2.8.53 → 2.8.56

package/dist/infrastructure/cloud/types.d.ts

@@ -1,445 +1,3 @@
-/**
- * bunqueue Cloud Types
- * Interfaces for the Cloud agent that sends telemetry to the remote dashboard
- */
-/** Cloud configuration from environment variables */
-export interface CloudConfig {
-    /** Remote dashboard URL (e.g. https://bunqueue.io) */
-    readonly url: string;
-    /** API key for authentication */
-    readonly apiKey: string;
-    /** Instance ID from cloud dashboard (required) */
-    readonly instanceId: string;
-    /** HMAC signing secret (optional) */
-    readonly signingSecret: string | null;
-    /** Human-readable instance name */
-    readonly instanceName: string;
-    /** Snapshot interval in ms (default: 5000) */
-    readonly intervalMs: number;
-    /** Include job data in events (default: false) */
-    readonly includeJobData: boolean;
-    /** Fields to redact from job data */
-    readonly redactFields: string[];
-    /** Event types to forward (empty = all) */
-    readonly eventFilter: string[];
-    /** Max snapshots in offline buffer (default: 720) */
-    readonly bufferSize: number;
-    /** Circuit breaker: failures before OPEN (default: 5) */
-    readonly circuitBreakerThreshold: number;
-    /** Circuit breaker: ms in OPEN before HALF_OPEN (default: 60000) */
-    readonly circuitBreakerResetMs: number;
-    /** Enable WebSocket event stream (default: true) */
-    readonly useWebSocket: boolean;
-    /** Enable HTTP snapshot posting (default: true) */
-    readonly useHttp: boolean;
-    /** Data directory (used for local state) */
-    readonly dataPath: string | null;
-    /** Enable remote commands from dashboard (default: false) */
-    readonly remoteCommands: boolean;
-}
-/** Snapshot payload sent every N seconds via HTTP POST */
-export interface CloudSnapshot {
-    instanceId: string;
-    instanceName: string;
-    version: string;
-    hostname: string;
-    pid: number;
-    startedAt: number;
-    timestamp: number;
-    sequenceId: number;
-    shutdown?: boolean;
-    stats: {
-        waiting: number;
-        prioritized: number;
-        delayed: number;
-        active: number;
-        dlq: number;
-        completed: number;
-        'waiting-children': number;
-        totalPushed: string;
-        totalPulled: string;
-        totalCompleted: string;
-        totalFailed: string;
-        stalled: number;
-        paused: number;
-        uptime: number;
-        cronJobs: number;
-        cronPending: number;
-    };
-    throughput: {
-        pushPerSec: number;
-        pullPerSec: number;
-        completePerSec: number;
-        failPerSec: number;
-    };
-    latency: {
-        averages: {
-            pushMs: number;
-            pullMs: number;
-            ackMs: number;
-        };
-        percentiles: {
-            push: {
-                p50: number;
-                p95: number;
-                p99: number;
-            };
-            pull: {
-                p50: number;
-                p95: number;
-                p99: number;
-            };
-            ack: {
-                p50: number;
-                p95: number;
-                p99: number;
-            };
-        };
-    };
-    memory: {
-        heapUsed: number;
-        heapTotal: number;
-        rss: number;
-        external: number;
-    };
-    collections: {
-        jobIndex: number;
-        completedJobs: number;
-        jobResults: number;
-        jobLogs: number;
-        customIdMap: number;
-        jobLocks: number;
-        processingTotal: number;
-        queuedTotal: number;
-        temporalIndexTotal: number;
-        delayedHeapTotal: number;
-    };
-    queues: Array<{
-        name: string;
-        waiting: number;
-        prioritized: number;
-        delayed: number;
-        active: number;
-        completed: number;
-        failed: number;
-        'waiting-children': number;
-        paused: boolean;
-        totalCompleted: number;
-        totalFailed: number;
-    }>;
-    workers: {
-        total: number;
-        active: number;
-        totalProcessed: number;
-        totalFailed: number;
-        activeJobs: number;
-    };
-    crons: Array<{
-        name: string;
-        queue: string;
-        schedule: string | null;
-        repeatEvery: number | null;
-        nextRun: number;
-        executions: number;
-        maxLimit: number | null;
-        lastRun: number | null;
-        priority: number;
-        timezone: string | null;
-        data: unknown;
-        uniqueKey: string | null;
-        dedup: unknown;
-    }>;
-    storage: {
-        diskFull: boolean;
-        error: string | null;
-    };
-    taskErrors: Record<string, {
-        consecutiveFailures: number;
-        lastError?: string;
-        lastFailureAt?: number;
-    }>;
-    /** All jobs across all queues, all states, no cap */
-    recentJobs: Array<{
-        id: string;
-        name: string;
-        queue: string;
-        state: string;
-        data?: unknown;
-        priority: number;
-        createdAt: number;
-        startedAt?: number;
-        completedAt?: number;
-        runAt: number;
-        failedReason?: string;
-        attempts: number;
-        maxAttempts: number;
-        backoff: number;
-        timeout?: number;
-        ttl?: number;
-        duration?: number;
-        waitTime?: number;
-        totalDuration?: number;
-        progress?: number;
-        progressMessage?: string;
-        customId?: string;
-        uniqueKey?: string;
-        tags?: string[];
-        groupId?: string;
-        parentId?: string;
-        childrenIds?: string[];
-        dependsOn?: string[];
-        childrenCompleted?: number;
-        lastHeartbeat?: number;
-        stallCount?: number;
-        stallTimeout?: number;
-        removeOnComplete?: boolean;
-        removeOnFail?: boolean;
-        lifo?: boolean;
-        backoffConfig?: unknown;
-        repeat?: unknown;
-        stackTraceLimit: number;
-        keepLogs?: number;
-        sizeLimit?: number;
-        failParentOnFailure?: boolean;
-        removeDependencyOnFailure?: boolean;
-        continueParentOnFailure?: boolean;
-        ignoreDependencyOnFailure?: boolean;
-        deduplicationTtl?: number;
-        deduplicationExtend?: boolean;
-        deduplicationReplace?: boolean;
-        debounceId?: string;
-        debounceTtl?: number;
-        timeline?: Array<{
-            state: string;
-            timestamp: number;
-            worker?: string;
-            error?: string;
-            attempt?: number;
-        }>;
-    }>;
-    /** All DLQ entries across all queues — full data */
-    dlqEntries: Array<{
-        jobId: string;
-        queue: string;
-        reason: string;
-        error: string | null;
-        enteredAt: number;
-        retryCount: number;
-        lastRetryAt?: number;
-        nextRetryAt?: number;
-        expiresAt?: number;
-        jobAttempts: number;
-        jobMaxAttempts: number;
-        jobData?: unknown;
-        jobCreatedAt: number;
-        jobPriority: number;
-        attemptHistory: Array<{
-            attempt: number;
-            startedAt: number;
-            failedAt: number;
-            reason: string;
-            error: string | null;
-            duration: number;
-        }>;
-    }>;
-    /** Individual worker details */
-    workerDetails: Array<{
-        id: string;
-        name: string;
-        queues: string[];
-        concurrency: number;
-        hostname: string;
-        pid: number;
-        registeredAt: number;
-        lastSeen: number;
-        activeJobs: number;
-        processedJobs: number;
-        failedJobs: number;
-        currentJob: string | null;
-        uptime: number;
-        status: 'active' | 'idle' | 'stalled';
-        errorRate: number;
-        utilization: number;
-    }>;
-    /** Per-queue configuration (includes rate limit + concurrency) */
-    queueConfigs: Record<string, {
-        paused: boolean;
-        rateLimit: number | null;
-        concurrencyLimit: number | null;
-        concurrencyActive: number;
-        stallConfig?: {
-            enabled: boolean;
-            stallInterval: number;
-            maxStalls: number;
-            gracePeriod: number;
-        };
-        dlqConfig?: {
-            autoRetry: boolean;
-            autoRetryInterval: number;
-            maxRetries: number;
-            maxAge: number;
-            maxEntries: number;
-        };
-    }>;
-    /** Connection stats — TCP, WebSocket, SSE clients */
-    connections: {
-        tcp: number;
-        ws: number;
-        sse: number;
-    };
-    /** Registered webhooks with delivery stats */
-    webhooks: Array<{
-        id: string;
-        url: string;
-        events: string[];
-        queue: string | null;
-        enabled: boolean;
-        successCount: number;
-        failureCount: number;
-        lastTriggered: number | null;
-    }>;
-    /** Top recent errors (last ~20, grouped by message) */
-    topErrors: Array<{
-        message: string;
-        count: number;
-        queue: string;
-        lastSeen: number;
-    }>;
-    /** Per-queue throughput (push/complete/fail per second) */
-    queueThroughput: Record<string, {
-        pushPerSec: number;
-        completePerSec: number;
-        failPerSec: number;
-        errorRate: number;
-    }>;
-    /** Job duration histogram buckets (ms thresholds) */
-    durationHistogram: {
-        lt100ms: number;
-        lt1s: number;
-        lt10s: number;
-        lt60s: number;
-        gt60s: number;
-    };
-    /** Per-worker utilization (activeJobs / concurrency) */
-    workerUtilization: Array<{
-        id: string;
-        name: string;
-        utilization: number;
-    }>;
-    /** SQLite storage stats (null if in-memory mode) */
-    sqliteStats: {
-        dbSizeBytes: number;
-        writeBufferPending: number;
-    } | null;
-    /** Runtime environment */
-    runtime: {
-        bunVersion: string;
-        os: string;
-        arch: string;
-        cpus: number;
-    };
-    /** Per-queue priority distribution */
-    queuePriorityDistribution: Record<string, Record<number, number>>;
-    /** Per-queue job wait time stats (time in queue before processing) */
-    queueWaitTime: Record<string, {
-        avgMs: number;
-        maxMs: number;
-        minMs: number;
-    }>;
-    /** Per-queue retry rate (% jobs with attempts > 0) */
-    queueRetryRate: Record<string, {
-        retryRate: number;
-        retrying: number;
-        total: number;
-    }>;
-    /** Queue backlog velocity — delta of waiting jobs between snapshots */
-    queueBacklogVelocity: Record<string, {
-        deltaWaiting: number;
-        deltaPerMin: number;
-        trend: 'growing' | 'shrinking' | 'stable';
-    }>;
-    /** Stall details — currently stalled jobs */
-    stallDetails: Array<{
-        jobId: string;
-        queue: string;
-        workerId: string | null;
-        stalledAt: number;
-        stalledForMs: number;
-    }>;
-    /** Buffered events embedded in snapshot */
-    events?: CloudEvent[];
-    /** MCP tool invocation history (drained each snapshot) */
-    mcpOperations?: Array<{
-        tool: string;
-        queue: string | null;
-        timestamp: number;
-        durationMs: number;
-        success: boolean;
-        error: string | null;
-    }>;
-    /** MCP usage summary stats */
-    mcpSummary?: {
-        totalInvocations: number;
-        successCount: number;
-        failureCount: number;
-        avgDurationMs: number;
-        topTools: Array<{
-            tool: string;
-            count: number;
-        }>;
-    };
-    /** S3 backup status (null if not configured) */
-    s3Backup: {
-        enabled: boolean;
-        bucket: string;
-        endpoint: string;
-        intervalMs: number;
-        retention: number;
-        isRunning: boolean;
-    } | null;
-    /** Job results — return values from completed jobs (from LRU cache, max 5k) */
-    jobResults: Record<string, unknown>;
-    /** Job logs — per-job log entries (from LRU cache, max 10k) */
-    jobLogEntries: Record<string, Array<{
-        timestamp: number;
-        level: 'info' | 'warn' | 'error';
-        message: string;
-    }>>;
-    /** Active job locks — current lock ownership for processing jobs */
-    activeLocks: Array<{
-        jobId: string;
-        owner: string;
-        token: string;
-        createdAt: number;
-        expiresAt: number;
-        lastRenewalAt: number;
-        renewalCount: number;
-        ttl: number;
-    }>;
-    /** Per-queue extended telemetry (dedup, groups, dependencies) */
-    queueExtended: Record<string, {
-        uniqueKeys: number;
-        activeGroups: number;
-        waitingDeps: number;
-        waitingChildren: number;
-    }>;
-    /** Active event subscribers (SSE, WebSocket, internal) */
-    eventSubscribers: number;
-    /** Pending dependency checks awaiting flush */
-    pendingDepChecks: number;
-}
-/** Event payload forwarded via WebSocket */
-export interface CloudEvent {
-    instanceId: string;
-    timestamp: number;
-    jobEvent?: {
-        eventType: string;
-        queue: string;
-        jobId: string;
-        error?: string;
-        progress?: number;
-        data?: unknown;
-        prev?: string;
-        delay?: number;
-    };
-}
+export type { CloudConfig } from './types/config';
+export type { CloudEvent } from './types/event';
+export type { CloudSnapshot } from './types/snapshot';

package/dist/infrastructure/cloud/types.js

@@ -1,5 +1 @@
-/**
- * bunqueue Cloud Types
- * Interfaces for the Cloud agent that sends telemetry to the remote dashboard
- */
 export {};

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

@@ -0,0 +1,13 @@
+import type { Database } from 'bun:sqlite';
+import type { Job } from '../../domain/types/job';
+import type { BatchInsertResult } from './types/batch';
+/** Multi-row SQLite insert manager with per-row failure isolation. */
+export declare class BatchInsertManager {
+    private readonly db;
+    private readonly cache;
+    constructor(db: Database);
+    insertJobsBatch(jobs: Job[]): BatchInsertResult;
+    private insertRowByRow;
+    private getBatchInsertStmt;
+    private insertJobsChunk;
+}

package/dist/infrastructure/persistence/batchInsert.js

@@ -0,0 +1,96 @@
+import { encodeJobOptions } from './jobOptionsBlob';
+import { pack, persistedInitialState, persistedStallCount } from './sqliteSerializer';
+const COLUMNS_PER_ROW = 31;
+const MAX_ROWS_PER_INSERT = Math.floor(999 / COLUMNS_PER_ROW);
+function isConstraintError(error) {
+    const code = error.code ?? '';
+    return code.startsWith('SQLITE_CONSTRAINT') || /constraint failed/i.test(error.message);
+}
+/** Multi-row SQLite insert manager with per-row failure isolation. */
+export class BatchInsertManager {
+    db;
+    cache = new Map();
+    constructor(db) {
+        this.db = db;
+    }
+    insertJobsBatch(jobs) {
+        if (jobs.length === 0)
+            return { transient: [], conflicts: [] };
+        const now = Date.now();
+        try {
+            this.db.transaction(() => {
+                for (let offset = 0; offset < jobs.length; offset += MAX_ROWS_PER_INSERT) {
+                    const chunk = jobs.slice(offset, offset + MAX_ROWS_PER_INSERT);
+                    this.insertJobsChunk(chunk, now);
+                }
+            })();
+            return { transient: [], conflicts: [] };
+        }
+        catch (error) {
+            const batchError = error instanceof Error ? error : new Error(String(error));
+            return this.insertRowByRow(jobs, now, batchError);
+        }
+    }
+    insertRowByRow(jobs, now, batchError) {
+        const transient = [];
+        const conflicts = [];
+        for (const job of jobs) {
+            try {
+                this.insertJobsChunk([job], now);
+            }
+            catch (error) {
+                const rowError = error instanceof Error ? error : new Error(String(error));
+                if (isConstraintError(rowError))
+                    conflicts.push(job);
+                else
+                    transient.push(job);
+            }
+        }
+        return { transient, conflicts, error: batchError };
+    }
+    getBatchInsertStmt(size) {
+        let statement = this.cache.get(size);
+        if (!statement) {
+            const rowPlaceholder = '(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)';
+            const placeholders = Array(size).fill(rowPlaceholder).join(', ');
+            const sql = `INSERT INTO jobs (
+        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, extended_options
+      ) VALUES ${placeholders}
+      ON CONFLICT(id) DO UPDATE SET
+        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,
+        depends_on=excluded.depends_on, parent_id=excluded.parent_id, children_ids=excluded.children_ids,
+        tags=excluded.tags, state=excluded.state, lifo=excluded.lifo, group_id=excluded.group_id,
+        remove_on_complete=excluded.remove_on_complete, remove_on_fail=excluded.remove_on_fail,
+        fail_parent_on_failure=excluded.fail_parent_on_failure,
+        remove_dependency_on_failure=excluded.remove_dependency_on_failure,
+        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, dlq_retry_state=excluded.dlq_retry_state,
+        extended_options=excluded.extended_options,
+        started_at=excluded.started_at, completed_at=excluded.completed_at,
+        progress=excluded.progress, progress_msg=excluded.progress_msg,
+        last_heartbeat=excluded.last_heartbeat, stacktrace=excluded.stacktrace`;
+            statement = this.db.prepare(sql);
+            if (size <= 100)
+                this.cache.set(size, statement);
+        }
+        return statement;
+    }
+    insertJobsChunk(jobs, now) {
+        const statement = this.getBatchInsertStmt(jobs.length);
+        const values = [];
+        for (const job of jobs) {
+            values.push(job.id, job.queue, job.name, pack(job.data), job.priority, job.createdAt, job.runAt, job.attempts, job.maxAttempts, job.backoff, job.ttl, job.timeout, job.uniqueKey, job.customId, job.dependsOn.length > 0 ? pack(job.dependsOn) : null, job.parentId, job.childrenIds.length > 0 ? pack(job.childrenIds) : null, job.tags.length > 0 ? pack(job.tags) : null, persistedInitialState(job, now), job.lifo ? 1 : 0, job.groupId, job.removeOnComplete ? 1 : 0, job.removeOnFail ? 1 : 0, job.failParentOnFailure ? 1 : 0, job.removeDependencyOnFailure ? 1 : 0, job.continueParentOnFailure ? 1 : 0, job.ignoreDependencyOnFailure ? 1 : 0, job.stallTimeout, persistedStallCount(job), job.timeline.length > 0 ? pack(job.timeline) : null, encodeJobOptions(job));
+        }
+        statement.run(...values);
+    }
+}

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

@@ -0,0 +1,18 @@
+import type { BackoffConfig, Job, RepeatConfig } from '../../domain/types/job';
+export interface StoredJobOptions {
+    backoffConfig: BackoffConfig | null;
+    repeat: RepeatConfig | null;
+    stackTraceLimit: number;
+    keepLogs: number | null;
+    sizeLimit: number | null;
+    deduplicationTtl: number | null;
+    deduplicationExtend: boolean;
+    deduplicationReplace: boolean;
+    debounceId: string | null;
+    debounceTtl: number | null;
+    durable: boolean;
+}
+/** Persist generation policies that do not have dedicated legacy columns. */
+export declare function encodeJobOptions(job: Job): Uint8Array;
+/** Decode current blobs while giving pre-v34 rows their historical defaults. */
+export declare function decodeJobOptions(blob: Uint8Array | null, context: string): StoredJobOptions;

package/dist/infrastructure/persistence/jobOptionsBlob.js

@@ -0,0 +1,56 @@
+import { storageLog } from '../../shared/logger';
+import { decodeMessagePack, encodeMessagePack } from '../../shared/msgpack';
+const DEFAULTS = {
+    backoffConfig: null,
+    repeat: null,
+    stackTraceLimit: 10,
+    keepLogs: null,
+    sizeLimit: null,
+    deduplicationTtl: null,
+    deduplicationExtend: false,
+    deduplicationReplace: false,
+    debounceId: null,
+    debounceTtl: null,
+    durable: false,
+};
+/** Persist generation policies that do not have dedicated legacy columns. */
+export function encodeJobOptions(job) {
+    return encodeMessagePack({
+        backoffConfig: job.backoffConfig,
+        repeat: job.repeat,
+        stackTraceLimit: job.stackTraceLimit,
+        keepLogs: job.keepLogs,
+        sizeLimit: job.sizeLimit,
+        deduplicationTtl: job.deduplicationTtl,
+        deduplicationExtend: job.deduplicationExtend,
+        deduplicationReplace: job.deduplicationReplace,
+        debounceId: job.debounceId,
+        debounceTtl: job.debounceTtl,
+        durable: job.durable ?? false,
+    });
+}
+/** Decode current blobs while giving pre-v34 rows their historical defaults. */
+export function decodeJobOptions(blob, context) {
+    if (!blob)
+        return { ...DEFAULTS };
+    try {
+        const decoded = decodeMessagePack(blob);
+        return {
+            backoffConfig: decoded.backoffConfig ?? null,
+            repeat: decoded.repeat ?? null,
+            stackTraceLimit: decoded.stackTraceLimit ?? 10,
+            keepLogs: decoded.keepLogs ?? null,
+            sizeLimit: decoded.sizeLimit ?? null,
+            deduplicationTtl: decoded.deduplicationTtl ?? null,
+            deduplicationExtend: decoded.deduplicationExtend ?? false,
+            deduplicationReplace: decoded.deduplicationReplace ?? false,
+            debounceId: decoded.debounceId ?? null,
+            debounceTtl: decoded.debounceTtl ?? null,
+            durable: decoded.durable ?? false,
+        };
+    }
+    catch (error) {
+        storageLog.error('Job options decode error', { context, error: String(error) });
+        return { ...DEFAULTS };
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { Database } from 'bun:sqlite';
+/** Backfill pre-v31 job payload envelopes after adding jobs.name. */
+export declare function migrateLegacyJobNames(db: Database): void;
+/** Backfill pre-v32 cron payload envelopes after adding cron_jobs.job_name. */
+export declare function migrateLegacyCronJobNames(db: Database): void;

package/dist/infrastructure/persistence/legacyNameMigration.js

@@ -0,0 +1,42 @@
+import { normalizeLegacyJobPayload } from '../../domain/job/payload';
+import { decodeMessagePack, encodeMessagePack } from '../../shared/msgpack';
+const MIGRATION_BATCH_SIZE = 500;
+function splitLegacyBlob(row) {
+    try {
+        const decoded = decodeMessagePack(row.data);
+        const normalized = normalizeLegacyJobPayload({ data: decoded });
+        return {
+            name: normalized.name,
+            data: normalized.legacy ? encodeMessagePack(normalized.data) : row.data,
+        };
+    }
+    catch {
+        // Preserve an undecodable blob byte-for-byte. Its existing read-path error
+        // handling remains authoritative; the migration only supplies a safe name.
+        return { name: 'default', data: row.data };
+    }
+}
+function migrateLegacyNames(db, table, idColumn, nameColumn) {
+    const select = db.query(`SELECT ${idColumn} AS id, data FROM ${table} WHERE ${nameColumn} IS NULL LIMIT ${MIGRATION_BATCH_SIZE}`);
+    const update = db.prepare(`UPDATE ${table} SET ${nameColumn} = ?, data = ? WHERE ${idColumn} = ? AND ${nameColumn} IS NULL`);
+    const applyBatch = db.transaction((rows) => {
+        for (const row of rows) {
+            const migrated = splitLegacyBlob(row);
+            update.run(migrated.name, migrated.data, row.id);
+        }
+    });
+    while (true) {
+        const rows = select.all();
+        if (rows.length === 0)
+            return;
+        applyBatch(rows);
+    }
+}
+/** Backfill pre-v31 job payload envelopes after adding jobs.name. */
+export function migrateLegacyJobNames(db) {
+    migrateLegacyNames(db, 'jobs', 'id', 'name');
+}
+/** Backfill pre-v32 cron payload envelopes after adding cron_jobs.job_name. */
+export function migrateLegacyCronJobNames(db) {
+    migrateLegacyNames(db, 'cron_jobs', 'name', 'job_name');
+}

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

@@ -0,0 +1,3 @@
+export type MigrationSql = string | readonly string[];
+/** All SQLite migrations in order. Arrays preserve atomic statement boundaries. */
+export declare const MIGRATIONS: Record<number, MigrationSql>;