bunqueue 2.8.0 → 2.8.2

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

@@ -5,7 +5,16 @@
  */
 import type { Job, JobId, JobTimelineEntry } from '../../domain/types/job';
 import type { CronJob } from '../../domain/types/cron';
-import type { DlqEntry } from '../../domain/types/dlq';
+import { type DlqEntry } from '../../domain/types/dlq';
+/** Critical-loss callback: invoked when WriteBuffer drops jobs after exhausting retries. */
+export type SqliteCriticalLossCallback = (jobs: Job[], lastError: Error, attempts: number) => void;
+/** Record of a critical job loss event (jobs dropped after max retries). */
+export interface SqliteCriticalLoss {
+    jobs: Job[];
+    error: string;
+    attempts: number;
+    at: number;
+}
 /** SQLite configuration */
 export interface SqliteConfig {
     path: string;
@@ -16,6 +25,8 @@ export interface SqliteConfig {
     writeBufferSize?: number;
     /** Write buffer flush interval in ms (default: 50) */
     writeBufferFlushMs?: number;
+    /** Callback invoked when WriteBuffer drops jobs after exhausting retries. */
+    onCriticalLoss?: SqliteCriticalLossCallback;
 }
 /**
  * SQLite Storage class with write buffering for high throughput
@@ -28,7 +39,26 @@ export declare class SqliteStorage {
     private _diskFull;
     private _lastDiskFullError;
     private _lastDiskFullAt;
+    private readonly _criticalLosses;
+    private readonly _onCriticalLoss?;
+    /** Cap on retained critical-loss records to prevent unbounded growth */
+    private static readonly MAX_RETAINED_LOSSES;
     constructor(config: SqliteConfig);
+    /**
+     * Default handler for WriteBuffer critical loss. Logs every dropped job so
+     * ops can recover from logs, retains the last MAX_RETAINED_LOSSES records
+     * for programmatic inspection, and forwards to a user-provided callback.
+     *
+     * Without this handler the dropped jobs would be silently discarded by
+     * sqliteBatch.ts:209-223 (no callback = no recovery path).
+     */
+    private handleCriticalLoss;
+    /** Truncate job data preview to keep logs readable. */
+    private previewJobData;
+    /** Retrieve retained critical-loss records (most recent last). */
+    getCriticalLosses(): readonly SqliteCriticalLoss[];
+    /** Clear retained critical-loss records (e.g. after operator acknowledgement). */
+    clearCriticalLosses(): void;
     /** Mark disk as full and log */
     private setDiskFull;
     /** Execute a write operation with SQLITE_FULL detection */
@@ -52,6 +82,14 @@ export declare class SqliteStorage {
     insertJob(job: Job, durable?: boolean): void;
     /** Insert job immediately (bypass buffer) */
     insertJobImmediate(job: Job): void;
+    /**
+     * Ensure a job's buffered INSERT has been written to disk before issuing a
+     * state-mutating UPDATE. Without this, markActive/markCompleted's UPDATE
+     * would silently match 0 rows and the state change would be overwritten
+     * when the buffered INSERT eventually fires with the original
+     * 'waiting'/'delayed' state baked at insert time.
+     */
+    private flushIfBuffered;
     markActive(jobId: JobId, startedAt: number, timeline?: JobTimelineEntry[]): void;
     markCompleted(jobId: JobId, completedAt: number, timeline?: JobTimelineEntry[]): void;
     markFailed(job: Job, error: string | null): void;
@@ -74,6 +112,14 @@ export declare class SqliteStorage {
     getResult(jobId: JobId): unknown;
     /** Check if a job result exists (for dependency checking during recovery) */
     hasResult(jobId: JobId): boolean;
+    /** Check if a job has a DLQ entry (used for state/job fallback after restart) */
+    hasDlqEntry(jobId: JobId): boolean;
+    /** Get latest DLQ entry for a job (used for getJob fallback after restart) */
+    getDlqEntry(jobId: JobId): DlqEntry | null;
+    /** Load all DLQ job IDs (used by recovery to skip stale active rows) */
+    loadDlqJobIds(): Set<JobId>;
+    /** Get the persisted `state` column for a job. Returns null if the row is missing. */
+    getJobStateRaw(jobId: JobId): string | null;
     /** Load all completed job IDs (for dependency recovery) */
     loadCompletedJobIds(): Set<JobId>;
     /** Insert batch of jobs (adds to buffer) */
@@ -102,6 +148,13 @@ export declare class SqliteStorage {
      * @param offset Skip first N jobs (default: 0)
      */
     loadActiveJobs(limit?: number, offset?: number): Job[];
+    /**
+     * Load completed jobs with pagination.
+     * Uses job_results join to get only jobs that were successfully completed.
+     * @param limit Max jobs to return (default: 10000)
+     * @param offset Skip first N jobs (default: 0)
+     */
+    loadCompletedJobs(limit?: number, offset?: number): Job[];
     /**
      * Count pending jobs (for pagination)
      */
@@ -118,4 +171,3 @@ export declare class SqliteStorage {
     close(): void;
     getSize(): number;
 }
-//# sourceMappingURL=sqlite.d.ts.map

package/dist/infrastructure/persistence/sqlite.js

@@ -4,6 +4,7 @@
  * Uses MessagePack for ~2-3x faster serialization than JSON
  */
 import { Database } from 'bun:sqlite';
+import { createDlqEntry } from '../../domain/types/dlq';
 import { PRAGMA_SETTINGS, SCHEMA, MIGRATION_TABLE, SCHEMA_VERSION, MIGRATIONS } from './schema';
 import { prepareStatements } from './statements';
 import { pack, unpack, rowToJob, reconstructDlqEntry } from './sqliteSerializer';
@@ -27,11 +28,16 @@ export class SqliteStorage {
     _diskFull = false;
     _lastDiskFullError = null;
     _lastDiskFullAt = null;
+    _criticalLosses = [];
+    _onCriticalLoss;
+    /** Cap on retained critical-loss records to prevent unbounded growth */
+    static MAX_RETAINED_LOSSES = 100;
     constructor(config) {
         this.db = new Database(config.path, { create: true });
         this.db.run(PRAGMA_SETTINGS);
         this.migrate();
         this.statements = prepareStatements(this.db);
+        this._onCriticalLoss = config.onCriticalLoss;
         // Initialize batch manager and write buffer
         this.batchManager = new BatchInsertManager(this.db);
         this.writeBuffer = new WriteBuffer(this.batchManager, config.writeBufferSize ?? 100, config.writeBufferFlushMs ?? 10, (err, jobCount) => {
@@ -43,8 +49,94 @@ export class SqliteStorage {
                 error: err.message,
                 diskFull: this._diskFull,
             });
+        }, (jobs, lastError, attempts) => {
+            this.handleCriticalLoss(jobs, lastError, attempts);
         });
     }
+    /**
+     * Default handler for WriteBuffer critical loss. Logs every dropped job so
+     * ops can recover from logs, retains the last MAX_RETAINED_LOSSES records
+     * for programmatic inspection, and forwards to a user-provided callback.
+     *
+     * Without this handler the dropped jobs would be silently discarded by
+     * sqliteBatch.ts:209-223 (no callback = no recovery path).
+     */
+    handleCriticalLoss(jobs, lastError, attempts) {
+        storageLog.error('CRITICAL: WriteBuffer dropped jobs after exhausting retries', {
+            lostJobCount: jobs.length,
+            attempts,
+            error: lastError.message,
+            diskFull: this._diskFull,
+        });
+        for (const job of jobs) {
+            storageLog.error('Lost job (recover from this log if needed)', {
+                id: String(job.id),
+                queue: job.queue,
+                customId: job.customId,
+                priority: job.priority,
+                createdAt: job.createdAt,
+                attempts: job.attempts,
+                // Data preview (truncated to avoid log spam from huge payloads)
+                dataPreview: this.previewJobData(job.data),
+            });
+        }
+        this._criticalLosses.push({
+            jobs,
+            error: lastError.message,
+            attempts,
+            at: Date.now(),
+        });
+        // Bound retention
+        while (this._criticalLosses.length > SqliteStorage.MAX_RETAINED_LOSSES) {
+            this._criticalLosses.shift();
+        }
+        // Durably persist each lost job to the DLQ table so it survives a restart
+        // and is recoverable via the normal DLQ path (getDlqEntry / loadDlq).
+        // saveDlqEntry() writes directly via the prepared `insertDlq` statement
+        // (NOT through the WriteBuffer that just exhausted its retries), so this
+        // cannot recurse back into the failing flush path.
+        for (const job of jobs) {
+            try {
+                this.saveDlqEntry(createDlqEntry(job, "unknown" /* FailureReason.Unknown */, lastError.message));
+            }
+            catch (err) {
+                storageLog.error('Failed to persist lost job to DLQ', {
+                    id: String(job.id),
+                    queue: job.queue,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        // Forward to user-supplied callback if provided
+        if (this._onCriticalLoss) {
+            try {
+                this._onCriticalLoss(jobs, lastError, attempts);
+            }
+            catch (err) {
+                storageLog.error('onCriticalLoss callback threw', {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
+    /** Truncate job data preview to keep logs readable. */
+    previewJobData(data) {
+        try {
+            const s = JSON.stringify(data);
+            return s.length > 500 ? s.slice(0, 500) + '...[truncated]' : s;
+        }
+        catch {
+            return '[unserializable]';
+        }
+    }
+    /** Retrieve retained critical-loss records (most recent last). */
+    getCriticalLosses() {
+        return this._criticalLosses;
+    }
+    /** Clear retained critical-loss records (e.g. after operator acknowledgement). */
+    clearCriticalLosses() {
+        this._criticalLosses.length = 0;
+    }
     /** Mark disk as full and log */
     setDiskFull(message) {
         if (!this._diskFull) {
@@ -132,7 +224,28 @@ export class SqliteStorage {
                 .run(job.id, job.queue, 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, job.runAt > Date.now() ? 'delayed' : 'waiting', job.lifo ? 1 : 0, job.groupId, job.removeOnComplete ? 1 : 0, job.removeOnFail ? 1 : 0, job.stallTimeout, job.timeline.length > 0 ? pack(job.timeline) : null);
         });
     }
+    /**
+     * Ensure a job's buffered INSERT has been written to disk before issuing a
+     * state-mutating UPDATE. Without this, markActive/markCompleted's UPDATE
+     * would silently match 0 rows and the state change would be overwritten
+     * when the buffered INSERT eventually fires with the original
+     * 'waiting'/'delayed' state baked at insert time.
+     */
+    flushIfBuffered(jobId) {
+        if (this.writeBuffer.hasPending(String(jobId))) {
+            try {
+                this.writeBuffer.flush();
+            }
+            catch {
+                // Flush errors are already routed through onError/onCriticalLoss.
+                // Proceed to UPDATE — if the row really isn't there the UPDATE will
+                // no-op and the caller's in-memory state stays authoritative until
+                // the next successful flush or recovery cycle.
+            }
+        }
+    }
     markActive(jobId, startedAt, timeline) {
+        this.flushIfBuffered(jobId);
         this.safeWrite(() => {
             this.statements
                 .get('updateJobState')
@@ -140,6 +253,7 @@ export class SqliteStorage {
         });
     }
     markCompleted(jobId, completedAt, timeline) {
+        this.flushIfBuffered(jobId);
         this.safeWrite(() => {
             this.statements
                 .get('completeJob')
@@ -147,6 +261,7 @@ export class SqliteStorage {
         });
     }
     markFailed(job, error) {
+        this.flushIfBuffered(job.id);
         this.safeWrite(() => {
             this.statements.get('insertDlq').run(job.id, job.queue, pack({ job, error }), Date.now());
         });
@@ -197,8 +312,21 @@ export class SqliteStorage {
         });
     }
     deleteJob(jobId) {
+        this.writeBuffer.removePending(jobId);
         this.safeWrite(() => {
-            this.statements.get('deleteJob').run(jobId);
+            // Atomic cascade: job row + result must succeed or fail together so
+            // cleanAsync cannot leave orphan job_results rows (issue #84).
+            // DLQ is NOT cascaded here: moveFailedJobToDlq() intentionally calls
+            // saveDlqEntry() then deleteJob() to drop the jobs row while keeping
+            // the DLQ entry. Callers that want DLQ cleanup (e.g. cleanFailed)
+            // explicitly call deleteDlqEntry() before deleteJob().
+            const deleteStmt = this.statements.get('deleteJob');
+            const deleteResultStmt = this.statements.get('deleteJobResult');
+            const tx = this.db.transaction((id) => {
+                deleteStmt.run(id);
+                deleteResultStmt.run(id);
+            });
+            tx(jobId);
         });
     }
     /** Update a job's data blob (e.g. after adding __parentId) */
@@ -235,6 +363,35 @@ export class SqliteStorage {
             .get(String(jobId));
         return row !== null;
     }
+    /** Check if a job has a DLQ entry (used for state/job fallback after restart) */
+    hasDlqEntry(jobId) {
+        const row = this.db
+            .query('SELECT job_id FROM dlq WHERE job_id = ? LIMIT 1')
+            .get(String(jobId));
+        return row !== null;
+    }
+    /** Get latest DLQ entry for a job (used for getJob fallback after restart) */
+    getDlqEntry(jobId) {
+        const row = this.db
+            .query('SELECT entry FROM dlq WHERE job_id = ? ORDER BY entered_at DESC LIMIT 1')
+            .get(String(jobId));
+        if (!row)
+            return null;
+        const entry = unpack(row.entry, null, `getDlqEntry:${String(jobId)}`);
+        return entry?.job ? reconstructDlqEntry(entry) : null;
+    }
+    /** Load all DLQ job IDs (used by recovery to skip stale active rows) */
+    loadDlqJobIds() {
+        const rows = this.db.query('SELECT job_id FROM dlq').all();
+        return new Set(rows.map((r) => r.job_id));
+    }
+    /** Get the persisted `state` column for a job. Returns null if the row is missing. */
+    getJobStateRaw(jobId) {
+        const row = this.db
+            .query('SELECT state FROM jobs WHERE id = ?')
+            .get(String(jobId));
+        return row?.state ?? null;
+    }
     /** Load all completed job IDs (for dependency recovery) */
     loadCompletedJobIds() {
         const rows = this.db.query('SELECT job_id FROM job_results').all();
@@ -294,6 +451,18 @@ export class SqliteStorage {
             .all(limit, offset);
         return rows.map((row) => rowToJob(row));
     }
+    /**
+     * Load completed jobs with pagination.
+     * Uses job_results join to get only jobs that were successfully completed.
+     * @param limit Max jobs to return (default: 10000)
+     * @param offset Skip first N jobs (default: 0)
+     */
+    loadCompletedJobs(limit = 10000, offset = 0) {
+        const rows = this.db
+            .query("SELECT * FROM jobs WHERE state = 'completed' ORDER BY completed_at DESC LIMIT ? OFFSET ?")
+            .all(limit, offset);
+        return rows.map((row) => rowToJob(row));
+    }
     /**
      * Count pending jobs (for pagination)
      */
@@ -317,7 +486,7 @@ export class SqliteStorage {
         this.safeWrite(() => {
             this.statements
                 .get('insertCron')
-                .run(cron.name, cron.queue, pack(cron.data), cron.schedule, cron.repeatEvery, cron.priority, cron.nextRun, cron.executions, cron.maxLimit, cron.timezone, cron.uniqueKey, cron.dedup ? pack(cron.dedup) : null, cron.skipMissedOnRestart ? 1 : 0, cron.skipIfNoWorker ? 1 : 0, cron.preventOverlap ? 1 : 0);
+                .run(cron.name, cron.queue, pack(cron.data), cron.schedule, cron.repeatEvery, cron.priority, cron.nextRun, cron.executions, cron.maxLimit, cron.timezone, cron.uniqueKey, cron.dedup ? pack(cron.dedup) : null, cron.skipMissedOnRestart ? 1 : 0, cron.skipIfNoWorker ? 1 : 0, cron.preventOverlap ? 1 : 0, cron.jobOptions ? pack(cron.jobOptions) : null);
         });
     }
     loadCronJobs() {
@@ -340,6 +509,9 @@ export class SqliteStorage {
             skipMissedOnRestart: row.skip_missed_on_restart === 1,
             skipIfNoWorker: row.skip_if_no_worker === 1,
             preventOverlap: row.prevent_overlap === 1,
+            jobOptions: row.job_options
+                ? unpack(row.job_options, null, `loadCronJobOptions:${row.name}`)
+                : null,
         }));
     }
     deleteCron(name) {
@@ -381,4 +553,3 @@ export class SqliteStorage {
         return file.size;
     }
 }
-//# sourceMappingURL=sqlite.js.map

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

@@ -58,6 +58,20 @@ export declare class WriteBuffer {
     private scheduleBackoffRetry;
     /** Get pending job count (includes both buffers) */
     get pendingCount(): number;
+    /**
+     * Remove any pending buffered inserts for a given jobId.
+     * Prevents a buffered insert from flushing to disk after an immediate deleteJob,
+     * which would leave an orphan row with stale state.
+     */
+    removePending(jobId: string): void;
+    /**
+     * Check whether a job is still sitting in the WriteBuffer (not yet persisted).
+     * Used by state-transition writes (markActive/Completed/Failed) to decide
+     * whether they need to flush the buffer first — otherwise their UPDATE
+     * would silently match 0 rows and the state change would be lost when the
+     * buffered INSERT eventually writes with the original state.
+     */
+    hasPending(jobId: string): boolean;
     /** Stop auto-flush timer and flush pending jobs */
     stop(): void;
     /**
@@ -76,4 +90,3 @@ export declare class WriteBuffer {
         lastError: Error | null;
     };
 }
-//# sourceMappingURL=sqliteBatch.d.ts.map

package/dist/infrastructure/persistence/sqliteBatch.js

@@ -199,6 +199,35 @@ export class WriteBuffer {
     get pendingCount() {
         return this.activeBuffer.length + this.flushBuffer.length;
     }
+    /**
+     * Remove any pending buffered inserts for a given jobId.
+     * Prevents a buffered insert from flushing to disk after an immediate deleteJob,
+     * which would leave an orphan row with stale state.
+     */
+    removePending(jobId) {
+        const i = this.activeBuffer.findIndex((j) => j.id === jobId);
+        if (i !== -1)
+            this.activeBuffer.splice(i, 1);
+        const j = this.flushBuffer.findIndex((j) => j.id === jobId);
+        if (j !== -1)
+            this.flushBuffer.splice(j, 1);
+    }
+    /**
+     * Check whether a job is still sitting in the WriteBuffer (not yet persisted).
+     * Used by state-transition writes (markActive/Completed/Failed) to decide
+     * whether they need to flush the buffer first — otherwise their UPDATE
+     * would silently match 0 rows and the state change would be lost when the
+     * buffered INSERT eventually writes with the original state.
+     */
+    hasPending(jobId) {
+        for (const j of this.activeBuffer)
+            if (j.id === jobId)
+                return true;
+        for (const j of this.flushBuffer)
+            if (j.id === jobId)
+                return true;
+        return false;
+    }
     /** Stop auto-flush timer and flush pending jobs */
     stop() {
         // Clear auto-flush timer
@@ -291,4 +320,3 @@ export class WriteBuffer {
         };
     }
 }
-//# sourceMappingURL=sqliteBatch.js.map

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

@@ -10,8 +10,23 @@ import type { DbJob } from './statements';
 export declare function pack(data: unknown): Uint8Array;
 /** Decode MessagePack buffer to data */
 export declare function unpack<T>(buffer: Uint8Array | null, fallback: T, context: string): T;
+/**
+ * Symbol marker stamped on a Job whose `depends_on` blob failed to decode.
+ *
+ * A corrupt dependency list must NOT collapse into `dependsOn: []` (which the
+ * recovery path treats as "ready, no deps" -> out-of-order execution). Rather
+ * than parking the job behind a magic-string dependency (which could collide
+ * with a real user-supplied jobId, and which leaks into waitingDeps forever),
+ * we signal corruption with a Symbol-keyed flag that cannot collide with any
+ * user data. The recovery path detects this flag and routes the job to the DLQ.
+ *
+ * A Symbol property is non-enumerable to JSON/msgpack and is never persisted,
+ * so it only exists on the in-memory Job for the duration of recovery.
+ */
+export declare const CORRUPT_DEPENDS_ON: unique symbol;
+/** True if a Job was recovered with a corrupt `depends_on` blob. */
+export declare function isCorruptDependsOn(job: Job): boolean;
 /** Convert database row to Job object */
 export declare function rowToJob(row: DbJob): Job;
 /** Reconstruct DlqEntry from MessagePack-decoded data */
 export declare function reconstructDlqEntry(entry: DlqEntry): DlqEntry;
-//# sourceMappingURL=sqliteSerializer.d.ts.map

package/dist/infrastructure/persistence/sqliteSerializer.js

@@ -22,17 +22,58 @@ export function unpack(buffer, fallback, context) {
         return fallback;
     }
 }
+/**
+ * Symbol marker stamped on a Job whose `depends_on` blob failed to decode.
+ *
+ * A corrupt dependency list must NOT collapse into `dependsOn: []` (which the
+ * recovery path treats as "ready, no deps" -> out-of-order execution). Rather
+ * than parking the job behind a magic-string dependency (which could collide
+ * with a real user-supplied jobId, and which leaks into waitingDeps forever),
+ * we signal corruption with a Symbol-keyed flag that cannot collide with any
+ * user data. The recovery path detects this flag and routes the job to the DLQ.
+ *
+ * A Symbol property is non-enumerable to JSON/msgpack and is never persisted,
+ * so it only exists on the in-memory Job for the duration of recovery.
+ */
+export const CORRUPT_DEPENDS_ON = Symbol('bunqueue.corruptDependsOn');
+/** True if a Job was recovered with a corrupt `depends_on` blob. */
+export function isCorruptDependsOn(job) {
+    return job[CORRUPT_DEPENDS_ON] === true;
+}
+/**
+ * Decode a job's `depends_on` blob, distinguishing a genuine decode FAILURE
+ * from a legitimately empty list. On decode failure, returns `corrupt: true`
+ * (with empty ids) instead of silently swallowing it into a healthy empty array.
+ */
+function decodeDependsOn(buffer, context) {
+    if (!buffer)
+        return { ids: [], corrupt: false };
+    try {
+        return { ids: msgpackDecode(buffer), corrupt: false };
+    }
+    catch (err) {
+        storageLog.error('Corrupt depends_on blob (routing job to DLQ)', {
+            context,
+            error: String(err),
+        });
+        return { ids: [], corrupt: true };
+    }
+}
 /** Convert database row to Job object */
 export function rowToJob(row) {
     const jobContext = `rowToJob:${row.id}`;
-    const dependsOn = row.depends_on
-        ? unpack(row.depends_on, [], `${jobContext}:dependsOn`)
-        : [];
+    // A corrupt depends_on blob must NOT be silently swallowed into [] (which the
+    // recovery path treats as "ready, no deps" -> out-of-order execution).
+    // decodeDependsOn() surfaces the corruption via a `corrupt` flag; we then
+    // stamp the returned Job with the CORRUPT_DEPENDS_ON symbol so the recovery
+    // path can route it to the DLQ instead of enqueuing it as ready.
+    const decoded = decodeDependsOn(row.depends_on, `${jobContext}:dependsOn`);
+    const dependsOn = decoded.ids;
     const childrenIds = row.children_ids
         ? unpack(row.children_ids, [], `${jobContext}:childrenIds`)
         : [];
     const tags = row.tags ? unpack(row.tags, [], `${jobContext}:tags`) : [];
-    return {
+    const job = {
         id: jobId(row.id),
         queue: row.queue,
         data: unpack(row.data, {}, `${jobContext}:data`),
@@ -81,6 +122,30 @@ export function rowToJob(row) {
             ? unpack(row.timeline, [], `${jobContext}:timeline`)
             : [],
     };
+    // Stamp a collision-proof corruption marker (non-enumerable Symbol, never
+    // persisted) so the recovery path routes this job to the DLQ rather than
+    // enqueuing it as ready. We keep dependsOn: [] here — the real deps are
+    // unrecoverable — but the marker prevents out-of-order execution.
+    if (decoded.corrupt) {
+        Object.defineProperty(job, CORRUPT_DEPENDS_ON, {
+            value: true,
+            enumerable: false,
+            configurable: true,
+        });
+    }
+    return job;
+}
+/**
+ * Brand a decoded id as a JobId, preserving its runtime type.
+ *
+ * Production ids are UUIDv7 strings (identity). msgpackr faithfully round-trips
+ * the original runtime type (including bigint), so we only stringify when the
+ * decoded value is genuinely non-string rather than unconditionally coercing —
+ * which would otherwise rewrite a recovered job's id and break id equality on
+ * the critical-loss -> DLQ -> restart recovery path.
+ */
+function brandId(id) {
+    return typeof id === 'string' ? jobId(id) : id;
 }
 /** Reconstruct DlqEntry from MessagePack-decoded data */
 export function reconstructDlqEntry(entry) {
@@ -88,11 +153,10 @@ export function reconstructDlqEntry(entry) {
         ...entry,
         job: {
             ...entry.job,
-            id: jobId(String(entry.job.id)),
-            dependsOn: entry.job.dependsOn.map((id) => jobId(String(id))),
-            parentId: entry.job.parentId ? jobId(String(entry.job.parentId)) : null,
-            childrenIds: entry.job.childrenIds.map((id) => jobId(String(id))),
+            id: brandId(entry.job.id),
+            dependsOn: entry.job.dependsOn.map((id) => brandId(id)),
+            parentId: entry.job.parentId !== null ? brandId(entry.job.parentId) : null,
+            childrenIds: entry.job.childrenIds.map((id) => brandId(id)),
         },
     };
 }
-//# sourceMappingURL=sqliteSerializer.js.map

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' | 'deleteJob' | 'getJob' | 'insertResult' | 'getResult' | 'insertDlq' | 'loadDlq' | 'deleteDlqEntry' | 'clearDlqQueue' | 'insertCron' | 'updateCron';
+export type StatementName = 'insertJob' | 'updateJobState' | 'completeJob' | 'deleteJob' | 'deleteJobResult' | 'getJob' | 'insertResult' | 'getResult' | 'insertDlq' | 'loadDlq' | 'deleteDlqEntry' | 'clearDlqQueue' | 'insertCron' | 'updateCron';
 /** SQL statements */
 export declare const SQL_STATEMENTS: Record<StatementName, string>;
 /** Prepare all statements */
@@ -58,5 +58,5 @@ export interface DbCron {
     skip_missed_on_restart: number;
     skip_if_no_worker: number;
     prevent_overlap: number;
+    job_options: Uint8Array | null;
 }
-//# sourceMappingURL=statements.d.ts.map

package/dist/infrastructure/persistence/statements.js

@@ -20,6 +20,7 @@ export const SQL_STATEMENTS = {
     updateJobState: 'UPDATE jobs SET state = ?, started_at = ?, timeline = ? WHERE id = ?',
     completeJob: 'UPDATE jobs SET state = ?, completed_at = ?, progress = 100, timeline = ? WHERE id = ?',
     deleteJob: 'DELETE FROM jobs WHERE id = ?',
+    deleteJobResult: 'DELETE FROM job_results WHERE job_id = ?',
     getJob: 'SELECT * FROM jobs WHERE id = ?',
     insertResult: 'INSERT OR REPLACE INTO job_results (job_id, result, completed_at) VALUES (?, ?, ?)',
     getResult: 'SELECT result FROM job_results WHERE job_id = ?',
@@ -29,8 +30,8 @@ export const SQL_STATEMENTS = {
     clearDlqQueue: 'DELETE FROM dlq WHERE queue = ?',
     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)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    (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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `,
     updateCron: 'UPDATE cron_jobs SET executions = ?, next_run = ? WHERE name = ?',
 };
@@ -42,4 +43,3 @@ export function prepareStatements(db) {
     }
     return statements;
 }
-//# sourceMappingURL=statements.js.map

package/dist/infrastructure/scheduler/cronParser.d.ts

@@ -43,4 +43,3 @@ export declare function expandCronShortcut(expression: string): string;
  * Get human-readable description of cron schedule
  */
 export declare function describeCron(expression: string): string;
-//# sourceMappingURL=cronParser.d.ts.map

package/dist/infrastructure/scheduler/cronParser.js

@@ -89,4 +89,3 @@ export function describeCron(expression) {
     }
     return `At ${minute} ${hour} on day ${dayOfMonth} of ${month}, day of week ${dayOfWeek}`;
 }
-//# sourceMappingURL=cronParser.js.map

package/dist/infrastructure/scheduler/cronScheduler.d.ts

@@ -111,4 +111,3 @@ export declare class CronScheduler {
         nextRun: number | null;
     };
 }
-//# sourceMappingURL=cronScheduler.d.ts.map