bunqueue-client 0.1.8 → 0.2.0

package/dist/types/src/infrastructure/persistence/completedJobCountSchema.d.ts

@@ -0,0 +1,6 @@
+/** Exact retained-completion counts maintained by the jobs lifecycle itself. */
+export declare const COMPLETED_JOB_COUNTS_TABLE = "\nCREATE TABLE IF NOT EXISTS completed_job_counts (\n    queue TEXT PRIMARY KEY,\n    count INTEGER NOT NULL CHECK (count >= 0)\n);\n";
+export declare const COMPLETED_JOB_COUNT_TRIGGERS = "\nCREATE TRIGGER IF NOT EXISTS trg_jobs_completed_insert\nAFTER INSERT ON jobs\nWHEN NEW.state = 'completed'\nBEGIN\n    INSERT INTO completed_job_counts(queue, count) VALUES (NEW.queue, 1)\n    ON CONFLICT(queue) DO UPDATE SET count = count + 1;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS trg_jobs_completed_leave\nAFTER UPDATE OF state, queue ON jobs\nWHEN OLD.state = 'completed'\n AND (NEW.state <> 'completed' OR NEW.queue <> OLD.queue)\nBEGIN\n    UPDATE completed_job_counts SET count = count - 1 WHERE queue = OLD.queue;\n    DELETE FROM completed_job_counts WHERE queue = OLD.queue AND count = 0;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS trg_jobs_completed_enter\nAFTER UPDATE OF state, queue ON jobs\nWHEN NEW.state = 'completed'\n AND (OLD.state <> 'completed' OR NEW.queue <> OLD.queue)\nBEGIN\n    INSERT INTO completed_job_counts(queue, count) VALUES (NEW.queue, 1)\n    ON CONFLICT(queue) DO UPDATE SET count = count + 1;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS trg_jobs_completed_delete\nAFTER DELETE ON jobs\nWHEN OLD.state = 'completed'\nBEGIN\n    UPDATE completed_job_counts SET count = count - 1 WHERE queue = OLD.queue;\n    DELETE FROM completed_job_counts WHERE queue = OLD.queue AND count = 0;\nEND;\n";
+export declare const COMPLETED_JOB_RETENTION_INDEX = "\nCREATE INDEX IF NOT EXISTS idx_jobs_completed_retention\n    ON jobs(queue, COALESCE(completed_at, created_at), id)\n    WHERE state = 'completed';\n\nCREATE INDEX IF NOT EXISTS idx_jobs_completed_retention_global\n    ON jobs(COALESCE(completed_at, created_at), id)\n    WHERE state = 'completed';\n";
+/** Backfill existing rows before lifecycle triggers become authoritative. */
+export declare const COMPLETED_JOB_MAINTENANCE_MIGRATION = "\nDROP INDEX IF EXISTS idx_jobs_completed_order;\nCREATE INDEX idx_jobs_completed_order\n    ON jobs(completed_at DESC, id DESC) WHERE state = 'completed';\n\nCREATE INDEX IF NOT EXISTS idx_jobs_completed_retention\n    ON jobs(queue, COALESCE(completed_at, created_at), id)\n    WHERE state = 'completed';\n\nCREATE INDEX IF NOT EXISTS idx_jobs_completed_retention_global\n    ON jobs(COALESCE(completed_at, created_at), id)\n    WHERE state = 'completed';\n\n\nCREATE TABLE IF NOT EXISTS completed_job_counts (\n    queue TEXT PRIMARY KEY,\n    count INTEGER NOT NULL CHECK (count >= 0)\n);\n\nDELETE FROM completed_job_counts;\nINSERT INTO completed_job_counts(queue, count)\nSELECT queue, COUNT(*) FROM jobs WHERE state = 'completed' GROUP BY queue;\n\nCREATE TRIGGER IF NOT EXISTS trg_jobs_completed_insert\nAFTER INSERT ON jobs\nWHEN NEW.state = 'completed'\nBEGIN\n    INSERT INTO completed_job_counts(queue, count) VALUES (NEW.queue, 1)\n    ON CONFLICT(queue) DO UPDATE SET count = count + 1;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS trg_jobs_completed_leave\nAFTER UPDATE OF state, queue ON jobs\nWHEN OLD.state = 'completed'\n AND (NEW.state <> 'completed' OR NEW.queue <> OLD.queue)\nBEGIN\n    UPDATE completed_job_counts SET count = count - 1 WHERE queue = OLD.queue;\n    DELETE FROM completed_job_counts WHERE queue = OLD.queue AND count = 0;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS trg_jobs_completed_enter\nAFTER UPDATE OF state, queue ON jobs\nWHEN NEW.state = 'completed'\n AND (OLD.state <> 'completed' OR NEW.queue <> OLD.queue)\nBEGIN\n    INSERT INTO completed_job_counts(queue, count) VALUES (NEW.queue, 1)\n    ON CONFLICT(queue) DO UPDATE SET count = count + 1;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS trg_jobs_completed_delete\nAFTER DELETE ON jobs\nWHEN OLD.state = 'completed'\nBEGIN\n    UPDATE completed_job_counts SET count = count - 1 WHERE queue = OLD.queue;\n    DELETE FROM completed_job_counts WHERE queue = OLD.queue AND count = 0;\nEND;\n\n";

package/dist/types/src/infrastructure/persistence/dependencyCompletionSchema.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Durable, payload-free evidence for completed jobs removed by
+ * `removeOnComplete`. Unreferenced rows follow the bounded FIFO retention
+ * window; rows owned by live dependency edges remain pinned until checkpoint.
+ */
+export declare const DEPENDENCY_COMPLETION_SCHEMA = "\nCREATE TABLE IF NOT EXISTS dependency_completions (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    job_id TEXT NOT NULL UNIQUE,\n    queue TEXT NOT NULL,\n    completed_at INTEGER NOT NULL,\n    pinned INTEGER NOT NULL DEFAULT 0\n);\nCREATE INDEX IF NOT EXISTS idx_dependency_completions_queue\n    ON dependency_completions(queue);\n";

