bunqueue 2.8.49 → 2.8.51

package/dist/infrastructure/persistence/schema.js

@@ -1,6 +1,7 @@
 /**
  * SQLite schema and migrations
  */
+import { DEPENDENCY_COMPLETION_SCHEMA } from './dependencyCompletionSchema';
 /** SQLite PRAGMA settings for optimal performance */
 export const PRAGMA_SETTINGS = `
 PRAGMA journal_mode = WAL;
@@ -42,6 +43,10 @@ CREATE TABLE IF NOT EXISTS jobs (
     progress_msg TEXT,
     remove_on_complete INTEGER DEFAULT 0,
     remove_on_fail INTEGER DEFAULT 0,
+    fail_parent_on_failure INTEGER NOT NULL DEFAULT 0,
+    remove_dependency_on_failure INTEGER NOT NULL DEFAULT 0,
+    continue_parent_on_failure INTEGER NOT NULL DEFAULT 0,
+    ignore_dependency_on_failure INTEGER NOT NULL DEFAULT 0,
     stall_timeout INTEGER,
     last_heartbeat INTEGER,
     stall_count INTEGER NOT NULL DEFAULT 0,
@@ -58,7 +63,7 @@ CREATE INDEX IF NOT EXISTS idx_jobs_queue_created
 CREATE INDEX IF NOT EXISTS idx_jobs_queue_state_created
     ON jobs(queue, state, created_at, id);
 CREATE INDEX IF NOT EXISTS idx_jobs_run_at
-    ON jobs(run_at) WHERE state IN ('waiting', 'delayed');
+    ON jobs(run_at) WHERE state IN ('waiting', 'prioritized', 'waiting-children', 'delayed');
 CREATE INDEX IF NOT EXISTS idx_jobs_unique
     ON jobs(queue, unique_key) WHERE unique_key IS NOT NULL;
 CREATE INDEX IF NOT EXISTS idx_jobs_custom_id
@@ -66,6 +71,20 @@ CREATE INDEX IF NOT EXISTS idx_jobs_custom_id
 CREATE INDEX IF NOT EXISTS idx_jobs_parent
     ON jobs(parent_id) WHERE parent_id IS NOT NULL;
 
+-- Durable outbox/state for terminal child failure propagation.
+CREATE TABLE IF NOT EXISTS flow_failures (
+    parent_id TEXT NOT NULL,
+    child_id TEXT NOT NULL,
+    child_queue TEXT NOT NULL,
+    mode TEXT NOT NULL,
+    error TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    PRIMARY KEY (parent_id, child_id)
+);
+CREATE INDEX IF NOT EXISTS idx_flow_failures_parent ON flow_failures(parent_id);
+
+${DEPENDENCY_COMPLETION_SCHEMA}
+
 -- Job results storage (BLOB for MessagePack)
 CREATE TABLE IF NOT EXISTS job_results (
     job_id TEXT PRIMARY KEY,
@@ -97,7 +116,7 @@ CREATE INDEX IF NOT EXISTS idx_jobs_group_id
 
 -- Pending jobs: compound index for priority-ordered retrieval
 CREATE INDEX IF NOT EXISTS idx_jobs_pending_priority
-    ON jobs(queue, state, priority DESC, run_at ASC) WHERE state IN ('waiting', 'delayed');
+    ON jobs(queue, state, priority DESC, run_at ASC) WHERE state IN ('waiting', 'prioritized', 'waiting-children', 'delayed');
 
 -- Completed jobs: index for recovery ordering (issue #84)
 CREATE INDEX IF NOT EXISTS idx_jobs_completed_order
@@ -146,7 +165,7 @@ CREATE TABLE IF NOT EXISTS migrations (
 );
 `;
 /** Current schema version */