package/dist/types/src/infrastructure/persistence/dependencyCompletionStore.d.ts

@@ -0,0 +1,40 @@
+import type { Database } from "../../../sdk/typescript/src/canonical-transport/bun-sqlite-types.js";
+import type { JobId } from "../../domain/types/job.js";
+export interface DependencyCompletionRecord {
+    jobId: JobId;
+    queue: string;
+    completedAt: number;
+    pinned: boolean;
+}
+/**
+ * SQLite operations for payload-free `removeOnComplete` completion evidence.
+ * The owner supplies write-error handling and buffered-job coordination.
+ */
+export declare class DependencyCompletionStore {
+    private readonly db;
+    private readonly insert;
+    private readonly deleteJob;
+    private readonly deleteResult;
+    private readonly deleteFlowFailures;
+    private readonly pruneThrough;
+    private readonly maxSequence;
+    private readonly loadAll;
+    private readonly deleteOne;
+    private readonly pinOne;
+    private readonly unpinOne;
+    private readonly unpinAll;
+    private readonly loadQueue;
+    private readonly deleteQueue;
+    constructor(db: Database);
+    commit(record: DependencyCompletionRecord, retentionLimit: number): void;
+    load(): DependencyCompletionRecord[];
+    private loadRecords;
+    pin(jobIds: Iterable<JobId>): void;
+    unpin(jobIds: Iterable<JobId>, retentionLimit: number): DependencyCompletionRecord[];
+    reconcilePins(referenced: ReadonlySet<JobId>, retentionLimit: number): DependencyCompletionRecord[];
+    /** Reconcile inside a transaction already owned by the caller. */
+    reconcilePinsInTransaction(referenced: ReadonlySet<JobId>, retentionLimit: number): DependencyCompletionRecord[];
+    private prune;
+    delete(jobId: JobId): boolean;
+    deleteForQueue(queue: string): JobId[];
+}

package/dist/types/src/infrastructure/persistence/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Persistence barrel export
+ */
+export * from "./schema.js";
+export * from "./sqlite.js";

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

@@ -0,0 +1,19 @@
+import type { BackoffConfig, Job, RepeatConfig } from "../../domain/types/job.js";
+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;
+    groupFifoOrder: string | null;
+}
+/** 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/types/src/infrastructure/persistence/legacyNameMigration.d.ts

@@ -0,0 +1,17 @@
+import type { Database } from "../../../sdk/typescript/src/canonical-transport/bun-sqlite-types.js";
+export interface LegacyNameMigrationProgress {
+    version: 31 | 32;
+    phase: 'job-names' | 'cron-job-names';
+    table: 'jobs' | 'cron_jobs';
+    processedRows: number;
+    processedBytes: number;
+    totalRows: number;
+    batchRows: number;
+    batchBytes: number;
+    elapsedMs: number;
+    complete: boolean;
+}
+/** Backfill pre-v31 job payload envelopes after adding jobs.name. */
+export declare function migrateLegacyJobNames(db: Database, onProgress?: (progress: LegacyNameMigrationProgress) => void): LegacyNameMigrationProgress;
+/** Backfill pre-v32 cron payload envelopes after adding cron_jobs.job_name. */
+export declare function migrateLegacyCronJobNames(db: Database, onProgress?: (progress: LegacyNameMigrationProgress) => void): LegacyNameMigrationProgress;

package/dist/types/src/infrastructure/persistence/migrationProgressSchema.d.ts

@@ -0,0 +1,2 @@
+/** Durable cursor for resumable, bounded SQLite data migrations. */
+export declare const MIGRATION_PROGRESS_TABLE = "\nCREATE TABLE IF NOT EXISTS migration_progress (\n    version INTEGER NOT NULL,\n    phase TEXT NOT NULL,\n    last_key TEXT,\n    processed_rows INTEGER NOT NULL DEFAULT 0,\n    processed_bytes INTEGER NOT NULL DEFAULT 0,\n    total_rows INTEGER NOT NULL DEFAULT 0,\n    started_at INTEGER NOT NULL,\n    updated_at INTEGER NOT NULL,\n    PRIMARY KEY (version, phase)\n);\n";

package/dist/types/src/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>;

package/dist/types/src/infrastructure/persistence/schema.d.ts