-export const SCHEMA_VERSION = 22;
+export const SCHEMA_VERSION = 29;
 /** All migrations in order */
 export const MIGRATIONS = {
     1: SCHEMA,
@@ -241,4 +260,39 @@ ALTER TABLE queue_state ADD COLUMN stall_grace_period INTEGER;
     22: `
 ALTER TABLE queue_state ADD COLUMN dlq_config BLOB;
 `,
+    // Migrations 23-26: flow failure policy must survive active-job recovery.
+    23: `
+ALTER TABLE jobs ADD COLUMN fail_parent_on_failure INTEGER NOT NULL DEFAULT 0;
+`,
+    24: `
+ALTER TABLE jobs ADD COLUMN remove_dependency_on_failure INTEGER NOT NULL DEFAULT 0;
+`,
+    25: `
+ALTER TABLE jobs ADD COLUMN continue_parent_on_failure INTEGER NOT NULL DEFAULT 0;
+`,
+    26: `
+ALTER TABLE jobs ADD COLUMN ignore_dependency_on_failure INTEGER NOT NULL DEFAULT 0;
+`,
+    27: `
+CREATE TABLE IF NOT EXISTS flow_failures (
+    parent_id TEXT NOT NULL,
+    child_id TEXT NOT NULL,
+    child_queue TEXT NOT NULL,
+    mode TEXT NOT NULL,
+    error TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    PRIMARY KEY (parent_id, child_id)
+);
+CREATE INDEX IF NOT EXISTS idx_flow_failures_parent ON flow_failures(parent_id);
+
+DROP INDEX IF EXISTS idx_jobs_run_at;
+CREATE INDEX idx_jobs_run_at
+    ON jobs(run_at) WHERE state IN ('waiting', 'prioritized', 'waiting-children', 'delayed');
+
+DROP INDEX IF EXISTS idx_jobs_pending_priority;
+CREATE INDEX idx_jobs_pending_priority
+    ON jobs(queue, state, priority DESC, run_at ASC) WHERE state IN ('waiting', 'prioritized', 'waiting-children', 'delayed');
+`,
+    28: DEPENDENCY_COMPLETION_SCHEMA,
+    29: 'ALTER TABLE dependency_completions ADD COLUMN pinned INTEGER NOT NULL DEFAULT 0;',
 };

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

@@ -4,9 +4,11 @@
  * Uses MessagePack for ~2-3x faster serialization than JSON
  */
 import type { Job, JobId, JobTimelineEntry } from '../../domain/types/job';
+import type { FlowFailureRecord } from '../../domain/types/flow';
 import type { StallConfig } from '../../domain/types/stall';
 import type { CronJob } from '../../domain/types/cron';
 import { type DlqConfig, type DlqEntry } from '../../domain/types/dlq';
+import { type DependencyCompletionRecord } from './dependencyCompletionStore';
 /** 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). */