@@ -0,0 +1,8 @@
+/** SQLite PRAGMA settings for optimal performance */
+export declare const PRAGMA_SETTINGS = "\nPRAGMA journal_mode = WAL;\nPRAGMA synchronous = NORMAL;\nPRAGMA cache_size = -64000;\nPRAGMA temp_store = MEMORY;\nPRAGMA mmap_size = 268435456;\nPRAGMA page_size = 4096;\nPRAGMA busy_timeout = 5000;\n";
+/** Main schema creation. */
+export declare const SCHEMA = "\n-- Jobs table (using UUIDv7 for job IDs)\n-- Uses BLOB for data fields (MessagePack serialization for ~2-3x faster than JSON)\nCREATE TABLE IF NOT EXISTS jobs (\n    id TEXT PRIMARY KEY,\n    queue TEXT NOT NULL,\n    name TEXT,\n    data BLOB NOT NULL,\n    priority INTEGER NOT NULL DEFAULT 0,\n    created_at INTEGER NOT NULL,\n    run_at INTEGER NOT NULL,\n    started_at INTEGER,\n    completed_at INTEGER,\n    attempts INTEGER NOT NULL DEFAULT 0,\n    max_attempts INTEGER NOT NULL DEFAULT 3,\n    backoff INTEGER NOT NULL DEFAULT 1000,\n    ttl INTEGER,\n    timeout INTEGER,\n    unique_key TEXT,\n    custom_id TEXT,\n    depends_on BLOB,\n    parent_id TEXT,\n    children_ids BLOB,\n    tags BLOB,\n    state TEXT NOT NULL DEFAULT 'waiting',\n    lifo INTEGER NOT NULL DEFAULT 0,\n    group_id TEXT,\n    progress INTEGER DEFAULT 0,\n    progress_msg TEXT,\n    remove_on_complete INTEGER DEFAULT 0,\n    remove_on_fail INTEGER DEFAULT 0,\n    fail_parent_on_failure INTEGER NOT NULL DEFAULT 0,\n    remove_dependency_on_failure INTEGER NOT NULL DEFAULT 0,\n    continue_parent_on_failure INTEGER NOT NULL DEFAULT 0,\n    ignore_dependency_on_failure INTEGER NOT NULL DEFAULT 0,\n    stall_timeout INTEGER,\n    last_heartbeat INTEGER,\n    stall_count INTEGER NOT NULL DEFAULT 0,\n    timeline BLOB,\n    stacktrace BLOB,\n    dlq_retry_state BLOB,\n    extended_options BLOB\n);\n\n-- Indexes for common queries\nCREATE INDEX IF NOT EXISTS idx_jobs_queue_state\n    ON jobs(queue, state);\n-- Stable createdAt/id pagination for unfiltered and logical-state queue views\nCREATE INDEX IF NOT EXISTS idx_jobs_queue_created\n    ON jobs(queue, created_at, id);\nCREATE INDEX IF NOT EXISTS idx_jobs_queue_state_created\n    ON jobs(queue, state, created_at, id);\nCREATE INDEX IF NOT EXISTS idx_jobs_run_at\n    ON jobs(run_at) WHERE state IN ('waiting', 'prioritized', 'waiting-children', 'delayed');\nCREATE INDEX IF NOT EXISTS idx_jobs_unique\n    ON jobs(queue, unique_key) WHERE unique_key IS NOT NULL;\nCREATE INDEX IF NOT EXISTS idx_jobs_custom_id\n    ON jobs(custom_id) WHERE custom_id IS NOT NULL;\nCREATE INDEX IF NOT EXISTS idx_jobs_parent\n    ON jobs(parent_id) WHERE parent_id IS NOT NULL;\n\n-- Durable outbox/state for terminal child failure propagation.\nCREATE TABLE IF NOT EXISTS flow_failures (\n    parent_id TEXT NOT NULL,\n    child_id TEXT NOT NULL,\n    child_queue TEXT NOT NULL,\n    mode TEXT NOT NULL,\n    error TEXT NOT NULL,\n    created_at INTEGER NOT NULL,\n    PRIMARY KEY (parent_id, child_id)\n);\nCREATE INDEX IF NOT EXISTS idx_flow_failures_parent ON flow_failures(parent_id);\n\n\nCREATE TABLE IF NOT EXISTS dependency_completions (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    job_id TEXT NOT NULL UNIQUE,\n    queue TEXT NOT NULL,\n    completed_at INTEGER NOT NULL,\n    pinned INTEGER NOT NULL DEFAULT 0\n);\nCREATE INDEX IF NOT EXISTS idx_dependency_completions_queue\n    ON dependency_completions(queue);\n\n\n-- Job results storage (BLOB for MessagePack)\nCREATE TABLE IF NOT EXISTS job_results (\n    job_id TEXT PRIMARY KEY,\n    result BLOB,\n    completed_at INTEGER NOT NULL\n);\n\n-- Dead letter queue (BLOB for MessagePack - stores full DlqEntry)\nCREATE TABLE IF NOT EXISTS dlq (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    job_id TEXT NOT NULL,\n    queue TEXT NOT NULL,\n    entry BLOB NOT NULL,\n    entered_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_dlq_queue ON dlq(queue);\nCREATE INDEX IF NOT EXISTS idx_dlq_job_id ON dlq(job_id);\nCREATE INDEX IF NOT EXISTS idx_dlq_entered_at ON dlq(entered_at);\n\n-- Performance indexes for high-throughput operations\n-- Stall detection: runs every 5s, needs fast lookup of active jobs by started_at\nCREATE INDEX IF NOT EXISTS idx_jobs_state_started\n    ON jobs(state, started_at) WHERE state = 'active';\n\n-- Group operations: fast lookup by group_id\nCREATE INDEX IF NOT EXISTS idx_jobs_group_id\n    ON jobs(group_id) WHERE group_id IS NOT NULL;\n\n-- Pending jobs: compound index for priority-ordered retrieval\nCREATE INDEX IF NOT EXISTS idx_jobs_pending_priority\n    ON jobs(queue, state, priority DESC, run_at ASC) WHERE state IN ('waiting', 'prioritized', 'waiting-children', 'delayed');\n\n-- Completed jobs: index for recovery ordering (issue #84)\nCREATE INDEX IF NOT EXISTS idx_jobs_completed_order\n    ON jobs(completed_at DESC, id DESC) WHERE state = 'completed';\n\nCREATE INDEX IF NOT EXISTS idx_jobs_completed_retention\n    ON jobs(queue, COALESCE(completed_at, created_at), id)\n    WHERE state = 'completed';\n\nCREATE INDEX IF NOT EXISTS idx_jobs_completed_retention_global\n    ON jobs(COALESCE(completed_at, created_at), id)\n    WHERE state = 'completed';\n\n\n\nCREATE TABLE IF NOT EXISTS completed_job_counts (\n    queue TEXT PRIMARY KEY,\n    count INTEGER NOT NULL CHECK (count >= 0)\n);\n\n\nCREATE TRIGGER IF NOT EXISTS trg_jobs_completed_insert\nAFTER INSERT ON jobs\nWHEN NEW.state = 'completed'\nBEGIN\n    INSERT INTO completed_job_counts(queue, count) VALUES (NEW.queue, 1)\n    ON CONFLICT(queue) DO UPDATE SET count = count + 1;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS trg_jobs_completed_leave\nAFTER UPDATE OF state, queue ON jobs\nWHEN OLD.state = 'completed'\n AND (NEW.state <> 'completed' OR NEW.queue <> OLD.queue)\nBEGIN\n    UPDATE completed_job_counts SET count = count - 1 WHERE queue = OLD.queue;\n    DELETE FROM completed_job_counts WHERE queue = OLD.queue AND count = 0;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS trg_jobs_completed_enter\nAFTER UPDATE OF state, queue ON jobs\nWHEN NEW.state = 'completed'\n AND (OLD.state <> 'completed' OR NEW.queue <> OLD.queue)\nBEGIN\n    INSERT INTO completed_job_counts(queue, count) VALUES (NEW.queue, 1)\n    ON CONFLICT(queue) DO UPDATE SET count = count + 1;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS trg_jobs_completed_delete\nAFTER DELETE ON jobs\nWHEN OLD.state = 'completed'\nBEGIN\n    UPDATE completed_job_counts SET count = count - 1 WHERE queue = OLD.queue;\n    DELETE FROM completed_job_counts WHERE queue = OLD.queue AND count = 0;\nEND;\n\n\n-- Cron jobs (BLOB for MessagePack)\nCREATE TABLE IF NOT EXISTS cron_jobs (\n    name TEXT PRIMARY KEY,\n    queue TEXT NOT NULL,\n    job_name TEXT,\n    data BLOB NOT NULL,\n    schedule TEXT,\n    repeat_every INTEGER,\n    priority INTEGER NOT NULL DEFAULT 0,\n    next_run INTEGER NOT NULL,\n    executions INTEGER NOT NULL DEFAULT 0,\n    max_limit INTEGER,\n    timezone TEXT,\n    unique_key TEXT,\n    dedup BLOB,\n    skip_missed_on_restart INTEGER NOT NULL DEFAULT 0,\n    skip_if_no_worker INTEGER NOT NULL DEFAULT 0,\n    prevent_overlap INTEGER NOT NULL DEFAULT 1,\n    job_options BLOB\n);\n\n-- Queue state persistence (optional)\nCREATE TABLE IF NOT EXISTS queue_state (\n    name TEXT PRIMARY KEY,\n    paused INTEGER NOT NULL DEFAULT 0,\n    rate_limit INTEGER,\n    concurrency_limit INTEGER,\n    rate_limit_duration INTEGER,\n    rate_limit_expires_at INTEGER,\n    stall_enabled INTEGER,\n    stall_interval INTEGER,\n    max_stalls INTEGER,\n    stall_grace_period INTEGER,\n    dlq_config BLOB\n);\n\n-- Durable per-group overrides. Runtime rate windows remain in-memory in the\n-- embedded single-broker engine, matching the existing queue-level limiter.\nCREATE TABLE IF NOT EXISTS group_state (\n    queue TEXT NOT NULL,\n    group_id TEXT NOT NULL,\n    rate_limit INTEGER,\n    rate_duration INTEGER,\n    concurrency_limit INTEGER,\n    paused INTEGER NOT NULL DEFAULT 0,\n    PRIMARY KEY (queue, group_id)\n);\n\n-- Per-queue lifecycle event journal. Entries are kept newest-first by id and\n-- bounded by QueueManagerConfig.maxQueueEvents when they are appended.\nCREATE TABLE IF NOT EXISTS queue_events (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    queue TEXT NOT NULL,\n    event_type TEXT NOT NULL,\n    job_id TEXT NOT NULL,\n    occurred_at INTEGER NOT NULL,\n    payload BLOB\n);\nCREATE INDEX IF NOT EXISTS idx_queue_events_queue_id\n    ON queue_events(queue, id DESC);\n\n-- Cumulative terminal counters are separate from bounded minute buckets so\n-- pruning old data points never resets meta.count.\nCREATE TABLE IF NOT EXISTS queue_metrics_meta (\n    queue TEXT NOT NULL,\n    type TEXT NOT NULL CHECK (type IN ('completed', 'failed')),\n    total_count INTEGER NOT NULL DEFAULT 0,\n    prev_ts INTEGER NOT NULL DEFAULT 0,\n    prev_count INTEGER NOT NULL DEFAULT 0,\n    PRIMARY KEY (queue, type)\n);\nCREATE TABLE IF NOT EXISTS queue_metric_buckets (\n    queue TEXT NOT NULL,\n    type TEXT NOT NULL CHECK (type IN ('completed', 'failed')),\n    minute INTEGER NOT NULL,\n    count INTEGER NOT NULL DEFAULT 0,\n    PRIMARY KEY (queue, type, minute)\n);\nCREATE INDEX IF NOT EXISTS idx_queue_metric_buckets_window\n    ON queue_metric_buckets(queue, type, minute DESC);\n";
+/** Migration version table */
+export declare const MIGRATION_TABLE = "\nCREATE TABLE IF NOT EXISTS migrations (\n    version INTEGER PRIMARY KEY,\n    applied_at INTEGER NOT NULL\n);\n";
+/** Current schema version */
+export declare const SCHEMA_VERSION = 37;

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

@@ -0,0 +1,9 @@
+import type { DurableAdmissionMetadata } from "../types/admission.js";
+import { SqliteState } from "./state.js";
+/** SQL primitives shared by every durable job-admission transaction. */
+export declare abstract class SqliteAdmission extends SqliteState {
+    protected hasAdmissionMetadata(metadata?: DurableAdmissionMetadata): boolean;
+    protected runAdmissionMetadata(metadata?: DurableAdmissionMetadata): void;
+    protected finalizeAdmissionMetadata(metadata?: DurableAdmissionMetadata): void;
+    protected commitBufferedAdmissionMetadata(metadata?: DurableAdmissionMetadata): void;
+}

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

@@ -0,0 +1,17 @@
+import type { Job, JobId } from "../../../domain/types/job.js";
+import { SqliteRecords } from "./records.js";
+export interface CompletedJobRemoval {
+    jobId: JobId;
+    queue: string;
+}
+/** SQLite-authoritative cleanup and exact retained-completion counts. */
+export declare abstract class SqliteCompleted extends SqliteRecords {
+    getCompletedJob(jobId: JobId): Job | null;
+    cleanCompletedJobs(queue: string | null, completedBefore: number, limit: number, isProtected?: (jobId: JobId) => boolean): CompletedJobRemoval[];
+    countCompletedJobs(): number;
+    countCompletedJobsByQueue(queueNames: Iterable<string>): Map<string, number>;
+    loadCompletedQueueNames(): string[];
+    loadCompletedJobsForRetry(queue: string, completedBefore: number, cursorTimestamp: number, cursorId: string, limit: number): Job[];
+    private selectCompletedCandidates;
+    private completedCandidatePage;
+}

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