@@ -37,6 +39,7 @@ export declare class SqliteStorage {
     private readonly statements;
     private readonly batchManager;
     private readonly writeBuffer;
+    private readonly dependencyCompletionStore;
     private _diskFull;
     private _lastDiskFullError;
     private _lastDiskFullAt;
@@ -98,6 +101,11 @@ export declare class SqliteStorage {
     markFailed(job: Job, error: string | null): void;
     /** Save DLQ entry with full metadata */
     saveDlqEntry(entry: DlqEntry): void;
+    /**
+     * Commit a terminal child outcome, its optional DLQ row, and its flow outbox
+     * record together. Recovery therefore never observes only half the transition.
+     */
+    commitFailedJob(jobId: JobId, entry: DlqEntry | null, flowFailure: FlowFailureRecord | null): void;
     /** Delete DLQ entry by job ID */
     deleteDlqEntry(jobId: JobId): void;
     /** Clear all DLQ entries for a queue */
@@ -129,6 +137,25 @@ export declare class SqliteStorage {
     updateRunAt(jobId: JobId, runAt: number): void;
     /** Update a job's children_ids blob and parent_id */
     updateJobChildrenIds(jobId: JobId, childrenIds: JobId[]): void;
+    /** Persist both sides of a legacy parent link in one SQLite transaction. */
+    updateFlowLink(child: Pick<Job, 'id' | 'parentId' | 'data'>, parent: Pick<Job, 'id' | 'childrenIds' | 'dependsOn' | 'data'>, parentState: 'waiting-children' | 'waiting' | 'prioritized' | 'delayed'): void;
+    /**
+     * Persist a legacy SDK parent-id backpatch without changing parent state.
+     *
+     * A fast child can finish before the SDK sends UpdateParent. Completed jobs
+     * remain in `jobs`, while failed jobs live only in the serialized DLQ entry.
+     * The failure outbox is re-keyed in the same transaction so a crash between
+     * this write and in-memory propagation still targets the real parent.
+     */
+    backpatchFlowChild(child: Pick<Job, 'id' | 'parentId' | 'data'>, previousParentId: JobId | null): void;
+    /** Persist both sides of a removed parent/child relationship atomically. */
+    removeFlowLink(child: Pick<Job, 'id' | 'parentId' | 'data'>, parent: Pick<Job, 'id' | 'childrenIds' | 'dependsOn' | 'data' | 'runAt'>, parentState: 'waiting-children' | 'waiting' | 'prioritized'): void;
+    /** Record terminal child propagation before applying its parent-side effect. */
+    saveFlowFailure(record: FlowFailureRecord): void;
+    loadFlowFailures(): FlowFailureRecord[];
+    deleteFlowFailure(parentId: JobId, childId?: JobId): void;
+    /** Persist dependency removal/promotion as one parent-side recovery checkpoint. */
+    updateFlowParentResolution(job: Pick<Job, 'id' | 'dependsOn' | 'runAt' | 'priority' | 'timeline'>, stateOverride?: 'waiting-children' | 'waiting' | 'prioritized' | 'delayed'): void;
     getJob(id: JobId): Job | null;
     storeResult(jobId: JobId, result: unknown): void;
     getResult(jobId: JobId): unknown;
@@ -144,6 +171,14 @@ export declare class SqliteStorage {
     getJobStateRaw(jobId: JobId): string | null;
     /** Load all completed job IDs (for dependency recovery) */
     loadCompletedJobIds(): Set<JobId>;
+    /** Atomically replace a removed completed job with payload-free dependency evidence. */
+    commitRemovedCompletion(job: Pick<Job, 'id' | 'queue'>, retentionLimit: number, pinned: boolean, completedAt?: number): void;
+    loadDependencyCompletions(): DependencyCompletionRecord[];
+    pinDependencyCompletions(jobIds: Iterable<JobId>): void;
+    unpinDependencyCompletions(jobIds: Iterable<JobId>, retentionLimit: number): DependencyCompletionRecord[];
+    reconcileDependencyCompletionPins(referenced: ReadonlySet<JobId>, retentionLimit: number): DependencyCompletionRecord[];
+    deleteDependencyCompletion(jobId: JobId): boolean;
+    deleteDependencyCompletionsForQueue(queue: string): JobId[];
     /**
      * Insert batch of jobs. By default the jobs go through the write buffer.
      * When `durable` is true they bypass the buffer and are written to disk

package/dist/infrastructure/persistence/sqlite.js

@@ -7,9 +7,10 @@ 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, persistedStallCount, reconstructDlqEntry, rowToJob, unpack, } from './sqliteSerializer';
+import { pack, persistedInitialState, persistedStallCount, reconstructDlqEntry, rowToJob, unpack, } from './sqliteSerializer';
 import { BatchInsertManager, WriteBuffer } from './sqliteBatch';
 import { storageLog } from '../../shared/logger';
+import { DependencyCompletionStore, } from './dependencyCompletionStore';
 /** Check if an error is a SQLITE_FULL (disk full) error */
 function isSqliteFullError(err) {
     if (!(err instanceof Error))
@@ -25,6 +26,7 @@ export class SqliteStorage {
     statements;
     batchManager;
     writeBuffer;
+    dependencyCompletionStore;
     _diskFull = false;
     _lastDiskFullError = null;
     _lastDiskFullAt = null;
@@ -48,6 +50,7 @@ export class SqliteStorage {
             });
         }
         this.migrate();
+        this.dependencyCompletionStore = new DependencyCompletionStore(this.db);
         this.statements = prepareStatements(this.db);
         this._onCriticalLoss = config.onCriticalLoss;
         // Initialize batch manager and write buffer
@@ -256,7 +259,7 @@ export class SqliteStorage {
     runInsertJobStmt(job) {
         this.statements
             .get('insertJob')
-            .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, persistedStallCount(job), job.timeline.length > 0 ? pack(job.timeline) : null);
+            .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, persistedInitialState(job), 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);
     }
     /**
      * Ensure a job's buffered INSERT has been written to disk before issuing a
@@ -308,6 +311,35 @@ export class SqliteStorage {
                 .run(entry.job.id, entry.job.queue, pack(entry), entry.enteredAt);
         });
     }
+    /**
+     * Commit a terminal child outcome, its optional DLQ row, and its flow outbox
+     * record together. Recovery therefore never observes only half the transition.
+     */
+    commitFailedJob(jobId, entry, flowFailure) {
+        this.writeBuffer.removePending(jobId);
+        this.safeWrite(() => {
+            const tx = this.db.transaction(() => {
+                if (entry) {
+                    this.statements
+                        .get('insertDlq')
+                        .run(entry.job.id, entry.job.queue, pack(entry), entry.enteredAt);
+                }
+                if (flowFailure) {
+                    this.db
+                        .prepare(`INSERT INTO flow_failures
+               (parent_id, child_id, child_queue, mode, error, created_at)
+               VALUES (?, ?, ?, ?, ?, ?)
+               ON CONFLICT(parent_id, child_id) DO UPDATE SET
+                 child_queue=excluded.child_queue, mode=excluded.mode,
+                 error=excluded.error, created_at=excluded.created_at`)
+                        .run(flowFailure.parentId, flowFailure.childId, flowFailure.childQueue, flowFailure.mode, flowFailure.error, flowFailure.createdAt);
+                }
+                this.statements.get('deleteJob').run(jobId);
+                this.statements.get('deleteJobResult').run(jobId);
+            });
+            tx();
+        });
+    }
     /** Delete DLQ entry by job ID */
     deleteDlqEntry(jobId) {
         this.safeWrite(() => {
@@ -388,6 +420,7 @@ export class SqliteStorage {
             const tx = this.db.transaction((id) => {
                 deleteStmt.run(id);
                 deleteResultStmt.run(id);
+                this.db.prepare('DELETE FROM flow_failures WHERE parent_id = ?').run(id);
             });
             tx(jobId);
         });
@@ -438,12 +471,161 @@ export class SqliteStorage {
     }
     /** Update a job's children_ids blob and parent_id */
     updateJobChildrenIds(jobId, childrenIds) {
+        this.flushIfBuffered(jobId);
         this.safeWrite(() => {
             this.db
                 .prepare('UPDATE jobs SET children_ids = ? WHERE id = ?')
                 .run(childrenIds.length > 0 ? pack(childrenIds) : null, jobId);
         });
     }
+    /** Persist both sides of a legacy parent link in one SQLite transaction. */
+    updateFlowLink(child, parent, parentState) {
+        this.flushIfBuffered(child.id);
+        this.flushIfBuffered(parent.id);
+        this.safeWrite(() => {
+            const tx = this.db.transaction(() => {
+                this.db
+                    .prepare('UPDATE jobs SET parent_id = ?, data = ? WHERE id = ?')
+                    .run(child.parentId, pack(child.data), child.id);
+                this.db
+                    .prepare('UPDATE jobs SET children_ids = ?, depends_on = ?, data = ?, state = ? WHERE id = ?')
+                    .run(parent.childrenIds.length > 0 ? pack(parent.childrenIds) : null, parent.dependsOn.length > 0 ? pack(parent.dependsOn) : null, pack(parent.data), parentState, parent.id);
+            });
+            tx();
+        });
+    }
+    /**
+     * Persist a legacy SDK parent-id backpatch without changing parent state.
+     *
+     * A fast child can finish before the SDK sends UpdateParent. Completed jobs
+     * remain in `jobs`, while failed jobs live only in the serialized DLQ entry.
+     * The failure outbox is re-keyed in the same transaction so a crash between
+     * this write and in-memory propagation still targets the real parent.
+     */
+    backpatchFlowChild(child, previousParentId) {
+        this.flushIfBuffered(child.id);
+        this.safeWrite(() => {
+            const tx = this.db.transaction(() => {
+                let persisted = this.db
+                    .prepare('UPDATE jobs SET parent_id = ?, data = ? WHERE id = ?')
+                    .run(child.parentId, pack(child.data), child.id).changes > 0;
+                const dlqRows = this.db
+                    .query('SELECT id, entry FROM dlq WHERE job_id = ?')
+                    .all(String(child.id));
+                for (const row of dlqRows) {
+                    const entry = unpack(row.entry, null, `backpatchFlowChild:${String(child.id)}`);
+                    if (!entry?.job)
+                        continue;
+                    const updated = {
+                        ...entry,
+                        job: { ...entry.job, parentId: child.parentId, data: child.data },
+                    };
+                    this.db.prepare('UPDATE dlq SET entry = ? WHERE id = ?').run(pack(updated), row.id);
+                    persisted = true;
+                }
+                if (!persisted) {
+                    throw new Error(`Flow child is no longer persisted: ${String(child.id)}`);
+                }
+                if (previousParentId && child.parentId && previousParentId !== child.parentId) {
+                    const failure = this.db
+                        .query(`SELECT child_queue, mode, error, created_at
+               FROM flow_failures
+               WHERE parent_id = ? AND child_id = ?`)
+                        .get(String(previousParentId), String(child.id));
+                    if (failure) {
+                        this.db
+                            .prepare(`INSERT INTO flow_failures
+                 (parent_id, child_id, child_queue, mode, error, created_at)
+                 VALUES (?, ?, ?, ?, ?, ?)
+                 ON CONFLICT(parent_id, child_id) DO UPDATE SET
+                   child_queue=excluded.child_queue, mode=excluded.mode,
+                   error=excluded.error, created_at=excluded.created_at`)
+                            .run(child.parentId, child.id, failure.child_queue, failure.mode, failure.error, failure.created_at);
+                        this.db
+                            .prepare('DELETE FROM flow_failures WHERE parent_id = ? AND child_id = ?')
+                            .run(previousParentId, child.id);
+                    }
+                }
+            });
+            tx();
+        });
+    }
+    /** Persist both sides of a removed parent/child relationship atomically. */
+    removeFlowLink(child, parent, parentState) {
+        this.flushIfBuffered(child.id);
+        this.flushIfBuffered(parent.id);
+        this.safeWrite(() => {
+            const tx = this.db.transaction(() => {
+                this.db
+                    .prepare('UPDATE jobs SET parent_id = ?, data = ? WHERE id = ?')
+                    .run(child.parentId, pack(child.data), child.id);
+                this.db
+                    .prepare(`UPDATE jobs
+             SET children_ids = ?, depends_on = ?, data = ?, run_at = ?, state = ?
+             WHERE id = ?`)
+                    .run(parent.childrenIds.length > 0 ? pack(parent.childrenIds) : null, parent.dependsOn.length > 0 ? pack(parent.dependsOn) : null, pack(parent.data), parent.runAt, parentState, parent.id);
+                this.db
+                    .prepare('DELETE FROM flow_failures WHERE parent_id = ? AND child_id = ?')
+                    .run(parent.id, child.id);
+            });
+            tx();
+        });
+    }
+    /** Record terminal child propagation before applying its parent-side effect. */
+    saveFlowFailure(record) {
+        this.safeWrite(() => {
+            this.db
+                .prepare(`INSERT INTO flow_failures
+           (parent_id, child_id, child_queue, mode, error, created_at)
+           VALUES (?, ?, ?, ?, ?, ?)
+           ON CONFLICT(parent_id, child_id) DO UPDATE SET
+             child_queue=excluded.child_queue, mode=excluded.mode,
+             error=excluded.error, created_at=excluded.created_at`)
+                .run(record.parentId, record.childId, record.childQueue, record.mode, record.error, record.createdAt);
+        });
+    }
+    loadFlowFailures() {
+        const rows = this.db
+            .query('SELECT * FROM flow_failures ORDER BY created_at, parent_id, child_id')
+            .all();
+        return rows.map((row) => ({
+            parentId: row.parent_id,
+            childId: row.child_id,
+            childQueue: row.child_queue,
+            mode: row.mode,
+            error: row.error,
+            createdAt: row.created_at,
+        }));
+    }
+    deleteFlowFailure(parentId, childId) {
+        this.safeWrite(() => {
+            if (childId) {
+                this.db
+                    .prepare('DELETE FROM flow_failures WHERE parent_id = ? AND child_id = ?')
+                    .run(parentId, childId);
+            }
+            else {
+                this.db.prepare('DELETE FROM flow_failures WHERE parent_id = ?').run(parentId);
+            }
+        });
+    }
+    /** Persist dependency removal/promotion as one parent-side recovery checkpoint. */
+    updateFlowParentResolution(job, stateOverride) {
+        this.flushIfBuffered(job.id);
+        const state = stateOverride ??
+            (job.dependsOn.length > 0
+                ? 'waiting-children'
+                : job.runAt > Date.now()
+                    ? 'delayed'
+                    : job.priority > 0
+                        ? 'prioritized'
+                        : 'waiting');
+        this.safeWrite(() => {
+            this.db
+                .prepare('UPDATE jobs SET depends_on = ?, run_at = ?, state = ?, timeline = ? WHERE id = ?')
+                .run(job.dependsOn.length > 0 ? pack(job.dependsOn) : null, job.runAt, state, job.timeline.length > 0 ? pack(job.timeline) : null, job.id);
+        });
+    }
     getJob(id) {
         const row = this.statements.get('getJob').get(id);
         return row ? rowToJob(row) : null;
@@ -495,18 +677,62 @@ export class SqliteStorage {
     }
     /** Load all completed job IDs (for dependency recovery) */
     loadCompletedJobIds() {
-        const rows = this.db.query('SELECT job_id FROM job_results').all();
-        const ids = new Set(rows.map((r) => r.job_id));
-        // A job acked with no/undefined result has state='completed' but NO job_results
-        // row. Include state='completed' ids so dependency recovery still sees it as
-        // done and unblocks dependents (instead of parking them forever).
+        // `jobs.state` is the completion authority. A result row can exist while its
+        // job is still active if a process dies between the two legacy writes, so it
+        // must never release a dependency by itself.
+        const ids = new Set();
         const stateRows = this.db
             .query("SELECT id FROM jobs WHERE state = 'completed'")
             .all();
         for (const r of stateRows)
             ids.add(r.id);
+        for (const record of this.dependencyCompletionStore.load())
+            ids.add(record.jobId);
         return ids;
     }
+    /** Atomically replace a removed completed job with payload-free dependency evidence. */
+    commitRemovedCompletion(job, retentionLimit, pinned, completedAt = Date.now()) {
+        this.writeBuffer.removePending(job.id);
+        this.safeWrite(() => {
+            this.dependencyCompletionStore.commit({ jobId: job.id, queue: job.queue, completedAt, pinned }, retentionLimit);
+        });
+    }
+    loadDependencyCompletions() {
+        return this.dependencyCompletionStore.load();
+    }
+    pinDependencyCompletions(jobIds) {
+        this.safeWrite(() => {
+            this.dependencyCompletionStore.pin(jobIds);
+        });
+    }
+    unpinDependencyCompletions(jobIds, retentionLimit) {
+        let records = [];
+        this.safeWrite(() => {
+            records = this.dependencyCompletionStore.unpin(jobIds, retentionLimit);
+        });
+        return records;
+    }
+    reconcileDependencyCompletionPins(referenced, retentionLimit) {
+        let records = [];
+        this.safeWrite(() => {
+            records = this.dependencyCompletionStore.reconcilePins(referenced, retentionLimit);
+        });
+        return records;
+    }
+    deleteDependencyCompletion(jobId) {
+        let deleted = false;
+        this.safeWrite(() => {
+            deleted = this.dependencyCompletionStore.delete(jobId);
+        });
+        return deleted;
+    }
+    deleteDependencyCompletionsForQueue(queue) {
+        let deleted = [];
+        this.safeWrite(() => {
+            deleted = this.dependencyCompletionStore.deleteForQueue(queue);
+        });
+        return deleted;
+    }
     // ============ Bulk Operations ============
     /**
      * Insert batch of jobs. By default the jobs go through the write buffer.
@@ -573,15 +799,15 @@ export class SqliteStorage {
         const predicateParams = [];
         const requested = new Set(uniqueStates);
         if (requested.has('waiting')) {
-            predicates.push("(state IN ('waiting', 'delayed') AND run_at <= ? AND priority <= 0)");
+            predicates.push("(state IN ('waiting', 'prioritized', 'delayed') AND run_at <= ? AND priority <= 0)");
             predicateParams.push(options.now);
         }
         if (requested.has('prioritized')) {
-            predicates.push("(state IN ('waiting', 'delayed') AND run_at <= ? AND priority > 0)");
+            predicates.push("(state IN ('waiting', 'prioritized', 'delayed') AND run_at <= ? AND priority > 0)");
             predicateParams.push(options.now);
         }
         if (requested.has('delayed')) {
-            predicates.push("(state IN ('waiting', 'delayed') AND run_at > ?)");
+            predicates.push("(state IN ('waiting', 'prioritized', 'delayed') AND run_at > ?)");
             predicateParams.push(options.now);
         }
         const persistedStates = uniqueStates.filter((state) => state !== 'waiting' && state !== 'prioritized' && state !== 'delayed');
@@ -607,7 +833,7 @@ export class SqliteStorage {
      */
     loadPendingJobs(limit = 10000, offset = 0) {
         const rows = this.db
-            .query("SELECT * FROM jobs WHERE state IN ('waiting', 'delayed') ORDER BY priority DESC, run_at ASC, id ASC LIMIT ? OFFSET ?")
+            .query("SELECT * FROM jobs WHERE state IN ('waiting', 'prioritized', 'waiting-children', 'delayed') ORDER BY priority DESC, run_at ASC, id ASC LIMIT ? OFFSET ?")
             .all(limit, offset);
         return rows.map((row) => rowToJob(row));
     }
@@ -639,7 +865,7 @@ export class SqliteStorage {
      */
     countPendingJobs() {
         const result = this.db
-            .query("SELECT COUNT(*) as count FROM jobs WHERE state IN ('waiting', 'delayed')")
+            .query("SELECT COUNT(*) as count FROM jobs WHERE state IN ('waiting', 'prioritized', 'waiting-children', 'delayed')")
             .get();
         return result?.count ?? 0;
     }

package/dist/infrastructure/persistence/sqliteBatch.js

@@ -2,8 +2,8 @@
  * SQLite Batch Operations
  * High-performance batch insert with prepared statement caching
  */
-import { pack, persistedStallCount } from './sqliteSerializer';
-const COLS_PER_ROW = 25;
+import { pack, persistedInitialState, persistedStallCount } from './sqliteSerializer';
+const COLS_PER_ROW = 29;
 // SQLite has a limit of ~999 variables, so batch in chunks
 const MAX_ROWS_PER_INSERT = Math.floor(999 / COLS_PER_ROW);
 /**
@@ -75,7 +75,7 @@ export class BatchInsertManager {
     getBatchInsertStmt(size) {
         let stmt = this.cache.get(size);
         if (!stmt) {
-            const rowPlaceholder = '(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)';
+            const rowPlaceholder = '(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)';
             const placeholders = Array(size).fill(rowPlaceholder).join(', ');
             // ON CONFLICT(id) DO UPDATE (upsert): a colliding id overwrites in place instead
             // of failing the whole flush. Without it, one stale ORPHAN row (left when
@@ -87,6 +87,8 @@ export class BatchInsertManager {
         id, queue, 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
       ) VALUES ${placeholders}
       ON CONFLICT(id) DO UPDATE SET
@@ -97,6 +99,10 @@ export class BatchInsertManager {
         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,
         started_at=excluded.started_at, completed_at=excluded.completed_at,
@@ -116,7 +122,7 @@ export class BatchInsertManager {
         // Flatten all values
         const values = [];
         for (const job of jobs) {
-            values.push(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 > now ? 'delayed' : 'waiting', job.lifo ? 1 : 0, job.groupId, job.removeOnComplete ? 1 : 0, job.removeOnFail ? 1 : 0, job.stallTimeout, persistedStallCount(job), job.timeline.length > 0 ? pack(job.timeline) : null);
+            values.push(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, 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);
         }
         stmt.run(...values);
     }

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

@@ -16,6 +16,8 @@ export declare function unpack<T>(buffer: Uint8Array | null, fallback: T, contex
  * field receives the same zero default as a freshly created Job.
  */
 export declare function persistedStallCount(job: Pick<Job, 'stallCount'>): number;
+/** Derive the durable initial state from the authoritative timeline. */
+export declare function persistedInitialState(job: Job, now?: number): string;
 /**
  * Symbol marker stamped on a Job whose `depends_on` blob failed to decode.
  *
@@ -30,6 +32,9 @@ export declare function persistedStallCount(job: Pick<Job, 'stallCount'>): numbe
  * so it only exists on the in-memory Job for the duration of recovery.
  */
 export declare const CORRUPT_DEPENDS_ON: unique symbol;
+export type PersistedJobState = 'active' | 'completed' | 'delayed' | 'prioritized' | 'waiting' | 'waiting-children';
+/** Read the authoritative SQLite state carried by a recovered job. */
+export declare function persistedJobState(job: Job): PersistedJobState | undefined;
 /** 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 */

package/dist/infrastructure/persistence/sqliteSerializer.js

@@ -30,6 +30,19 @@ export function unpack(buffer, fallback, context) {
 export function persistedStallCount(job) {
     return job.stallCount ?? 0;
 }
+/** Derive the durable initial state from the authoritative timeline. */
+export function persistedInitialState(job, now = Date.now()) {
+    const latest = job.timeline[job.timeline.length - 1]?.state;
+    if (latest === 'waiting-children' ||
+        latest === 'waiting' ||
+        latest === 'prioritized' ||
+        latest === 'delayed') {
+        return latest;
+    }
+    if (job.runAt > now)
+        return 'delayed';
+    return job.priority > 0 ? 'prioritized' : 'waiting';
+}
 /**
  * Symbol marker stamped on a Job whose `depends_on` blob failed to decode.
  *
@@ -44,6 +57,11 @@ export function persistedStallCount(job) {
  * so it only exists on the in-memory Job for the duration of recovery.
  */
 export const CORRUPT_DEPENDS_ON = Symbol('bunqueue.corruptDependsOn');
+const PERSISTED_JOB_STATE = Symbol('bunqueue.persistedJobState');
+/** Read the authoritative SQLite state carried by a recovered job. */
+export function persistedJobState(job) {
+    return job[PERSISTED_JOB_STATE];
+}
 /** True if a Job was recovered with a corrupt `depends_on` blob. */
 export function isCorruptDependsOn(job) {
     return job[CORRUPT_DEPENDS_ON] === true;
@@ -113,14 +131,14 @@ export function rowToJob(row) {
         lastHeartbeat: row.last_heartbeat ?? row.created_at,
         stallTimeout: row.stall_timeout,
         stallCount: row.stall_count ?? 0,
-        // BullMQ v5 additional fields (not persisted in DB, use defaults)
+        // BullMQ v5 additional fields
         stackTraceLimit: 10,
         keepLogs: null,
         sizeLimit: null,
-        failParentOnFailure: false,
-        removeDependencyOnFailure: false,
-        continueParentOnFailure: false,
-        ignoreDependencyOnFailure: false,
+        failParentOnFailure: row.fail_parent_on_failure === 1,
+        removeDependencyOnFailure: row.remove_dependency_on_failure === 1,
+        continueParentOnFailure: row.continue_parent_on_failure === 1,
+        ignoreDependencyOnFailure: row.ignore_dependency_on_failure === 1,
         deduplicationTtl: null,
         deduplicationExtend: false,
         deduplicationReplace: false,
@@ -133,6 +151,11 @@ export function rowToJob(row) {
             ? unpack(row.stacktrace, null, `${jobContext}:stacktrace`)
             : null,
     };
+    Object.defineProperty(job, PERSISTED_JOB_STATE, {
+        value: row.state,
+        enumerable: false,
+        configurable: false,
+    });
     // 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

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

@@ -37,6 +37,10 @@ export interface DbJob {
     progress_msg: string | null;
     remove_on_complete: number;
     remove_on_fail: number;
+    fail_parent_on_failure: number;
+    remove_dependency_on_failure: number;
+    continue_parent_on_failure: number;
+    ignore_dependency_on_failure: number;
     stall_timeout: number | null;
     last_heartbeat: number | null;
     stall_count: number;