@@ -0,0 +1,48 @@
+import type { CronJob } from "../../../domain/types/cron.js";
+import type { DlqConfig } from "../../../domain/types/dlq.js";
+import type { StallConfig } from "../../../domain/types/stall.js";
+import { SqliteQueries } from "./queries.js";
+export interface PersistedQueueState {
+    name: string;
+    paused: boolean;
+    rateLimit: number | null;
+    concurrencyLimit: number | null;
+    rateLimitDuration: number | null;
+    rateLimitExpiresAt: number | null;
+    stallConfig: StallConfig | null;
+    dlqConfig: DlqConfig | null;
+}
+export interface PersistedGroupState {
+    queue: string;
+    groupId: string;
+    rateLimit: number | null;
+    rateDuration: number | null;
+    concurrencyLimit: number | null;
+    paused: boolean;
+}
+/** Cron schedules and durable queue control-state. */
+export declare abstract class SqliteControl extends SqliteQueries {
+    saveCron(cron: CronJob): void;
+    loadCronJobs(): CronJob[];
+    deleteCron(name: string): void;
+    updateCron(name: string, executions: number, nextRun: number): void;
+    saveQueueState(name: string, state: {
+        paused: boolean;
+        rateLimit: number | null;
+        concurrencyLimit: number | null;
+        rateLimitDuration?: number | null;
+        rateLimitExpiresAt?: number | null;
+        stallConfig?: StallConfig | null;
+        dlqConfig?: DlqConfig | null;
+    }): void;
+    loadQueueState(): PersistedQueueState[];
+    saveGroupRateLimit(queue: string, groupId: string, max: number, duration: number): void;
+    removeGroupRateLimit(queue: string, groupId: string): void;
+    saveGroupConcurrency(queue: string, groupId: string, concurrency: number): void;
+    removeGroupConcurrency(queue: string, groupId: string): void;
+    saveGroupPaused(queue: string, groupId: string, paused: boolean): void;
+    loadGroupState(): PersistedGroupState[];
+    deleteGroupState(queue: string): void;
+    deleteQueueState(name: string): void;
+    private deleteEmptyGroupState;
+}

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

@@ -0,0 +1,26 @@
+import type { FlowFailureRecord } from "../../../domain/types/flow.js";
+import type { Job, JobId } from "../../../domain/types/job.js";
+import type { DurableAdmissionMetadata } from "../types/admission.js";
+import { SqliteMutations } from "./mutations.js";
+export type FlowLinkWriteMode = {
+    readonly type: 'update';
+} | {
+    readonly type: 'insert';
+} | {
+    readonly type: 'replace';
+    readonly previousJobId: JobId;
+} | {
+    readonly type: 'transfer-active';
+    readonly previousJobId: JobId;
+};
+/** Atomic persistence for parent/child relationships and failure outbox rows. */
+export declare abstract class SqliteFlows extends SqliteMutations {
+    updateFlowLink(child: Job, parent: Job, parentState: 'waiting-children' | 'waiting' | 'prioritized' | 'delayed'): void;
+    commitFlowLink(child: Job, parent: Job, parentState: 'waiting-children' | 'waiting' | 'prioritized' | 'delayed', mode: FlowLinkWriteMode, admission?: DurableAdmissionMetadata): void;
+    backpatchFlowChild(child: Pick<Job, 'id' | 'parentId' | 'data'>, previousParentId: JobId | null): void;
+    removeFlowLink(child: Pick<Job, 'id' | 'parentId' | 'data'>, parent: Pick<Job, 'id' | 'childrenIds' | 'dependsOn' | 'data' | 'runAt'>, parentState: 'waiting-children' | 'waiting' | 'prioritized'): void;
+    saveFlowFailure(record: FlowFailureRecord): void;
+    loadFlowFailures(): FlowFailureRecord[];
+    deleteFlowFailure(parentId: JobId, childId?: JobId): void;
+    updateFlowParentResolution(job: Pick<Job, 'id' | 'dependsOn' | 'runAt' | 'priority' | 'timeline'>, stateOverride?: 'waiting-children' | 'waiting' | 'prioritized' | 'delayed'): void;
+}

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

@@ -0,0 +1,17 @@
+import { type Job, type JobId, type JobTimelineEntry } from "../../../domain/types/job.js";
+import type { DurableAdmissionMetadata } from "../types/admission.js";
+import type { ActiveJobWrite, CompletedJobWrite } from "../types/sqlite.js";
+import { SqliteAdmission } from "./admission.js";
+/** Buffered admission and lifecycle state persistence. */
+export declare abstract class SqliteJobLifecycle extends SqliteAdmission {
+    insertJob(job: Job, durable?: boolean, admission?: DurableAdmissionMetadata): void;
+    insertJobImmediate(job: Job, admission?: DurableAdmissionMetadata): void;
+    protected runInsertJobStmt(job: Job): void;
+    protected flushIfBuffered(jobId: JobId): void;
+    private flushPendingBatch;
+    markActive(jobId: JobId, startedAt: number, timeline?: JobTimelineEntry[]): void;
+    markActiveBatch(updates: readonly ActiveJobWrite[]): void;
+    markWaitingChildren(jobId: JobId, timeline?: JobTimelineEntry[]): void;
+    markCompleted(jobId: JobId, completedAt: number, timeline?: JobTimelineEntry[]): void;
+    markCompletedBatch(updates: readonly CompletedJobWrite[]): void;
+}

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

@@ -0,0 +1,15 @@
+import type { DlqEntry } from "../../../domain/types/dlq.js";
+import type { FlowFailureRecord } from "../../../domain/types/flow.js";
+import type { Job, JobId } from "../../../domain/types/job.js";
+import { SqliteJobLifecycle } from "./jobLifecycle.js";
+/** DLQ persistence layered on buffered job lifecycle writes. */
+export declare abstract class SqliteJobs extends SqliteJobLifecycle {
+    markFailed(job: Job, error: string | null): void;
+    saveDlqEntry(entry: DlqEntry): void;
+    commitFailedJob(jobId: JobId, entry: DlqEntry | null, flowFailure: FlowFailureRecord | null): void;
+    deleteDlqEntry(jobId: JobId): void;
+    requeueDlqJob(job: Job): void;
+    clearDlqQueue(queue: string): void;
+    purgeDlqEntries(queue: string, dlqJobIds: readonly JobId[], terminalJobIds: readonly JobId[], clearQueue: boolean): void;
+    loadDlq(): Map<string, DlqEntry[]>;
+}

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

@@ -0,0 +1,6 @@
+import { SqliteTelemetry } from "./telemetry.js";
+/** Storage shutdown and file-size inspection. */
+export declare class SqliteLifecycle extends SqliteTelemetry {
+    close(): void;
+    getSize(): number;
+}

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

@@ -0,0 +1,27 @@
+import type { Job, JobId } from "../../../domain/types/job.js";
+import type { DependencyCompletionRecord } from "../dependencyCompletionStore.js";
+import type { DurableAdmissionMetadata } from "../types/admission.js";
+import { SqliteJobs } from "./jobs.js";
+export interface QueueDeletionResult {
+    bufferedJobIds: JobId[];
+    dependencyCompletions: DependencyCompletionRecord[];
+}
+/** Non-terminal job field and scheduling mutations. */
+export declare abstract class SqliteMutations extends SqliteJobs {
+    updateForRetry(job: Job): void;
+    /** Atomically move a completed job back to waiting and retire its old result. */
+    requeueCompletedJob(job: Job): void;
+    deleteJob(jobId: JobId): void;
+    /** Commit every durable queue-owned deletion before removing buffered jobs. */
+    deleteJobsForQueue(queue: string, referencedDependencyIds: ReadonlySet<JobId>, dependencyRetentionLimit: number): QueueDeletionResult;
+    replaceJob(oldJobId: JobId, newJob: Job, durable?: boolean, admission?: DurableAdmissionMetadata): void;
+    transferActiveDedupJob(oldJobId: JobId, newJob: Job, durable?: boolean, admission?: DurableAdmissionMetadata): void;
+    protected runDeleteJobRows(jobId: JobId): void;
+    protected runClearActiveDedupKey(jobId: JobId): void;
+    updateJobData(jobId: JobId, data: unknown): void;
+    clearJobUniqueKey(jobId: JobId): void;
+    updateJobPriority(jobId: JobId, priority: number, lifo: boolean): void;
+    updateJobProgress(jobId: JobId, progress: number, message: string | null, lastHeartbeat: number): void;
+    updateRunAt(jobId: JobId, runAt: number): void;
+    updateJobChildrenIds(jobId: JobId, childrenIds: JobId[]): void;
+}

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

@@ -0,0 +1,23 @@
+import type { Job } from "../../../domain/types/job.js";
+import { SqliteCompleted } from "./completed.js";
+/** Persisted and logical-state job queries used by recovery and public pagination. */
+export declare abstract class SqliteQueries extends SqliteCompleted {
+    queryJobs(queue: string, options: {
+        state?: string;
+        states?: string[];
+        limit: number;
+        offset: number;
+        asc: boolean;
+    }): Job[];
+    queryJobsByLogicalStates(queue: string, states: string[], options: {
+        limit: number;
+        offset: number;
+        asc: boolean;
+        now: number;
+    }): Job[];
+    loadPendingJobs(limit?: number, offset?: number): Job[];
+    loadActiveJobs(limit?: number, offset?: number): Job[];
+    loadCompletedJobs(limit?: number, offset?: number): Job[];
+    countPendingJobs(): number;
+    countActiveJobs(): number;
+}

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

@@ -0,0 +1,3 @@
+export declare const DELETE_QUEUE_JOB_RESULTS_FROM_JOBS_SQL = "DELETE FROM job_results\n  WHERE job_id IN (\n    SELECT target.id FROM jobs AS target\n    WHERE target.queue = ?\n      AND NOT EXISTS (\n        SELECT 1 FROM dlq AS other_dlq\n        WHERE other_dlq.job_id = target.id AND other_dlq.queue <> ?\n      )\n  )";
+export declare const DELETE_QUEUE_JOB_RESULTS_FROM_DLQ_SQL = "DELETE FROM job_results\n  WHERE job_id IN (\n    SELECT dlq.job_id FROM dlq\n    WHERE dlq.queue = ?\n      AND NOT EXISTS (\n        SELECT 1 FROM jobs\n        WHERE jobs.id = dlq.job_id AND jobs.queue <> ?\n      )\n      AND NOT EXISTS (\n        SELECT 1 FROM dlq AS other_dlq\n        WHERE other_dlq.job_id = dlq.job_id AND other_dlq.queue <> ?\n      )\n  )";
+export declare const DELETE_QUEUE_FLOW_FAILURES_SQL = "DELETE FROM flow_failures\n  WHERE child_queue = ?\n     OR parent_id IN (\n       SELECT target.id FROM jobs AS target\n       WHERE target.queue = ?\n         AND NOT EXISTS (\n           SELECT 1 FROM dlq AS other_dlq\n           WHERE other_dlq.job_id = target.id AND other_dlq.queue <> ?\n         )\n     )\n     OR child_id IN (\n       SELECT target.id FROM jobs AS target\n       WHERE target.queue = ?\n         AND NOT EXISTS (\n           SELECT 1 FROM dlq AS other_dlq\n           WHERE other_dlq.job_id = target.id AND other_dlq.queue <> ?\n         )\n     )\n     OR EXISTS (\n       SELECT 1 FROM dlq\n       WHERE dlq.queue = ?\n         AND (dlq.job_id = flow_failures.parent_id\n              OR dlq.job_id = flow_failures.child_id)\n         AND NOT EXISTS (\n           SELECT 1 FROM jobs\n           WHERE jobs.id = dlq.job_id AND jobs.queue <> ?\n         )\n         AND NOT EXISTS (\n           SELECT 1 FROM dlq AS other_dlq\n           WHERE other_dlq.job_id = dlq.job_id AND other_dlq.queue <> ?\n         )\n     )";

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

@@ -0,0 +1,24 @@
+import type { DlqEntry } from "../../../domain/types/dlq.js";
+import { type Job, type JobId } from "../../../domain/types/job.js";
+import type { DependencyCompletionRecord } from "../dependencyCompletionStore.js";
+import { SqliteFlows } from "./flows.js";
+/** Direct job/result lookup and payload-free dependency completion records. */
+export declare abstract class SqliteRecords extends SqliteFlows {
+    getJob(id: JobId): Job | null;
+    storeResult(jobId: JobId, result: unknown): void;
+    getResult(jobId: JobId): unknown;
+    hasResult(jobId: JobId): boolean;
+    hasDlqEntry(jobId: JobId): boolean;
+    getDlqEntry(jobId: JobId): DlqEntry | null;
+    loadDlqJobIds(): Set<JobId>;
+    getJobStateRaw(jobId: JobId): string | null;
+    loadCompletedJobIds(requested: Iterable<JobId>): Set<JobId>;
+    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[];
+    insertJobsBatch(jobs: Job[], durable?: boolean): void;
+}

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

@@ -0,0 +1,42 @@
+import { Database } from "../../../../sdk/typescript/src/canonical-transport/bun-sqlite-types.js";
+import { type DlqEntry } from "../../../domain/types/dlq.js";
+import type { Job, JobId } from "../../../domain/types/job.js";
+import { BatchInsertManager, WriteBuffer } from "../sqliteBatch.js";
+import { DependencyCompletionStore } from "../dependencyCompletionStore.js";
+import { type StatementName } from "../statements.js";
+import type { SqliteConfig, SqliteCriticalLoss, SqliteCriticalLossCallback } from "../types/sqlite.js";
+import { SqliteTelemetryStore } from "./telemetryStore.js";
+/** Owns the database, prepared statements, buffering, and storage health state. */
+export declare abstract class SqliteState {
+    protected readonly db: Database;
+    protected readonly statements: Map<StatementName, ReturnType<Database['prepare']>>;
+    protected readonly batchManager: BatchInsertManager;
+    protected readonly writeBuffer: WriteBuffer;
+    protected readonly dependencyCompletionStore: DependencyCompletionStore;
+    protected readonly telemetryStore: SqliteTelemetryStore;
+    protected _diskFull: boolean;
+    protected _lastDiskFullError: string | null;
+    protected _lastDiskFullAt: number | null;
+    protected readonly _criticalLosses: SqliteCriticalLoss[];
+    protected readonly _onCriticalLoss?: SqliteCriticalLossCallback;
+    private static readonly MAX_RETAINED_LOSSES;
+    protected abstract saveDlqEntry(entry: DlqEntry): void;
+    constructor(config: SqliteConfig);
+    private handleCriticalLoss;
+    private previewJobData;
+    getCriticalLosses(): readonly SqliteCriticalLoss[];
+    clearCriticalLosses(): void;
+    private setDiskFull;
+    protected safeWrite(operation: () => void): void;
+    get diskFull(): boolean;
+    getDiskFullStatus(): {
+        diskFull: boolean;
+        error: string | null;
+        since: number | null;
+    };
+    flushWriteBuffer(): number;
+    withDeferredBufferFlush<T>(operation: () => T): T;
+    getBufferedJobs(queue?: string): Job[];
+    getBufferedJob(jobId: JobId): Job | null;
+    getBufferedJobState(jobId: JobId): string | null;
+}

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

@@ -0,0 +1,17 @@
+import type { QueueMetricsMeta, QueueMetricType } from "../../../domain/types/metrics.js";
+import type { JobEvent } from "../../../domain/types/queue.js";
+import { SqliteControl } from "./control.js";
+export interface PersistedQueueMetrics {
+    meta: QueueMetricsMeta;
+    data: number[];
+}
+/** Durable lifecycle journal and minute-bucket metrics. */
+export declare abstract class SqliteTelemetry extends SqliteControl {
+    recordQueueEvent(event: JobEvent, maxEvents: number, maxMetricDataPoints: number): void;
+    recordQueueEventsBatch(events: readonly JobEvent[], maxEvents: number, maxMetricDataPoints: number): void;
+    getQueueMetrics(queue: string, type: QueueMetricType, maxMetricDataPoints: number): PersistedQueueMetrics;
+    trimQueueEvents(queue: string, maxLength: number): number;
+    countQueueEvents(queue: string): number;
+    clearQueueTelemetry(queue: string): void;
+    private expandMetricBuckets;
+}

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

@@ -0,0 +1,30 @@
+import type { Database } from "../../../../sdk/typescript/src/canonical-transport/bun-sqlite-types.js";
+import type { QueueMetricType } from "../../../domain/types/metrics.js";
+import type { JobEvent } from "../../../domain/types/queue.js";
+export interface MetricBucketRow {
+    minute: number;
+    count: number;
+}
+export interface MetricMetaRow {
+    total_count: number;
+    prev_ts: number;
+    prev_count: number;
+}
+/** Owns SQLite telemetry statements, transactions, and exact event retention counts. */
+export declare class SqliteTelemetryStore {
+    private readonly statements;
+    private readonly eventCounts;
+    private readonly writeTransaction;
+    private readonly clearTransaction;
+    constructor(db: Database);
+    writeQueueEvents(events: readonly JobEvent[], maxEvents: number, maxMetricDataPoints: number): void;
+    getMetricMeta(queue: string, type: QueueMetricType): MetricMetaRow | null;
+    getMetricBuckets(queue: string, type: QueueMetricType, limit: number): MetricBucketRow[];
+    trimQueueEvents(queue: string, maxLength: number): number;
+    countQueueEvents(queue: string): number;
+    clearQueueTelemetry(queue: string): void;
+    /** Run cached queue deletes inside the caller's transaction. */
+    deleteQueueTelemetryRows(queue: string): void;
+    markQueueTelemetryCleared(queue: string): void;
+    private refreshEventCount;
+}

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

@@ -0,0 +1,47 @@
+import type { Database } from "../../../../sdk/typescript/src/canonical-transport/bun-sqlite-types.js";
+import type { QueueMetricType } from "../../../domain/types/metrics.js";
+import { type JobEvent } from "../../../domain/types/queue.js";
+export interface PreparedQueueEvent {
+    event: JobEvent;
+    metricType: QueueMetricType | null;
+    minute: number;
+    payload: Uint8Array;
+}
+interface MetricEvent {
+    minute: number;
+    timestamp: number;
+}
+export interface MetricGroup {
+    queue: string;
+    type: QueueMetricType;
+    events: MetricEvent[];
+}
+export declare function prepareQueueEvents(events: readonly JobEvent[]): PreparedQueueEvent[];
+export declare function groupMetricEvents(events: readonly PreparedQueueEvent[]): MetricGroup[];
+type TelemetryStatement = ReturnType<Database['prepare']>;
+export interface TelemetryWriteStatements {
+    insertEvent: TelemetryStatement;
+    trimEvents: TelemetryStatement;
+    evictOldestEvents: TelemetryStatement;
+    incrementBucket: TelemetryStatement;
+    readBucket: TelemetryStatement;
+    updateMeta: TelemetryStatement;
+    clearBuckets: TelemetryStatement;
+    readNewest: TelemetryStatement;
+    trimBuckets: TelemetryStatement;
+}
+export interface QueueEventCountUpdate {
+    queue: string;
+    count: number;
+}
+export interface QueueEventWrite {
+    statements: TelemetryWriteStatements;
+    batch: readonly PreparedQueueEvent[];
+    metricGroups: readonly MetricGroup[];
+    eventLimit: number;
+    metricLimit: number;
+    eventCounts: ReadonlyMap<string, number>;
+}
+/** Apply prepared events inside an existing transaction, preserving scalar semantics. */
+export declare function applyQueueEvents(write: QueueEventWrite): QueueEventCountUpdate[];
+export {};

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

@@ -0,0 +1,6 @@
+import { SqliteLifecycle } from "./sqlite/lifecycle.js";
+export type { SqliteConfig, SqliteCriticalLoss, SqliteCriticalLossCallback } from "./types/sqlite.js";
+export type { DurableAdmissionMetadata } from "./types/admission.js";
+/** SQLite persistence façade. Implementation is split by responsibility. */
+export declare class SqliteStorage extends SqliteLifecycle {
+}

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

@@ -0,0 +1,4 @@
+/** Stable batch-persistence import surface. */
+export { BatchInsertManager } from "./batchInsert.js";
+export { WriteBuffer } from "./writeBuffer.js";
+export type { BatchInsertResult, CriticalErrorCallback, WriteBufferErrorCallback, } from "./types/batch.js";

package/dist/types/src/infrastructure/persistence/sqliteMigration.d.ts

@@ -0,0 +1,5 @@
+import type { Database } from "../../../sdk/typescript/src/canonical-transport/bun-sqlite-types.js";
+export declare function readSqliteSchemaVersion(db: Database): number;
+export declare function assertSupportedSqliteSchema(db: Database): number;
+/** Apply every pending SQLite migration in restart-safe, bounded phases. */
+export declare function migrateSqliteDatabase(db: Database, path: string): void;

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

@@ -0,0 +1,50 @@
+/**
+ * SQLite Serialization Utilities
+ * MessagePack encoding/decoding and row conversion
+ * Uses msgpackr for 2-3x faster serialization
+ */
+import { type Job } from "../../domain/types/job.js";
+import { type DlqEntry } from "../../domain/types/dlq.js";
+import type { DbJob } from "./statements.js";
+/** Encode data to MessagePack buffer */
+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;
+/** Decode a modern named payload or a pre-v31 name-in-data envelope. */
+export declare function decodeStoredNamedPayload(name: string | null | undefined, buffer: Uint8Array, context: string): {
+    name: string;
+    data: unknown;
+};
+/**
+ * Normalize jobs constructed by pre-stallCount integrations at the persistence
+ * boundary. The database keeps its NOT NULL invariant while an omitted legacy
+ * field receives the same zero default as a freshly created Job.
+ */
+export declare function persistedStallCount(job: Pick<Job, 'stallCount'>): number;
+export type PersistedJobState = 'active' | 'completed' | 'delayed' | 'prioritized' | 'waiting' | 'waiting-children';
+/** Override inference after a buffered job changes lifecycle before its insert succeeds. */
+export declare function setBufferedJobState(job: Job, state: PersistedJobState): void;
+/** Derive the current durable state when a buffered job is eventually inserted. */
+export declare function persistedJobStateForWrite(job: Job, now?: number): PersistedJobState;
+/**
+ * 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;
+/** 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 */
+export declare function rowToJob(row: DbJob): Job;
+/** Reconstruct DlqEntry from MessagePack-decoded data */
+export declare function reconstructDlqEntry(entry: DlqEntry): DlqEntry;