velocious 1.0.666 → 1.0.668

package/build/src/background-jobs/store.js

@@ -8,7 +8,7 @@ import BackgroundJobRecord from "./job-record.js";
 import normalizeBackgroundJobError from "./normalize-error.js";
 import { coordinateSharedTransactionConnection } from "../testing/shared-transaction-connection-coordinator.js";
 import stableJsonStringify from "../utils/stable-json.js";
-import { BACKGROUND_JOB_EXECUTION_MODES, DEFAULT_BACKGROUND_JOB_EXECUTION_MODE, DEFAULT_BACKGROUND_JOB_QUEUE, QUEUE_CONCURRENCY_KEY_PREFIX, normalizeBackgroundJobConcurrency, normalizeBackgroundJobExecutionMode, normalizeBackgroundJobMaxRetries, normalizeBackgroundJobQueue, normalizeBackgroundJobScheduledAtMs, rescheduledBackgroundJobAtMs, retryDelayMs } from "./job-semantics.js";
+import { BACKGROUND_JOB_TERMINAL_STATUSES, BACKGROUND_JOB_EXECUTION_MODES, DEFAULT_BACKGROUND_JOB_EXECUTION_MODE, DEFAULT_BACKGROUND_JOB_QUEUE, QUEUE_CONCURRENCY_KEY_PREFIX, normalizeBackgroundJobConcurrency, normalizeBackgroundJobExecutionMode, normalizeBackgroundJobMaxRetries, normalizeBackgroundJobQueue, normalizeBackgroundJobScheduleKey, normalizeBackgroundJobScheduledAtMs, normalizeBackgroundJobStatus, rescheduledBackgroundJobAtMs, retryDelayMs } from "./job-semantics.js";
 import { MAIL_DELIVERY_OPERATIONS_TABLE, mailDeliveryOperationForJob, mailDeliveryOperationKey } from "../mailer/delivery-operation.js";
 /**
  * PreparedBackgroundJob type.
@@ -77,6 +77,9 @@ const JOBS_INDEX_COLUMN_NAMES = [
 ];
 const IDEMPOTENCY_KEYS_TABLE = "background_job_idempotency_keys";
 const SCHEDULE_KEYS_TABLE = "background_job_schedule_keys";
+const SCHEDULE_ORDER_WATERMARKS_TABLE = "background_job_schedule_order_watermarks";
+const SCHEDULE_ORDER_WATERMARK_MIGRATION_VERSION = "20260911120000";
+const SCHEDULE_HISTORY_ORDER_INDEX = "index_background_jobs_schedule_history_order";
 const CONCURRENCY_TABLE = "background_job_concurrency";
 const COUNTS_REVISION_TABLE = "background_job_count_revisions";
 const COUNTS_REVISION_KEY = "counts";
@@ -817,7 +820,8 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
                 previousJobId = ownerJob.id;
                 previousStatus = "handed_off";
             }
-            await this._insertPreparedJob(db, { preparedJob, scheduleKey: normalizedScheduleKey });
+            const scheduleOrder = await this._nextScheduleOrder(db, normalizedScheduleKey);
+            await this._insertPreparedJob(db, { preparedJob, scheduleKey: normalizedScheduleKey, scheduleOrder });
             await db.upsert({
                 tableName: SCHEDULE_KEYS_TABLE,
                 data: { schedule_key: normalizedScheduleKey, job_id: preparedJob.jobId },
@@ -878,6 +882,68 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
             }
         });
     }
+    /**
+     * Reads stable ownership and optional latest terminal history in one fenced transaction.
+     * @param {string} scheduleKey - Stable logical schedule key.
+     * @param {{includeLatestTerminal?: boolean}} [options] - Lookup options.
+     * @returns {Promise<import("./types.js").BackgroundJobScheduledLookupResult>} - Normalized public jobs.
+     */
+    async getScheduledJob(scheduleKey, { includeLatestTerminal = false } = {}) {
+        await this.ensureReady();
+        const normalizedScheduleKey = this._normalizeScheduleKey(scheduleKey);
+        if (typeof includeLatestTerminal !== "boolean") {
+            throw VelociousError.safe("background job includeLatestTerminal must be a boolean");
+        }
+        return await this._serializedCountMutation(async (db) => {
+            return await this._scheduledJobLookup(db, {
+                includeLatestTerminal,
+                scheduleKey: normalizedScheduleKey
+            });
+        }, {
+            advisoryLock: {
+                failureMessage: "Failed to acquire background job schedule-key lock",
+                name: this._scheduleKeyLockName(normalizedScheduleKey)
+            }
+        });
+    }
+    /**
+     * Moves only a future queued stable owner to the current time.
+     * @param {string} scheduleKey - Stable logical schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobWakeResult>} - Exact wake outcome.
+     */
+    async wakeScheduled(scheduleKey) {
+        await this.ensureReady();
+        const normalizedScheduleKey = this._normalizeScheduleKey(scheduleKey);
+        return await this._serializedCountMutation(async (db) => {
+            const job = await this._scheduledOwnerJob(db, normalizedScheduleKey);
+            if (!job || (job.status !== "queued" && job.status !== "handed_off"))
+                return { jobId: null, outcome: "not_found" };
+            if (job.status === "handed_off")
+                return { jobId: job.id, outcome: "handed_off" };
+            const nowMs = this.clock.now();
+            if (Number(job.scheduledAtMs) <= nowMs)
+                return { jobId: job.id, outcome: "already_due" };
+            const affectedRows = await this._updateAffectedRows(db, {
+                tableName: JOBS_TABLE,
+                data: { scheduled_at_ms: nowMs },
+                conditions: { id: job.id, scheduled_at_ms: job.scheduledAtMs, status: "queued" }
+            });
+            if (affectedRows === 1)
+                return { jobId: job.id, outcome: "woken" };
+            const currentJob = await this._scheduledOwnerJob(db, normalizedScheduleKey);
+            if (currentJob?.status === "handed_off")
+                return { jobId: currentJob.id, outcome: "handed_off" };
+            if (currentJob?.status === "queued" && Number(currentJob.scheduledAtMs) <= nowMs) {
+                return { jobId: currentJob.id, outcome: "already_due" };
+            }
+            return { jobId: null, outcome: "not_found" };
+        }, {
+            advisoryLock: {
+                failureMessage: "Failed to acquire background job schedule-key lock",
+                name: this._scheduleKeyLockName(normalizedScheduleKey)
+            }
+        });
+    }
     /**
      * Runs next available job.
      * @param {object} [args] - Options.
@@ -1568,6 +1634,21 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
                 await db.query(`DELETE FROM ${db.quoteTable(IDEMPOTENCY_KEYS_TABLE)}`);
             if (await db.tableExists(SCHEDULE_KEYS_TABLE))
                 await db.query(`DELETE FROM ${db.quoteTable(SCHEDULE_KEYS_TABLE)}`);
+            if (await db.tableExists(SCHEDULE_ORDER_WATERMARKS_TABLE)) {
+                const watermarkRows = await db
+                    .newQuery()
+                    .from(SCHEDULE_ORDER_WATERMARKS_TABLE)
+                    .select("schedule_key")
+                    .results();
+                for (const watermarkRow of watermarkRows) {
+                    await db.delete({
+                        tableName: SCHEDULE_ORDER_WATERMARKS_TABLE,
+                        conditions: {
+                            schedule_key: String(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (watermarkRow).schedule_key)
+                        }
+                    });
+                }
+            }
             await db.query(`DELETE FROM ${db.quoteTable(JOBS_TABLE)}`);
             if (await db.tableExists(CONCURRENCY_TABLE))
                 await db.query(`DELETE FROM ${db.quoteTable(CONCURRENCY_TABLE)}`);
@@ -1658,9 +1739,10 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
      * @param {object} args - Insert input.
      * @param {PreparedBackgroundJob} args.preparedJob - Prepared job.
      * @param {string | null} args.scheduleKey - Historical stable key.
+     * @param {number | null} [args.scheduleOrder] - Monotonic stable ownership order.
      * @returns {Promise<void>} - Resolves after insertion.
      */
-    async _insertPreparedJob(db, { preparedJob, scheduleKey }) {
+    async _insertPreparedJob(db, { preparedJob, scheduleKey, scheduleOrder = null }) {
         const { concurrency } = preparedJob;
         if (concurrency) {
             if (concurrency.queueDerived) {
@@ -1684,6 +1766,7 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
                 scheduled_at_ms: preparedJob.scheduledAtMs,
                 created_at_ms: preparedJob.createdAtMs,
                 schedule_key: scheduleKey,
+                schedule_order: scheduleOrder,
                 concurrency_key: concurrency?.concurrencyKey || null,
                 max_concurrency: concurrency?.maxConcurrency || null,
                 timeout_ms: preparedJob.timeoutMs,
@@ -1730,9 +1813,7 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
      * @returns {string} - Validated key.
      */
     _normalizeScheduleKey(scheduleKey) {
-        if (typeof scheduleKey === "string" && scheduleKey.length > 0 && scheduleKey.length <= 255)
-            return scheduleKey;
-        throw VelociousError.safe("background job scheduleKey must be a non-empty string of at most 255 characters");
+        return normalizeBackgroundJobScheduleKey(scheduleKey);
     }
     /**
      * Builds a bounded advisory-lock name for one stable schedule key.
@@ -1885,6 +1966,7 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
         table.bigint("scheduled_at_ms", { null: false, index: true });
         table.bigint("created_at_ms", { null: false, index: true });
         table.string("schedule_key", { null: true, index: true });
+        table.bigint("schedule_order", { null: true });
         table.bigint("handed_off_at_ms", { null: true, index: true });
         table.string("handoff_id", { null: true });
         table.bigint("completed_at_ms", { null: true });
@@ -1977,6 +2059,8 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
         }
         await this._ensureQueueColumn(db);
         await this._ensureScheduleKeyColumn(db);
+        await this._ensureScheduleOrderColumn(db);
+        await this._ensureScheduleOrderWatermarksTable(db);
         await this._ensureJobTimeoutColumn(db);
         await this._ensureChildAcceptanceColumns(db);
         await this._ensureJobsTableIndexesOnce(db);
@@ -2112,6 +2196,109 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
             await db.releaseAdvisoryLock(lockName);
         }
     }
+    /**
+     * Idempotently adds monotonic schedule ownership history and its lookup index.
+     * Existing rows remain null and use the documented legacy fallback ordering.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @returns {Promise<void>} - Resolves when ensured.
+     */
+    async _ensureScheduleOrderColumn(db) {
+        const lockName = `${MIGRATION_SCOPE}:schedule_order_column`;
+        const acquired = await db.acquireAdvisoryLock(lockName);
+        if (!acquired)
+            throw new Error("Failed to acquire background jobs schedule-order schema lock");
+        try {
+            db.clearSchemaCache();
+            let table = await db.getTableByNameOrFail(JOBS_TABLE);
+            if (!(await table.getColumnByName("schedule_order"))) {
+                const tableData = new TableData(JOBS_TABLE);
+                tableData.bigint("schedule_order", { null: true });
+                for (const sql of await db.alterTableSQLs(tableData))
+                    await db.query(sql);
+                db.clearSchemaCache();
+                table = await db.getTableByNameOrFail(JOBS_TABLE);
+            }
+            const indexNames = new Set((await table.getIndexes()).map((index) => index.getName()));
+            if (!indexNames.has(SCHEDULE_HISTORY_ORDER_INDEX)) {
+                const sqls = await db.createIndexSQLs({
+                    columns: ["schedule_key", "schedule_order", "created_at_ms", "id"],
+                    ifNotExists: db.getType() === "sqlite",
+                    name: SCHEDULE_HISTORY_ORDER_INDEX,
+                    tableName: JOBS_TABLE
+                });
+                for (const sql of sqls)
+                    await db.query(sql);
+                db.clearSchemaCache();
+            }
+        }
+        finally {
+            await db.releaseAdvisoryLock(lockName);
+        }
+    }
+    /**
+     * Creates the retention-independent schedule-order high-water table and
+     * initializes it from the greatest retained ordered row for every key.
+     * Legacy rows whose order is null deliberately do not establish a watermark.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @returns {Promise<void>} - Resolves when ensured and backfilled.
+     */
+    async _ensureScheduleOrderWatermarksTable(db) {
+        const migrationVersion = SCHEDULE_ORDER_WATERMARK_MIGRATION_VERSION;
+        const migrationKey = this._migrationKey(migrationVersion);
+        const tableExists = await db.tableExists(SCHEDULE_ORDER_WATERMARKS_TABLE);
+        if (tableExists && await this._hasMigration(db, migrationVersion))
+            return;
+        const acquired = await db.acquireAdvisoryLock(migrationKey);
+        if (!acquired)
+            throw new Error("Failed to acquire background jobs schedule-order watermark schema lock");
+        try {
+            db.clearSchemaCache();
+            const lockedTableExists = await db.tableExists(SCHEDULE_ORDER_WATERMARKS_TABLE);
+            const alreadyApplied = await this._hasMigration(db, migrationVersion);
+            if (!lockedTableExists) {
+                const table = new TableData(SCHEDULE_ORDER_WATERMARKS_TABLE, { ifNotExists: true });
+                table.string("schedule_key", { primaryKey: true });
+                table.bigint("high_water_mark", { null: false });
+                await db.createTable(table);
+                db.clearSchemaCache();
+            }
+            // Rebuild a missing table even when its migration ledger survived. The
+            // retained job rows are the only compatible source for that recovery;
+            // once rows are pruned, normal schema durability protects the watermark.
+            if (!lockedTableExists || !alreadyApplied)
+                await this._backfillScheduleOrderWatermarks(db);
+            if (!alreadyApplied)
+                await this._recordMigration(db, migrationVersion);
+        }
+        finally {
+            await db.releaseAdvisoryLock(migrationKey);
+        }
+    }
+    /**
+     * Backfills each key from its greatest retained non-legacy ownership order.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @returns {Promise<void>} - Resolves after all retained keys are represented.
+     */
+    async _backfillScheduleOrderWatermarks(db) {
+        const keyRows = await db
+            .newQuery()
+            .from(JOBS_TABLE)
+            .select("schedule_key")
+            .whereNot({ schedule_key: null })
+            .whereNot({ schedule_order: null })
+            .distinct()
+            .results();
+        for (const keyRow of keyRows) {
+            const scheduleKey = String(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (keyRow).schedule_key);
+            const retainedOrder = await this._greatestRetainedScheduleOrder(db, scheduleKey);
+            const currentWatermark = await this._scheduleOrderWatermark(db, scheduleKey);
+            if (retainedOrder === null)
+                continue;
+            if (currentWatermark !== null && currentWatermark >= retainedOrder)
+                continue;
+            await this._writeScheduleOrderWatermark(db, { scheduleKey, scheduleOrder: retainedOrder });
+        }
+    }
     /**
      * Idempotently adds the `queue` column to an existing jobs table. Existing
      * rows read back as the default queue (see {@link _normalizeJobRow}), so no
@@ -2265,6 +2452,144 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
             return null;
         return this._normalizeJobRow(rows[0]);
     }
+    /**
+     * Reads the job currently named by one stable owner row.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {string} scheduleKey - Validated stable schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobRow | null>} - Normalized owner job.
+     */
+    async _scheduledOwnerJob(db, scheduleKey) {
+        const ownerRows = await db
+            .newQuery()
+            .from(SCHEDULE_KEYS_TABLE)
+            .where({ schedule_key: scheduleKey })
+            .limit(1)
+            .results();
+        const ownerRow = ownerRows[0];
+        if (!ownerRow)
+            return null;
+        return await this._getJobRowById(db, String(ownerRow.job_id));
+    }
+    /**
+     * Assigns the next ownership order while the caller holds the schedule-key
+     * advisory lock and count-revision transaction fence. The independent
+     * watermark survives both ownership release and terminal-history pruning.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {string} scheduleKey - Validated stable schedule key.
+     * @returns {Promise<number>} - Next monotonic ownership order.
+     */
+    async _nextScheduleOrder(db, scheduleKey) {
+        const durableOrder = await this._scheduleOrderWatermark(db, scheduleKey);
+        const retainedOrder = await this._greatestRetainedScheduleOrder(db, scheduleKey);
+        let currentOrder = durableOrder;
+        if (retainedOrder !== null && (currentOrder === null || retainedOrder > currentOrder))
+            currentOrder = retainedOrder;
+        const nextOrder = currentOrder === null ? 1 : currentOrder + 1;
+        if (!Number.isSafeInteger(nextOrder)) {
+            throw new Error(`Background job schedule ownership order exhausted for ${scheduleKey}`);
+        }
+        await this._writeScheduleOrderWatermark(db, { scheduleKey, scheduleOrder: nextOrder });
+        return nextOrder;
+    }
+    /**
+     * Finds the greatest retained non-legacy ownership order for migration and
+     * rolling-upgrade compatibility. It is never the sole durability boundary.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {string} scheduleKey - Validated stable schedule key.
+     * @returns {Promise<number | null>} - Greatest retained order, or null.
+     */
+    async _greatestRetainedScheduleOrder(db, scheduleKey) {
+        const rows = await db
+            .newQuery()
+            .from(JOBS_TABLE)
+            .select("schedule_order")
+            .where({ schedule_key: scheduleKey })
+            .whereNot({ schedule_order: null })
+            .order("schedule_order DESC")
+            .limit(1)
+            .results();
+        const row = rows[0];
+        if (!row)
+            return null;
+        return this._validatedScheduleOrder(
+        /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (row).schedule_order);
+    }
+    /**
+     * Reads and validates one retention-independent schedule-order watermark.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {string} scheduleKey - Validated stable schedule key.
+     * @returns {Promise<number | null>} - Current watermark, or null before first ownership.
+     */
+    async _scheduleOrderWatermark(db, scheduleKey) {
+        const rows = await db
+            .newQuery()
+            .from(SCHEDULE_ORDER_WATERMARKS_TABLE)
+            .select("high_water_mark")
+            .where({ schedule_key: scheduleKey })
+            .limit(1)
+            .results();
+        const row = rows[0];
+        if (!row)
+            return null;
+        return this._validatedScheduleOrder(
+        /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (row).high_water_mark);
+    }
+    /**
+     * Persists one schedule-order watermark without exposing it as a job row.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {object} args - Watermark identity and value.
+     * @param {string} args.scheduleKey - Validated stable schedule key.
+     * @param {number} args.scheduleOrder - Validated monotonic order.
+     * @returns {Promise<void>} - Resolves after persistence.
+     */
+    async _writeScheduleOrderWatermark(db, { scheduleKey, scheduleOrder }) {
+        await db.upsert({
+            tableName: SCHEDULE_ORDER_WATERMARKS_TABLE,
+            data: { high_water_mark: scheduleOrder, schedule_key: scheduleKey },
+            conflictColumns: ["schedule_key"],
+            updateColumns: ["high_water_mark"]
+        });
+    }
+    /**
+     * Validates an ownership order loaded from durable storage.
+     * @param {ReturnType<typeof JSON.parse>} value - Stored order.
+     * @returns {number} - Positive safe integer ownership order.
+     */
+    _validatedScheduleOrder(value) {
+        const scheduleOrder = this._normalizeNumber(value);
+        if (scheduleOrder === null || !Number.isSafeInteger(scheduleOrder) || scheduleOrder < 1) {
+            throw new Error(`Invalid background job schedule ownership order: ${scheduleOrder}`);
+        }
+        return scheduleOrder;
+    }
+    /**
+     * Builds a stable-schedule lookup exclusively from normalized job rows.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {object} args - Lookup options.
+     * @param {boolean} args.includeLatestTerminal - Whether terminal history is requested.
+     * @param {string} args.scheduleKey - Validated stable schedule key.
+     * @returns {Promise<import("./types.js").BackgroundJobScheduledLookupResult>} - Normalized public jobs.
+     */
+    async _scheduledJobLookup(db, { includeLatestTerminal, scheduleKey }) {
+        const ownerJob = await this._scheduledOwnerJob(db, scheduleKey);
+        const currentJob = ownerJob && (ownerJob.status === "queued" || ownerJob.status === "handed_off") ? ownerJob : null;
+        if (!includeLatestTerminal)
+            return { currentJob, latestTerminalJob: null };
+        const terminalStatuses = BACKGROUND_JOB_TERMINAL_STATUSES.map((status) => db.quote(status)).join(", ");
+        const terminalRows = await db
+            .newQuery()
+            .from(JOBS_TABLE)
+            .where({ schedule_key: scheduleKey })
+            .where(`${db.quoteColumn("status")} IN (${terminalStatuses})`)
+            .order(`CASE WHEN ${db.quoteColumn("schedule_order")} IS NULL THEN 0 ELSE 1 END DESC`)
+            .order("schedule_order DESC")
+            .order("created_at_ms DESC")
+            .order("id DESC")
+            .limit(1)
+            .results();
+        const latestTerminalJob = terminalRows[0] ? this._normalizeJobRow(terminalRows[0]) : null;
+        return { currentJob, latestTerminalJob };
+    }
     /**
      * Releases ownership only when the key still points at the expected job.
      * @param {import("../database/drivers/base.js").default} db - Database connection.
@@ -2435,7 +2760,8 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
             executionMode,
             queue: row.queue ? String(row.queue) : DEFAULT_BACKGROUND_JOB_QUEUE,
             scheduleKey: row.schedule_key ? String(row.schedule_key) : null,
-            status: row.status ? String(row.status) : "queued",
+            scheduleOrder: this._normalizeNumber(row.schedule_order),
+            status: normalizeBackgroundJobStatus(row.status ? String(row.status) : "queued"),
             attempts: this._normalizeNumber(row.attempts),
             maxRetries: this._normalizeNumber(row.max_retries),
             scheduledAtMs: this._normalizeNumber(row.scheduled_at_ms),
@@ -3301,4 +3627,4 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
         return `${MIGRATION_SCOPE}:${version}`;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../src/background-jobs/store.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {createHash, randomUUID} from \"crypto\"\nimport BackgroundJobsAdapter from \"./adapter.js\"\nimport Logger from \"../logger.js\"\nimport TableData from \"../database/table-data/index.js\"\nimport VelociousError from \"../velocious-error.js\"\nimport BackgroundJobRecord from \"./job-record.js\"\nimport normalizeBackgroundJobError from \"./normalize-error.js\"\nimport { coordinateSharedTransactionConnection } from \"../testing/shared-transaction-connection-coordinator.js\"\nimport stableJsonStringify from \"../utils/stable-json.js\"\nimport {\n  BACKGROUND_JOB_EXECUTION_MODES,\n  DEFAULT_BACKGROUND_JOB_EXECUTION_MODE,\n  DEFAULT_BACKGROUND_JOB_QUEUE,\n  QUEUE_CONCURRENCY_KEY_PREFIX,\n  normalizeBackgroundJobConcurrency,\n  normalizeBackgroundJobExecutionMode,\n  normalizeBackgroundJobMaxRetries,\n  normalizeBackgroundJobQueue,\n  normalizeBackgroundJobScheduledAtMs,\n  rescheduledBackgroundJobAtMs,\n  retryDelayMs\n} from \"./job-semantics.js\"\nimport {\n  MAIL_DELIVERY_OPERATIONS_TABLE,\n  mailDeliveryOperationForJob,\n  mailDeliveryOperationKey\n} from \"../mailer/delivery-operation.js\"\n\n/**\n * PreparedBackgroundJob type.\n * @typedef {object} PreparedBackgroundJob\n * @property {string} argsJson - Serialized arguments.\n * @property {{concurrencyKey: string, maxConcurrency: number, queueDerived: boolean} | null} concurrency - Resolved concurrency.\n * @property {number} createdAtMs - Creation timestamp.\n * @property {import(\"./types.js\").BackgroundJobExecutionMode} executionMode - Execution mode.\n * @property {string} jobId - New job id.\n * @property {string} jobName - Job name.\n * @property {number} maxRetries - Retry cap.\n * @property {string} queue - Queue name.\n * @property {number} scheduledAtMs - Eligibility timestamp.\n * @property {number | null} timeoutMs - Per-job timeout override, or null when omitted.\n */\n\n/**\n * BackgroundJobOrphanSelection type.\n * @typedef {object} BackgroundJobOrphanSelection\n * @property {Record<string, ReturnType<typeof JSON.parse>>} conditions - Exact update fence.\n * @property {import(\"./types.js\").BackgroundJobRow} job - Selected active handoff.\n */\n\n/**\n * BackgroundJobTransactionSerializationOptions type.\n * @typedef {object} BackgroundJobTransactionSerializationOptions\n * @property {{failureMessage: string, name: string}} [advisoryLock] - Session lock held around the transaction.\n */\n\n/**\n * BackgroundJobConcurrencyCountRow type.\n * @typedef {object} BackgroundJobConcurrencyCountRow\n * @property {number | string} active_count - Persisted or aggregated active count.\n * @property {string} concurrency_key - Durable cap identity.\n */\n\n/**\n * BackgroundJobQueuedConcurrency type.\n * @typedef {object} BackgroundJobQueuedConcurrency\n * @property {string | null} concurrencyKey - Current concurrency key for queued work.\n * @property {number | null} maxConcurrency - Current concurrency cap for queued work.\n */\n\nconst MIGRATIONS_TABLE = \"velocious_internal_migrations\"\nconst MIGRATION_SCOPE = \"background_jobs\"\nconst MIGRATION_VERSION = \"20250215000000\"\nconst SCHEMA_RECOVERY_PENDING_VERSION = \"schema-recovery-pending\"\nconst EXECUTION_MODE_BACKFILL_MIGRATION_VERSION = \"20260607131010\"\n// Drops the redundant legacy `forked` boolean column and rewrites pooled rows to\n// persist `execution_mode = \"pooled\"` directly (retiring the pooled-as-forked\n// handoff-marker workaround), leaving `execution_mode` as the single source of\n// truth for a job's runtime.\nconst DROP_FORKED_COLUMN_MIGRATION_VERSION = \"20260719000000\"\nconst JOBS_INDEX_REPAIR_MIGRATION_VERSION = \"20260903120000\"\n// Legacy marker prefix used by rows written before this migration: pooled jobs\n// used to persist as `execution_mode = \"forked\"` plus a `velocious-pooled:*`\n// handoff id. Retained only to detect and convert those rows in the migration.\nconst LEGACY_POOLED_HANDOFF_ID_PREFIX = \"velocious-pooled:\"\nconst LEGACY_POOLED_QUEUED_HANDOFF_ID = `${LEGACY_POOLED_HANDOFF_ID_PREFIX}queued`\nconst JOBS_TABLE = \"background_jobs\"\nconst JOBS_INDEX_COLUMN_NAMES = [\n  \"job_name\",\n  \"queue\",\n  \"status\",\n  \"scheduled_at_ms\",\n  \"created_at_ms\",\n  \"schedule_key\",\n  \"handed_off_at_ms\",\n  \"orphaned_at_ms\",\n  \"concurrency_key\"\n]\nconst IDEMPOTENCY_KEYS_TABLE = \"background_job_idempotency_keys\"\nconst SCHEDULE_KEYS_TABLE = \"background_job_schedule_keys\"\nconst CONCURRENCY_TABLE = \"background_job_concurrency\"\nconst COUNTS_REVISION_TABLE = \"background_job_count_revisions\"\nconst COUNTS_REVISION_KEY = \"counts\"\nconst CONCURRENCY_RECONCILIATION_LOCK = \"background-jobs:queue-concurrency-reconcile\"\nconst CONCURRENCY_REPAIR_SAMPLE_LIMIT = 10\nexport const BACKGROUND_JOB_COUNTS_CHANNEL = \"velocious-background-job-counts\"\nexport const BACKGROUND_JOB_COUNT_BUCKETS = [\"all\", \"queued\", \"handed_off\", \"completed\", \"failed\", \"orphaned\"]\nconst COUNTED_JOB_STATUSES = BACKGROUND_JOB_COUNT_BUCKETS.slice(1)\nconst MAX_JOB_TIMEOUT_MS = 2_147_483_647\nconst JOB_TIMEOUT_VALIDATION_MESSAGE = `background job timeoutMs must be a finite non-positive number or an integer between 1 and ${MAX_JOB_TIMEOUT_MS}`\nconst ORPHANED_AFTER_MS = 2 * 60 * 60 * 1000\n\n/**\n * Columns the dashboard is allowed to sort job listings by, mapped to their\n * database column names. Restricting to this set keeps the sort parameter\n * (which originates from untrusted query strings) from reaching raw SQL.\n * @type {Record<string, string>}\n */\nconst SORTABLE_COLUMNS = {\n  attempts: \"attempts\",\n  completedAtMs: \"completed_at_ms\",\n  createdAtMs: \"created_at_ms\",\n  failedAtMs: \"failed_at_ms\",\n  handedOffAtMs: \"handed_off_at_ms\",\n  scheduledAtMs: \"scheduled_at_ms\"\n}\n\n/**\n * Serializes concurrent `_applySchema` runs within THIS process, keyed by database\n * identifier, before callers without an existing connection check one out. Two\n * stores that share one connection (SingleMultiUse / SQLite)\n * otherwise interleave the multi-step table rebuild and corrupt it (the jobs table\n * is left as its `*_velocious_rebuild` temp). A DB advisory lock can't fix that: on\n * a session-scoped / re-entrant driver (MySQL `GET_LOCK`) a second acquire on the\n * same session succeeds immediately so both callers proceed, and taking it on a\n * separate connection blocks cross-session forever. An in-process promise-chain\n * mutex serializes same-process callers with neither hazard. Cross-process schema\n * races stay covered by the per-step advisory locks + rechecks inside the steps.\n * @type {Map<string, Promise<void>>}\n */\nconst schemaApplyChains = new Map()\n/** @type {Map<string, Promise<void>>} */\nconst transactionMutationChains = new Map()\n\nexport default class BackgroundJobsStore extends BackgroundJobsAdapter {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration.\n   * @param {string} [args.databaseIdentifier] - Database identifier.\n   * @param {{now: () => number}} [args.clock] - Injectable persistence clock.\n   * @param {(producerProof: import(\"./types.js\").BackgroundJobProducerProof) => void | Promise<void>} [args.afterOwnedProducerValidation] - Exact owned-enqueue validation hook.\n   */\n  constructor({configuration, databaseIdentifier, clock, afterOwnedProducerValidation}) {\n    super()\n    this.configuration = configuration\n    this.databaseIdentifier = databaseIdentifier\n    this.clock = clock || {now: () => Date.now()}\n    this.afterOwnedProducerValidation = afterOwnedProducerValidation\n    this.logger = new Logger(this)\n    this._readyPromise = null\n    this._queueConcurrencyReconciled = false\n  }\n\n  /**\n   * Runs get database identifier.\n   * @returns {string} - Database identifier.\n   */\n  getDatabaseIdentifier() {\n    if (this.databaseIdentifier) return this.databaseIdentifier\n\n    return this.configuration.getBackgroundJobsConfig().databaseIdentifier\n  }\n\n  /**\n   * Runs ensure ready.\n   * @returns {Promise<void>} - Resolves when ready.\n   */\n  async ensureReady() {\n    if (this._readyPromise) return await this._readyPromise\n\n    this._readyPromise = (async () => {\n      this.configuration.setCurrent()\n      await this._ensureSchema()\n      await this._initializeModel()\n    })()\n\n    try {\n      await this._readyPromise\n    } finally {\n      this._readyPromise = null\n    }\n  }\n\n  /**\n   * Ensures the background-jobs schema (tables + columns) exists on the configured\n   * database, without initializing the runtime model. Lets `db:migrate` create the\n   * framework's own schema deterministically alongside app migrations — and capture\n   * it in the dumped structure SQL — instead of it only appearing once a store boots.\n   * Idempotent: reuses the same `_ensureSchema` the runtime store uses, which skips\n   * work already applied (tracked in `velocious_internal_migrations`).\n   * @param {import(\"../database/drivers/base.js\").default} [db] - Reuse an already\n   *   checked-out connection (e.g. the one `db:migrate` holds) rather than opening a\n   *   nested checkout that would deadlock a single-connection pool.\n   * @returns {Promise<void>} - Resolves when the schema is present.\n   */\n  async ensureSchema(db) {\n    // When a connection is handed in (the db:migrate path), the caller already owns\n    // the active configuration + connection context; calling setCurrent() here would\n    // clobber it (e.g. the browser test runner juggles multiple configurations).\n    if (!db) this.configuration.setCurrent()\n\n    await this._ensureSchema(db)\n  }\n\n  /**\n   * Reconciles queue-derived concurrency with the current configuration: the\n   * explicit lifecycle path that adopts/releases persisted queued jobs onto\n   * queue concurrency keys when `queues[name].maxConcurrent` is added, removed,\n   * or changed. Called by the background-jobs main process on startup — the\n   * deploy-time moment queue configuration changes take effect. Schema/tenant\n   * checks and routine connection initialization deliberately never run this:\n   * they stay read-only regarding queued job rows, because the broad\n   * adoption/release UPDATEs deadlock against active job processes under\n   * concurrent tenant initialization. Serialized across processes with a\n   * database advisory lock so concurrently started mains cannot interleave the\n   * UPDATEs; the per-instance memo only skips repeat work within this process.\n   * @returns {Promise<void>} - Resolves when reconciled.\n   */\n  async reconcileQueueConcurrency() {\n    if (this._queueConcurrencyReconciled) return\n\n    const databaseIdentifier = this.getDatabaseIdentifier()\n    const startedAtMs = Date.now()\n\n    await this.logger.info(() => [\n      \"Starting background jobs queue-concurrency startup reconciliation\",\n      {databaseIdentifier}\n    ])\n    await this.ensureReady()\n\n    await this._withDb(async (db) => {\n      const acquired = await db.acquireAdvisoryLock(CONCURRENCY_RECONCILIATION_LOCK)\n\n      if (!acquired) throw new Error(\"Failed to acquire background job queue-concurrency reconcile lock\")\n\n      try {\n        await this._reconcileQueueConcurrency(db)\n        await this._reconcileConcurrency(db)\n\n        // Latch the memo only after BOTH steps succeed: if the count rebuild\n        // fails after adoption, a retry on this store must re-enter and repair\n        // the counts (adoption itself is idempotent).\n        this._queueConcurrencyReconciled = true\n      } finally {\n        await db.releaseAdvisoryLock(CONCURRENCY_RECONCILIATION_LOCK)\n      }\n    })\n\n    await this.logger.info(() => [\n      \"Completed background jobs queue-concurrency startup reconciliation\",\n      {databaseIdentifier, durationMs: Date.now() - startedAtMs}\n    ])\n  }\n\n  /**\n   * Repairs durable active-count drift while a main process remains live. The\n   * initial snapshot is read-only; only suspected mismatches take their\n   * counter lock and re-count inside the serialized transaction path.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobConcurrencyReconciliation>} - Repair summary.\n   */\n  async reconcileActiveConcurrency() {\n    const databaseIdentifier = this.getDatabaseIdentifier()\n    const startedAtMs = Date.now()\n\n    await this.ensureReady()\n\n    const result = await this._serializedConnectionMutation(\n      async (db) => await this._reconcileConcurrency(db),\n      {\n        advisoryLock: {\n          failureMessage: \"Failed to acquire background job active-concurrency reconcile lock\",\n          name: CONCURRENCY_RECONCILIATION_LOCK\n        }\n      }\n    )\n\n    if (result.repairedCount > 0) {\n      await this.logger.warn(() => [\n        \"Repaired background jobs active-concurrency count drift\",\n        {\n          databaseIdentifier,\n          durationMs: Date.now() - startedAtMs,\n          repairedCount: result.repairedCount,\n          repairs: result.repairs,\n          repairsTruncatedCount: result.repairsTruncatedCount\n        }\n      ])\n    }\n\n    return result\n  }\n\n  /**\n   * Runs enqueue.\n   * @param {object} args - Options.\n   * @param {string} args.jobName - Job name.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Arguments.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Options.\n   * @returns {Promise<string>} - Job id.\n   */\n  async enqueue({jobName, args, options}) {\n    await this.ensureReady()\n\n    const preparedJob = this._prepareJob({jobName, args, options})\n\n    if (options?.idempotencyKey !== undefined) {\n      return await this._enqueueIdempotently({args: args || [], options, preparedJob})\n    }\n\n    /** @type {string} */\n    let resultJobId = preparedJob.jobId\n\n    await this._serializedCountMutation(async (db) => {\n      if (options?.deduplicateWhileQueued) {\n        const duplicateJobId = await this._deduplicatedQueuedJobId(db, preparedJob)\n\n        if (duplicateJobId) {\n          resultJobId = duplicateJobId\n          return\n        }\n      }\n\n      await this._insertPreparedJob(db, {preparedJob, scheduleKey: null})\n      await this._recordCountDelta(db, {all: 1, queued: 1})\n    })\n\n    return resultJobId\n  }\n\n  /**\n   * Atomically validates an exact producing handoff and enqueues its follow-up.\n   * Every exact request owns an internal durable replay identity, while queued\n   * deduplication can point several distinct producer events at one covering row.\n   * @param {object} args - Owned enqueue request.\n   * @param {string} args.jobName - Job name.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Arguments.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Options.\n   * @param {string} [args.producerInvocationId] - Stable identity for one owned enqueue invocation.\n   * @param {import(\"./types.js\").BackgroundJobProducerProof} args.producerProof - Exact producer lease.\n   * @returns {Promise<string>} - Durable follow-up id.\n   */\n  async enqueueFromOwnedHandoff({jobName, args, options, producerInvocationId, producerProof}) {\n    await this.ensureReady()\n\n    const normalizedProducerProof = this._normalizeProducerProof(producerProof)\n    const normalizedProducerInvocationId = this._normalizeProducerInvocationId(producerInvocationId)\n    const preparedJob = this._prepareJob({jobName, args, options})\n\n    return await this._serializedCountMutation(async (db) => {\n      await this._validateOwnedProducerProof(db, normalizedProducerProof)\n      if (this.afterOwnedProducerValidation) await this.afterOwnedProducerValidation(normalizedProducerProof)\n\n      if (options?.idempotencyKey !== undefined) {\n        return await this._enqueueIdempotentlyInTransaction({\n          args: args || [],\n          countRevisionLocked: true,\n          db,\n          options,\n          preparedJob\n        })\n      }\n\n      return await this._enqueueOwnedReplayInTransaction({\n        db,\n        options: options || {},\n        preparedJob,\n        producerInvocationId: normalizedProducerInvocationId,\n        producerProof: normalizedProducerProof\n      })\n    })\n  }\n\n  /**\n   * Finds the earliest queued job that covers this enqueue's identity and time.\n   * @param {import(\"../database/drivers/base.js\").default} db - Transaction connection.\n   * @param {PreparedBackgroundJob} preparedJob - Normalized job.\n   * @returns {Promise<string | null>} - Covering job id.\n   */\n  async _deduplicatedQueuedJobId(db, preparedJob) {\n    // Dedupe on the job's identity (name + args + queue), NOT its concurrency key, so a job\n    // keeps whatever concurrency it resolves to. Only an existing job scheduled no later than\n    // this enqueue can cover it; a retry backed off into the future must not suppress earlier\n    // work. Ordering returns the earliest covering job when several queued rows already exist.\n    const existing = await db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .select(\"id\")\n      .where({status: \"queued\", job_name: preparedJob.jobName, args_json: preparedJob.argsJson, queue: preparedJob.queue})\n      .where(`scheduled_at_ms <= ${db.quote(preparedJob.scheduledAtMs)}`)\n      .order(\"scheduled_at_ms ASC\")\n      .limit(1)\n      .results()\n    const row = existing[0]\n\n    return row ? String(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (row).id) : null\n  }\n\n  /**\n   * Persists one internal exact-replay owner and its queued job in the caller's\n   * producer-validation transaction.\n   * @param {object} args - Transaction input.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Transaction connection.\n   * @param {import(\"./types.js\").BackgroundJobOptions} args.options - Enqueue options.\n   * @param {PreparedBackgroundJob} args.preparedJob - Normalized job.\n   * @param {string} args.producerInvocationId - Stable identity for one owned enqueue invocation.\n   * @param {import(\"./types.js\").BackgroundJobProducerProof} args.producerProof - Exact producer lease.\n   * @returns {Promise<string>} - Stable replay job id.\n   */\n  async _enqueueOwnedReplayInTransaction({db, options, preparedJob, producerInvocationId, producerProof}) {\n    const requestDigest = this._ownedEnqueueRequestDigest({options, preparedJob})\n    const scopeDigest = this._ownedEnqueueScopeDigest({preparedJob, producerInvocationId, producerProof, requestDigest})\n    const idempotencyKey = `owned-handoff:${scopeDigest}`\n    const existing = await this._idempotencyOwnership(db, scopeDigest)\n    const baseOwnership = {\n      created_at_ms: preparedJob.createdAtMs,\n      idempotency_key: idempotencyKey,\n      job_name: preparedJob.jobName,\n      queue: preparedJob.queue,\n      request_digest: requestDigest,\n      scope_digest: scopeDigest\n    }\n\n    if (existing) {\n      this._validateIdempotencyOwnership({existing, ownership: {...baseOwnership, job_id: String(existing.job_id)}})\n      return String(existing.job_id)\n    }\n\n    const duplicateJobId = options.deduplicateWhileQueued\n      ? await this._deduplicatedQueuedJobId(db, preparedJob)\n      : null\n    const ownership = {...baseOwnership, job_id: duplicateJobId || preparedJob.jobId}\n    const claimed = await this._claimIdempotencyOwnership(db, ownership)\n\n    if (!claimed.created) {\n      this._validateIdempotencyOwnership({existing: claimed.row, ownership})\n      return String(claimed.row.job_id)\n    }\n    if (duplicateJobId) return duplicateJobId\n\n    await this._insertPreparedJob(db, {preparedJob, scheduleKey: null})\n    await this._recordCountDelta(db, {all: 1, queued: 1})\n\n    return preparedJob.jobId\n  }\n\n  /**\n   * Atomically owns one durable idempotency scope and creates its job exactly once.\n   * @param {object} args - Enqueue input.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job arguments.\n   * @param {import(\"./types.js\").BackgroundJobOptions} args.options - Job options.\n   * @param {PreparedBackgroundJob} args.preparedJob - Normalized job.\n   * @returns {Promise<string>} - Stable original job id.\n   */\n  async _enqueueIdempotently({args, options, preparedJob}) {\n    // Reuse ordinary enqueue transaction admission because this path changes\n    // the same durable count revision. The scope primary key remains the\n    // cross-process convergence owner.\n    return await this._idempotentEnqueueTransaction(async (db) => {\n      return await this._enqueueIdempotentlyInTransaction({args, db, options, preparedJob})\n    })\n  }\n\n  /**\n   * Owns or replays one public idempotency key inside the caller's transaction.\n   * @param {object} args - Transaction input.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job arguments.\n   * @param {boolean} [args.countRevisionLocked] - Whether the caller already owns count serialization.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Transaction connection.\n   * @param {import(\"./types.js\").BackgroundJobOptions} args.options - Job options.\n   * @param {PreparedBackgroundJob} args.preparedJob - Normalized job.\n   * @returns {Promise<string>} - Stable original job id.\n   */\n  async _enqueueIdempotentlyInTransaction({args, countRevisionLocked = false, db, options, preparedJob}) {\n    const idempotencyKey = this._normalizeIdempotencyKey(options.idempotencyKey)\n    const scopeDigest = this._idempotencyScopeDigest({idempotencyKey, jobName: preparedJob.jobName, queue: preparedJob.queue})\n    const requestDigest = this._idempotencyRequestDigest({args, options, preparedJob})\n    const ownership = {\n      created_at_ms: preparedJob.createdAtMs,\n      idempotency_key: idempotencyKey,\n      job_id: preparedJob.jobId,\n      job_name: preparedJob.jobName,\n      queue: preparedJob.queue,\n      request_digest: requestDigest,\n      scope_digest: scopeDigest\n    }\n    const mailOperationInput = mailDeliveryOperationForJob(preparedJob.jobName, args)\n\n    if (mailOperationInput && mailOperationInput.operation.id !== idempotencyKey) {\n      throw VelociousError.safe(\"Mail delivery operation id must equal its background job idempotency key.\", {\n        code: \"mail-delivery-idempotency-key-mismatch\"\n      })\n    }\n\n    const existing = await this._idempotencyOwnership(db, scopeDigest)\n\n    if (existing) {\n      this._validateIdempotencyOwnership({existing, ownership})\n      await this._validateMailDeliveryOperation(db, {jobId: String(existing.job_id), mailOperationInput})\n      return String(existing.job_id)\n    }\n\n    const claimed = await this._claimIdempotencyOwnership(db, ownership)\n\n    if (!claimed.created) {\n      this._validateIdempotencyOwnership({existing: claimed.row, ownership})\n      await this._validateMailDeliveryOperation(db, {jobId: String(claimed.row.job_id), mailOperationInput})\n      return String(claimed.row.job_id)\n    }\n\n    if (!countRevisionLocked) await this._lockCountRevision(db)\n    await this._insertPreparedJob(db, {preparedJob, scheduleKey: null})\n    await this._persistMailDeliveryOperation(db, {jobId: preparedJob.jobId, mailOperationInput, createdAtMs: preparedJob.createdAtMs})\n    await this._recordCountDelta(db, {all: 1, queued: 1})\n\n    return preparedJob.jobId\n  }\n\n  /**\n   * Serializes one physical connection locally without taking ownership away\n   * from the database uniqueness constraint shared by all processes.\n   * @template T\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<T>} callback - Transaction work.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async _idempotentEnqueueTransaction(callback) {\n    return await this._serializedTransactionMutation(callback)\n  }\n\n  /**\n   * Inserts an ownership row, resolving only a database uniqueness race.\n   * @param {import(\"../database/drivers/base.js\").default} db - Transaction connection.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} ownership - Ownership row.\n   * @returns {Promise<{created: boolean, row: Record<string, ReturnType<typeof JSON.parse>>}>} - Claim result.\n   */\n  async _claimIdempotencyOwnership(db, ownership) {\n    try {\n      // The savepoint keeps PostgreSQL's outer transaction usable after a\n      // concurrent unique-key loss. The unique primary key, not a process\n      // mutex, is the cross-process convergence authority.\n      await db.transaction(async () => {\n        await db.insert({tableName: IDEMPOTENCY_KEYS_TABLE, data: ownership})\n      })\n\n      return {created: true, row: ownership}\n    } catch (error) {\n      const raced = await this._idempotencyOwnership(db, String(ownership.scope_digest))\n\n      if (!raced) throw error\n      return {created: false, row: raced}\n    }\n  }\n\n  /**\n   * Loads one durable enqueue owner.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} scopeDigest - Fixed-size scope digest.\n   * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>> | null>} - Row or null.\n   */\n  async _idempotencyOwnership(db, scopeDigest) {\n    const rows = await db.newQuery().from(IDEMPOTENCY_KEYS_TABLE).where({scope_digest: scopeDigest}).limit(1).results()\n\n    return rows[0] ? /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (rows[0]) : null\n  }\n\n  /**\n   * Fails closed when a durable key is reused for a different canonical request.\n   * @param {object} args - Validation input.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.existing - Stored owner.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.ownership - Requested owner.\n   * @returns {void}\n   */\n  _validateIdempotencyOwnership({existing, ownership}) {\n    const exactScope = String(existing.job_name) === ownership.job_name\n      && String(existing.queue) === ownership.queue\n      && String(existing.idempotency_key) === ownership.idempotency_key\n\n    if (!exactScope || String(existing.request_digest) !== ownership.request_digest) {\n      throw VelociousError.safe(\"The background job idempotency key was already used for a different request.\", {\n        code: \"background-job-idempotency-conflict\"\n      })\n    }\n  }\n\n  /**\n   * Persists the built-in mail operation in the same first-enqueue transaction.\n   * @param {import(\"../database/drivers/base.js\").default} db - Transaction connection.\n   * @param {object} args - Operation input.\n   * @param {number} args.createdAtMs - Creation timestamp.\n   * @param {string} args.jobId - Native job id.\n   * @param {{operation: import(\"../mailer/index.js\").MailerDeliveryOperation, payload: import(\"../mailer/index.js\").MailerDeliveryPayload} | null} args.mailOperationInput - Mail operation.\n   * @returns {Promise<void>} - Resolves after persistence.\n   */\n  async _persistMailDeliveryOperation(db, {createdAtMs, jobId, mailOperationInput}) {\n    if (!mailOperationInput) return\n    const {operation} = mailOperationInput\n    const operationKey = mailDeliveryOperationKey(operation.id)\n    const row = {\n      background_job_id: jobId,\n      created_at_ms: createdAtMs,\n      first_attempt_started_at_ms: null,\n      operation_id: operation.id,\n      operation_key: operationKey,\n      payload_digest: operation.payloadDigest,\n      provider_kind: operation.providerKind,\n      provider_retention_ms: operation.providerRetentionMs\n    }\n\n    try {\n      await db.transaction(async () => {\n        await db.insert({tableName: MAIL_DELIVERY_OPERATIONS_TABLE, data: row})\n      })\n    } catch (error) {\n      const existing = await this._mailDeliveryOperation(db, operationKey)\n\n      if (!existing) throw error\n      this._validateMailDeliveryOperationRow({existing, requested: row})\n    }\n  }\n\n  /**\n   * Validates the durable mail row during an exact generic enqueue replay.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {object} args - Validation input.\n   * @param {string} args.jobId - Owned job id.\n   * @param {{operation: import(\"../mailer/index.js\").MailerDeliveryOperation, payload: import(\"../mailer/index.js\").MailerDeliveryPayload} | null} args.mailOperationInput - Mail operation.\n   * @returns {Promise<void>} - Resolves when exact.\n   */\n  async _validateMailDeliveryOperation(db, {jobId, mailOperationInput}) {\n    if (!mailOperationInput) return\n    const {operation} = mailOperationInput\n    const existing = await this._mailDeliveryOperation(db, mailDeliveryOperationKey(operation.id))\n\n    if (!existing) {\n      throw new Error(\"Background job idempotency ownership is missing its durable mail delivery operation\")\n    }\n\n    this._validateMailDeliveryOperationRow({\n      existing,\n      requested: {\n        background_job_id: jobId,\n        operation_id: operation.id,\n        payload_digest: operation.payloadDigest,\n        provider_kind: operation.providerKind,\n        provider_retention_ms: operation.providerRetentionMs\n      }\n    })\n  }\n\n  /**\n   * Loads a durable mail operation.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} operationKey - Fixed-size operation key.\n   * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>> | null>} - Row or null.\n   */\n  async _mailDeliveryOperation(db, operationKey) {\n    const rows = await db.newQuery().from(MAIL_DELIVERY_OPERATIONS_TABLE).where({operation_key: operationKey}).limit(1).results()\n\n    return rows[0] ? /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (rows[0]) : null\n  }\n\n  /**\n   * Compares provider-relevant durable mail operation fields.\n   * @param {object} args - Validation input.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.existing - Stored row.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.requested - Requested row.\n   * @returns {void}\n   */\n  _validateMailDeliveryOperationRow({existing, requested}) {\n    const matches = String(existing.operation_id) === requested.operation_id\n      && String(existing.payload_digest) === requested.payload_digest\n      && String(existing.background_job_id) === requested.background_job_id\n      && String(existing.provider_kind) === requested.provider_kind\n      && this._normalizeNumber(existing.provider_retention_ms) === requested.provider_retention_ms\n\n    if (!matches) {\n      throw VelociousError.safe(\"The mail delivery operation was already used for a different payload or provider.\", {\n        code: \"mail-delivery-idempotency-conflict\"\n      })\n    }\n  }\n\n  /**\n   * Canonical request digest excluding generated ids and immediate enqueue time.\n   * @param {object} args - Digest input.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job arguments.\n   * @param {import(\"./types.js\").BackgroundJobOptions} args.options - Job options.\n   * @param {PreparedBackgroundJob} args.preparedJob - Normalized job.\n   * @returns {string} - SHA-256 digest.\n   */\n  _idempotencyRequestDigest({args, options, preparedJob}) {\n    const serialized = stableJsonStringify({\n      args,\n      concurrency: preparedJob.concurrency,\n      executionMode: preparedJob.executionMode,\n      format: \"velocious-background-job-idempotency-v1\",\n      jobName: preparedJob.jobName,\n      maxRetries: preparedJob.maxRetries,\n      queue: preparedJob.queue,\n      scheduledAtMs: options.scheduledAtMs === undefined ? null : preparedJob.scheduledAtMs,\n      scheduling: options.scheduledAtMs === undefined ? \"immediate\" : \"scheduled\",\n      ...(preparedJob.timeoutMs === null ? {} : {timeoutMs: preparedJob.timeoutMs})\n    })\n\n    return createHash(\"sha256\").update(serialized).digest(\"hex\")\n  }\n\n  /**\n   * Fixed-size globally indexed representation of the documented scope tuple.\n   * @param {object} args - Scope input.\n   * @param {string} args.idempotencyKey - Caller key.\n   * @param {string} args.jobName - Job class name.\n   * @param {string} args.queue - Queue name.\n   * @returns {string} - SHA-256 scope digest.\n   */\n  _idempotencyScopeDigest({idempotencyKey, jobName, queue}) {\n    return createHash(\"sha256\")\n      .update(stableJsonStringify({format: \"velocious-background-job-idempotency-scope-v1\", idempotencyKey, jobName, queue}))\n      .digest(\"hex\")\n  }\n\n  /**\n   * Validates one caller key.\n   * @param {string | undefined} idempotencyKey - Caller key.\n   * @returns {string} - Valid key.\n   */\n  _normalizeIdempotencyKey(idempotencyKey) {\n    if (typeof idempotencyKey !== \"string\" || idempotencyKey.length === 0) {\n      throw VelociousError.safe(\"Background job idempotencyKey must be a non-empty string.\", {\n        code: \"background-job-idempotency-key-invalid\"\n      })\n    }\n\n    return idempotencyKey\n  }\n\n  /**\n   * Canonical request identity for an internal owned-handoff replay.\n   * Immediate enqueue wall time and generated job ids remain excluded.\n   * @param {object} args - Digest input.\n   * @param {import(\"./types.js\").BackgroundJobOptions} args.options - Enqueue options.\n   * @param {PreparedBackgroundJob} args.preparedJob - Normalized job.\n   * @returns {string} - SHA-256 digest.\n   */\n  _ownedEnqueueRequestDigest({options, preparedJob}) {\n    const serialized = stableJsonStringify({\n      argsJson: preparedJob.argsJson,\n      concurrency: preparedJob.concurrency,\n      deduplicateWhileQueued: options.deduplicateWhileQueued === true,\n      executionMode: preparedJob.executionMode,\n      format: \"velocious-background-job-owned-enqueue-v1\",\n      jobName: preparedJob.jobName,\n      maxRetries: preparedJob.maxRetries,\n      queue: preparedJob.queue,\n      scheduledAtMs: options.scheduledAtMs === undefined ? null : preparedJob.scheduledAtMs,\n      scheduling: options.scheduledAtMs === undefined ? \"immediate\" : \"scheduled\",\n      ...(preparedJob.timeoutMs === null ? {} : {timeoutMs: preparedJob.timeoutMs})\n    })\n\n    return createHash(\"sha256\").update(serialized).digest(\"hex\")\n  }\n\n  /**\n   * Isolates internal producer replay ownership from caller idempotency scopes.\n   * @param {object} args - Scope input.\n   * @param {PreparedBackgroundJob} args.preparedJob - Normalized job.\n   * @param {string} args.producerInvocationId - Stable identity for one owned enqueue invocation.\n   * @param {import(\"./types.js\").BackgroundJobProducerProof} args.producerProof - Exact producer lease.\n   * @param {string} args.requestDigest - Canonical request digest.\n   * @returns {string} - SHA-256 scope digest.\n   */\n  _ownedEnqueueScopeDigest({preparedJob, producerInvocationId, producerProof, requestDigest}) {\n    return createHash(\"sha256\")\n      .update(stableJsonStringify({\n        format: \"velocious-background-job-owned-enqueue-scope-v1\",\n        jobName: preparedJob.jobName,\n        producerInvocationId,\n        producerProof,\n        queue: preparedJob.queue,\n        requestDigest\n      }))\n      .digest(\"hex\")\n  }\n\n  /**\n   * Validates the untrusted identity of one producer-owned enqueue invocation.\n   * @param {string | undefined} producerInvocationId - Producer invocation identity.\n   * @returns {string} - Validated identity.\n   */\n  _normalizeProducerInvocationId(producerInvocationId) {\n    if (typeof producerInvocationId !== \"string\" || producerInvocationId.length === 0) {\n      throw VelociousError.safe(\"Background job producer invocation id is invalid.\", {\n        code: \"background-job-producer-invocation-id-invalid\"\n      })\n    }\n\n    return producerInvocationId\n  }\n\n  /**\n   * Validates the untrusted transport shape before transaction admission.\n   * @param {import(\"./types.js\").BackgroundJobProducerProof} producerProof - Producer proof.\n   * @returns {import(\"./types.js\").BackgroundJobProducerProof} - Normalized immutable proof.\n   */\n  _normalizeProducerProof(producerProof) {\n    const exactKeys = [\"handedOffAtMs\", \"handoffId\", \"jobId\", \"workerId\"]\n    const keys = producerProof && typeof producerProof === \"object\" ? Object.keys(producerProof) : []\n    const valid = producerProof\n      && typeof producerProof === \"object\"\n      && keys.length === exactKeys.length\n      && keys.every((key) => exactKeys.includes(key))\n      && typeof producerProof.jobId === \"string\"\n      && producerProof.jobId.length > 0\n      && typeof producerProof.handoffId === \"string\"\n      && producerProof.handoffId.length > 0\n      && typeof producerProof.workerId === \"string\"\n      && producerProof.workerId.length > 0\n      && Number.isSafeInteger(producerProof.handedOffAtMs)\n      && producerProof.handedOffAtMs >= 0\n\n    if (!valid) {\n      throw VelociousError.safe(\"Background job producer proof is invalid.\", {\n        code: \"background-job-producer-proof-invalid\"\n      })\n    }\n\n    return Object.freeze({\n      handedOffAtMs: producerProof.handedOffAtMs,\n      handoffId: producerProof.handoffId,\n      jobId: producerProof.jobId,\n      workerId: producerProof.workerId\n    })\n  }\n\n  /**\n   * Confirms exact active ownership while the enqueue transaction holds the\n   * shared mutation fence used by terminal producer transitions.\n   * @param {import(\"../database/drivers/base.js\").default} db - Transaction connection.\n   * @param {import(\"./types.js\").BackgroundJobProducerProof} producerProof - Exact producer lease.\n   * @returns {Promise<void>} - Resolves while ownership remains exact.\n   */\n  async _validateOwnedProducerProof(db, producerProof) {\n    const producer = await this._getJobRowById(db, producerProof.jobId)\n    const owned = producer\n      && producer.status === \"handed_off\"\n      && producer.handoffId === producerProof.handoffId\n      && producer.workerId === producerProof.workerId\n      && producer.handedOffAtMs === producerProof.handedOffAtMs\n\n    if (!owned) {\n      throw VelociousError.safe(\"Background job producer handoff is no longer owned.\", {\n        code: \"background-job-producer-handoff-not-owned\"\n      })\n    }\n  }\n\n  /**\n   * Replaces the queued owner of a stable schedule key with a new one-off job.\n   * A handed-off owner is left running and reported truthfully.\n   * @param {object} args - Options.\n   * @param {string} args.scheduleKey - Stable logical schedule key.\n   * @param {string} args.jobName - Job name.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Arguments.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Options.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobReplacementResult>} - Replacement result.\n   */\n  async replaceScheduled({scheduleKey, jobName, args, options}) {\n    await this.ensureReady()\n\n    const normalizedScheduleKey = this._normalizeScheduleKey(scheduleKey)\n    const preparedJob = this._prepareJob({jobName, args, options})\n\n    return await this._serializedCountMutation(async (db) => {\n      const ownerRows = await db\n        .newQuery()\n        .from(SCHEDULE_KEYS_TABLE)\n        .where({schedule_key: normalizedScheduleKey})\n        .limit(1)\n        .results()\n      const ownerJobId = ownerRows[0] ? String(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (ownerRows[0]).job_id) : null\n      const ownerJob = ownerJobId ? await this._getJobRowById(db, ownerJobId) : null\n      /** @type {import(\"./types.js\").BackgroundJobReplacementPreviousStatus} */\n      let previousStatus = null\n      let previousJobId = null\n\n      if (ownerJob?.status === \"queued\") {\n        const affectedRows = await this._updateAffectedRows(db, {\n          tableName: JOBS_TABLE,\n          data: {status: \"cancelled\"},\n          conditions: {id: ownerJob.id, status: \"queued\"}\n        })\n\n        if (affectedRows === 1) {\n          previousJobId = ownerJob.id\n          previousStatus = \"queued\"\n        } else {\n          const currentOwnerJob = await this._getJobRowById(db, ownerJob.id)\n\n          if (currentOwnerJob?.status === \"handed_off\") {\n            previousJobId = currentOwnerJob.id\n            previousStatus = \"handed_off\"\n          }\n        }\n      } else if (ownerJob?.status === \"handed_off\") {\n        previousJobId = ownerJob.id\n        previousStatus = \"handed_off\"\n      }\n\n      await this._insertPreparedJob(db, {preparedJob, scheduleKey: normalizedScheduleKey})\n      await db.upsert({\n        tableName: SCHEDULE_KEYS_TABLE,\n        data: {schedule_key: normalizedScheduleKey, job_id: preparedJob.jobId},\n        conflictColumns: [\"schedule_key\"],\n        updateColumns: [\"job_id\"]\n      })\n\n      if (previousStatus !== \"queued\") await this._recordCountDelta(db, {all: 1, queued: 1})\n      return {jobId: preparedJob.jobId, previousJobId, previousStatus}\n    }, {\n      advisoryLock: {\n        failureMessage: \"Failed to acquire background job schedule-key lock\",\n        name: this._scheduleKeyLockName(normalizedScheduleKey)\n      }\n    })\n  }\n\n  /**\n   * Cancels the queued owner of a stable schedule key. A handed-off owner is\n   * detached but not marked stopped because execution may already be running.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobCancellationResult>} - Cancellation result.\n   */\n  async cancelScheduled(scheduleKey) {\n    await this.ensureReady()\n\n    const normalizedScheduleKey = this._normalizeScheduleKey(scheduleKey)\n\n    return await this._serializedCountMutation(async (db) => {\n      const ownerRows = await db\n        .newQuery()\n        .from(SCHEDULE_KEYS_TABLE)\n        .where({schedule_key: normalizedScheduleKey})\n        .limit(1)\n        .results()\n\n      if (!ownerRows[0]) return {jobId: null, outcome: \"not_found\"}\n\n      const jobId = String(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (ownerRows[0]).job_id)\n      const job = await this._getJobRowById(db, jobId)\n\n      if (job?.status === \"queued\") {\n        const affectedRows = await this._updateAffectedRows(db, {\n          tableName: JOBS_TABLE,\n          data: {status: \"cancelled\"},\n          conditions: {id: job.id, status: \"queued\"}\n        })\n\n        if (affectedRows === 1) {\n          await this._releaseScheduleOwnership(db, {jobId, scheduleKey: normalizedScheduleKey})\n          await this._recordStatusTransition(db, \"queued\", \"cancelled\")\n\n          return {jobId, outcome: \"cancelled\"}\n        }\n      }\n\n      const currentJob = await this._getJobRowById(db, jobId)\n\n      await this._releaseScheduleOwnership(db, {jobId, scheduleKey: normalizedScheduleKey})\n\n      if (currentJob?.status === \"handed_off\") return {jobId, outcome: \"handed_off\"}\n      return {jobId: null, outcome: \"not_found\"}\n    }, {\n      advisoryLock: {\n        failureMessage: \"Failed to acquire background job schedule-key lock\",\n        name: this._scheduleKeyLockName(normalizedScheduleKey)\n      }\n    })\n  }\n\n  /**\n   * Runs next available job.\n   * @param {object} [args] - Options.\n   * @param {import(\"./types.js\").BackgroundJobExecutionMode | import(\"./types.js\").BackgroundJobExecutionMode[]} [args.executionMode] - Execution mode or modes to match.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Next job.\n   */\n  async nextAvailableJob(args = {}) {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      return await this._nextQueuedJob({\n        db,\n        scheduledAtOperator: \"<=\",\n        executionMode: args.executionMode\n      })\n    })\n  }\n\n  /**\n   * Returns the soonest future-scheduled queued job (one whose\n   * `scheduled_at_ms` is in the future), or null when there are no\n   * future-scheduled jobs. Used by the event-driven dispatcher to arm a\n   * `setTimeout` for the exact moment the next scheduled job becomes\n   * eligible, replacing the legacy 1-second polling loop.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Soonest future-scheduled job, or null.\n   */\n  async nextScheduledJob() {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      return await this._nextQueuedJob({db, scheduledAtOperator: \">\"})\n    })\n  }\n\n  /**\n   * Runs next queued job.\n   * @param {object} args - Options.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Database connection.\n   * @param {\"<=\" | \">\"} args.scheduledAtOperator - Scheduled timestamp operator.\n   * @param {import(\"./types.js\").BackgroundJobExecutionMode | import(\"./types.js\").BackgroundJobExecutionMode[]} [args.executionMode] - Execution mode or modes to match.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Next matching queued job.\n   */\n  async _nextQueuedJob({db, scheduledAtOperator, executionMode}) {\n    const now = this.clock.now()\n    let query = db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .where({status: \"queued\"})\n      .where(`scheduled_at_ms ${scheduledAtOperator} ${db.quote(now)}`)\n\n    if (scheduledAtOperator === \"<=\") {\n      const jobsTable = db.quoteTable(JOBS_TABLE)\n      const concurrencyTable = db.quoteTable(CONCURRENCY_TABLE)\n      query = query.where(\n        `(${jobsTable}.${db.quoteColumn(\"concurrency_key\")} IS NULL OR EXISTS (` +\n        `SELECT 1 FROM ${concurrencyTable} WHERE ` +\n        `${concurrencyTable}.${db.quoteColumn(\"concurrency_key\")} = ${jobsTable}.${db.quoteColumn(\"concurrency_key\")} AND ` +\n        `${concurrencyTable}.${db.quoteColumn(\"active_count\")} < ${concurrencyTable}.${db.quoteColumn(\"max_concurrency\")}))`\n      )\n    }\n\n    if (executionMode) query = this._whereExecutionMode({db, executionMode, query})\n\n    if (scheduledAtOperator === \"<=\") {\n      const priorityOrder = this._queuePriorityOrderSql(db)\n\n      if (priorityOrder) query = query.order(`${priorityOrder} DESC`)\n    }\n\n    query = query\n      .order(\"scheduled_at_ms ASC\")\n      .order(\"created_at_ms ASC\")\n      .limit(1)\n\n    const rows = await query.results()\n    const row = rows[0]\n\n    if (!row) return null\n\n    return this._normalizeJobRow(row)\n  }\n\n  /**\n   * Builds a raw SQL ORDER BY expression ranking queued jobs by their queue's\n   * configured priority (`backgroundJobs.queues[queue].priority`, default `0`),\n   * so the dispatcher picks higher-priority queues first regardless of enqueue\n   * order. Only applied to the dispatch path (`scheduledAtOperator === \"<=\"`);\n   * the future-scheduled lookup must stay strictly time-ordered. Composes with\n   * the concurrency EXISTS filter: a higher-priority queue already at its cap is\n   * filtered out, so dispatch falls through to the next eligible lower-priority\n   * job. Returns null when no queue configures a non-zero priority so the plain\n   * FIFO ordering is left untouched (and no needless filesort is introduced).\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {string | null} - Raw SQL CASE expression, or null when no queue is prioritized.\n   */\n  _queuePriorityOrderSql(db) {\n    const queues = this.configuration.getBackgroundJobsConfig().queues || {}\n    /** @type {Array<[string, number]>} */\n    const prioritized = []\n\n    for (const [queue, queueConfig] of Object.entries(queues)) {\n      const priority = queueConfig?.priority\n\n      if (Number.isFinite(priority) && Number(priority) !== 0) prioritized.push([queue, Number(priority)])\n    }\n\n    if (prioritized.length === 0) return null\n\n    const queueColumn = db.quoteColumn(\"queue\")\n    const whens = prioritized\n      .map(([queue, priority]) => `WHEN ${db.quote(queue)} THEN ${priority}`)\n      .join(\" \")\n\n    return `CASE COALESCE(${queueColumn}, ${db.quote(DEFAULT_BACKGROUND_JOB_QUEUE)}) ${whens} ELSE 0 END`\n  }\n\n  /**\n   * Runs get job.\n   * @param {string} jobId - Job id.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Job row.\n   */\n  async getJob(jobId) {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      const query = db\n        .newQuery()\n        .from(JOBS_TABLE)\n        .where({id: jobId})\n        .limit(1)\n\n      const rows = await query.results()\n      const row = rows[0]\n\n      if (!row) return null\n\n      return this._normalizeJobRow(row)\n    })\n  }\n\n  /**\n   * Counts jobs grouped by status. Used by the dashboard overview.\n   * @returns {Promise<Record<string, number>>} - Counts keyed by status.\n   */\n  async countsByStatus() {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      const rows = await db\n        .newQuery()\n        .from(JOBS_TABLE)\n        .select(\"status\")\n        .select(\"COUNT(*) AS count\")\n        .group(\"status\")\n        .results()\n\n      /**\n       * Counts.\n       * @type {Record<string, number>} */\n      const counts = {}\n\n      for (const row of rows) {\n        const typedRow = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (row)\n\n        counts[String(typedRow.status)] = this._normalizeNumber(typedRow.count) || 0\n      }\n\n      return counts\n    })\n  }\n\n  /**\n   * Returns the authoritative dashboard count snapshot and its matching durable\n   * revision. Locking the revision row before counting prevents a writer from\n   * committing between the count query and revision read.\n   * @returns {Promise<{counts: Record<string, number>, revision: number, total: number}>} Snapshot.\n   */\n  async countSnapshot() {\n    await this.ensureReady()\n\n    return await this._serializedCountMutation(async (db) => {\n      return await this._countSnapshotOnLockedConnection(db)\n    })\n  }\n\n  /**\n   * Counts jobs matching the given filters.\n   * @param {object} [args] - Options.\n   * @param {string} [args.status] - Filter by status.\n   * @param {string} [args.jobName] - Filter by job name.\n   * @returns {Promise<number>} - Matching job count.\n   */\n  async countJobs({status, jobName} = {}) {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      let query = db.newQuery().from(JOBS_TABLE).select(\"COUNT(*) AS count\")\n\n      if (status) query = query.where({status})\n      if (jobName) query = query.where({job_name: jobName})\n\n      const rows = await query.results()\n      const countRow = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (rows[0] || {})\n\n      return this._normalizeNumber(countRow.count) || 0\n    })\n  }\n\n  /**\n   * Lists jobs for the dashboard, filtered, sorted and paginated.\n   * @param {object} [args] - Options.\n   * @param {string} [args.status] - Filter by status.\n   * @param {string} [args.jobName] - Filter by job name.\n   * @param {number} [args.limit] - Maximum rows to return.\n   * @param {number} [args.offset] - Rows to skip.\n   * @param {string} [args.sortColumn] - Camel-cased column to sort by (see SORTABLE_COLUMNS).\n   * @param {\"ASC\" | \"DESC\"} [args.sortDirection] - Sort direction.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow[]>} - Normalized job rows.\n   */\n  async listJobs({status, jobName, limit = 25, offset = 0, sortColumn = \"createdAtMs\", sortDirection = \"DESC\"} = {}) {\n    await this.ensureReady()\n\n    const column = SORTABLE_COLUMNS[sortColumn] || SORTABLE_COLUMNS.createdAtMs\n    const direction = sortDirection === \"ASC\" ? \"ASC\" : \"DESC\"\n\n    return await this._withDb(async (db) => {\n      let query = db.newQuery().from(JOBS_TABLE)\n\n      if (status) query = query.where({status})\n      if (jobName) query = query.where({job_name: jobName})\n\n      query = query.order({column, direction})\n      if (column !== SORTABLE_COLUMNS.createdAtMs) query = query.order({column: SORTABLE_COLUMNS.createdAtMs, direction: \"DESC\"})\n\n      const rows = await query.limit(limit).offset(offset).results()\n\n      return rows.map((row) => this._normalizeJobRow(row))\n    })\n  }\n\n  /**\n   * Runs mark handed off.\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {string} [args.handoffId] - Caller-selected exact lease id. Generated for legacy direct callers when omitted.\n   * @param {string} [args.workerId] - Worker id.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobHandoff | null>} - Claimed handoff lease, or null when no longer queued.\n   */\n  async markHandedOff({jobId, handoffId = randomUUID(), workerId}) {\n    await this.ensureReady()\n\n    const handedOffAtMs = this.clock.now()\n\n    return await this._serializedCountMutation(async (db) => {\n      const selectedJob = await this._getJobRowById(db, jobId)\n      if (!selectedJob || selectedJob.status !== \"queued\") return null\n      const queuedJob = await this._reconcileQueuedJobConcurrency(db, selectedJob)\n\n      if (!queuedJob) return null\n      if (queuedJob.concurrencyKey && !(await this._reserveConcurrency(db, queuedJob.concurrencyKey))) return null\n      const affectedRows = await this._updateAffectedRows(db, {\n        tableName: JOBS_TABLE,\n        data: {\n          status: \"handed_off\",\n          handed_off_at_ms: handedOffAtMs,\n          handoff_id: handoffId,\n          worker_id: workerId || null,\n          ...this._clearedChildAcceptanceData()\n        },\n        conditions: {concurrency_key: queuedJob.concurrencyKey, id: jobId, status: \"queued\"}\n      })\n\n      if (affectedRows !== 1) {\n        await this._releaseConcurrency(db, queuedJob.concurrencyKey)\n        return null\n      }\n\n      await this._recordStatusTransition(db, \"queued\", \"handed_off\")\n      /** @type {import(\"./types.js\").BackgroundJobRow} */\n      const handedOffJob = {\n        ...queuedJob,\n        ...this._clearedChildAcceptanceRow(),\n        handedOffAtMs,\n        handoffId,\n        status: \"handed_off\",\n        workerId: workerId || null\n      }\n\n      return {handedOffAtMs, handoffId, job: handedOffJob}\n    })\n  }\n\n  /**\n   * Runs mark completed.\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {string} [args.handoffId] - Handoff lease id.\n   * @param {string} [args.workerId] - Worker id.\n   * @param {number} [args.handedOffAtMs] - Handed off timestamp.\n   * @returns {Promise<boolean>} - Whether the fenced report was accepted.\n   */\n  async markCompleted({jobId, handoffId, workerId, handedOffAtMs}) {\n    await this.ensureReady()\n\n    return await this._serializedCountMutation(async (db) => {\n      const job = await this._getJobRowById(db, jobId)\n\n      if (!job) return false\n      if (!this._shouldAcceptReport({job, handoffId, workerId, handedOffAtMs})) return false\n\n      await this._lockConcurrencyRow(db, job.concurrencyKey)\n      const affectedRows = await this._updateAffectedRows(db, {\n        tableName: JOBS_TABLE,\n        data: {\n          status: \"completed\",\n          completed_at_ms: this.clock.now()\n        },\n        conditions: this._activeHandoffConditions(job)\n      })\n\n      if (affectedRows !== 1) return false\n      await this._releaseScheduleOwnershipForJob(db, job)\n      await this._releaseConcurrency(db, job.concurrencyKey)\n      await this._recordStatusTransition(db, \"handed_off\", \"completed\")\n      return true\n    })\n  }\n\n  /**\n   * Records pooled-child acceptance evidence for an active handoff: when the\n   * executing runner child received and/or started the job, plus that child's\n   * stable identity and pid. Only the fields supplied are written, so a\n   * received-then-started observation lands as two fenced partial updates. The\n   * update is fenced by the exact active handoff lease, so a report for a\n   * reclaimed or re-handed-off job is dropped instead of stamping the wrong\n   * attempt.\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {string} [args.handoffId] - Handoff lease id.\n   * @param {string} [args.workerId] - Worker id.\n   * @param {number} [args.handedOffAtMs] - Handed off timestamp.\n   * @param {number} [args.receivedAtMs] - Epoch ms the runner child received the job.\n   * @param {number} [args.startedAtMs] - Epoch ms the job's perform started in the child.\n   * @param {string} [args.childInstanceId] - Stable pooled child identity.\n   * @param {number} [args.childPid] - Pooled child OS pid.\n   * @returns {Promise<boolean>} - Whether the fenced report was accepted.\n   */\n  async markChildAccepted({jobId, handoffId, workerId, handedOffAtMs, receivedAtMs, startedAtMs, childInstanceId, childPid}) {\n    await this.ensureReady()\n\n    return await this._serializedConnectionMutation(async (db) => {\n      const job = await this._getJobRowById(db, jobId)\n\n      if (!job) return false\n      if (!this._shouldAcceptReport({job, handoffId, workerId, handedOffAtMs})) return false\n\n      const data = {}\n      if (typeof receivedAtMs === \"number\") data.child_received_at_ms = receivedAtMs\n      if (typeof startedAtMs === \"number\") data.child_started_at_ms = startedAtMs\n      if (typeof childInstanceId === \"string\") data.child_instance_id = childInstanceId\n      if (typeof childPid === \"number\") data.child_pid = childPid\n      if (Object.keys(data).length === 0) return false\n\n      const affectedRows = await this._updateAffectedRows(db, {\n        tableName: JOBS_TABLE,\n        data,\n        conditions: this._activeHandoffConditions(job)\n      })\n\n      return affectedRows === 1\n    })\n  }\n\n  /**\n   * Returns the database data that clears pooled-child acceptance evidence.\n   * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Cleared acceptance columns.\n   */\n  _clearedChildAcceptanceData() {\n    return {child_instance_id: null, child_pid: null, child_received_at_ms: null, child_started_at_ms: null}\n  }\n\n  /**\n   * Returns the row-shape counterpart of the cleared acceptance columns.\n   * @returns {Pick<import(\"./types.js\").BackgroundJobRow, \"childInstanceId\" | \"childPid\" | \"childReceivedAtMs\" | \"childStartedAtMs\">} - Cleared acceptance fields.\n   */\n  _clearedChildAcceptanceRow() {\n    return {childInstanceId: null, childPid: null, childReceivedAtMs: null, childStartedAtMs: null}\n  }\n\n  /**\n   * Returns an active handoff to the queue at a caller-requested future time.\n   * This is normal job control flow: it preserves failure attempts and metadata.\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {number} args.delayMs - Delay from persistence time in milliseconds.\n   * @param {string} [args.handoffId] - Handoff lease id.\n   * @param {string} [args.workerId] - Worker id.\n   * @param {number} [args.handedOffAtMs] - Handed off timestamp.\n   * @returns {Promise<boolean>} - Whether the fenced report was accepted.\n   */\n  async markRescheduled({jobId, delayMs, handoffId, workerId, handedOffAtMs}) {\n    await this.ensureReady()\n    this._validateRescheduleDelayMs(delayMs)\n\n    return await this._serializedCountMutation(async (db) => {\n      const job = await this._getJobRowById(db, jobId)\n\n      if (!job) return false\n      if (!this._shouldAcceptReport({job, handoffId, workerId, handedOffAtMs})) return false\n\n      await this._lockConcurrencyRow(db, job.concurrencyKey)\n      const scheduledAtMs = this._rescheduledAtMs(delayMs)\n      const affectedRows = await this._updateAffectedRows(db, {\n        tableName: JOBS_TABLE,\n        data: {\n          status: \"queued\",\n          scheduled_at_ms: scheduledAtMs,\n          handed_off_at_ms: null,\n          handoff_id: null,\n          worker_id: null,\n          ...this._clearedChildAcceptanceData()\n        },\n        conditions: this._activeHandoffConditions(job)\n      })\n\n      if (affectedRows !== 1) return false\n      await this._releaseConcurrency(db, job.concurrencyKey)\n      await this._recordStatusTransition(db, \"handed_off\", \"queued\")\n      return true\n    })\n  }\n\n  /**\n   * Runs mark returned to queue.\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {string} args.handoffId - Handoff lease id.\n   * @returns {Promise<void>} - Resolves when updated.\n   */\n  async markReturnedToQueue({jobId, handoffId}) {\n    await this.ensureReady()\n\n    await this._serializedCountMutation(async (db) => {\n      const job = await this._getJobRowById(db, jobId)\n      if (!job || job.handoffId !== handoffId || job.status !== \"handed_off\") return\n      await this._lockConcurrencyRow(db, job.concurrencyKey)\n      const affectedRows = await this._updateAffectedRows(db, {\n        tableName: JOBS_TABLE,\n        data: {\n          status: \"queued\",\n          scheduled_at_ms: this.clock.now(),\n          handed_off_at_ms: null,\n          handoff_id: null,\n          worker_id: null,\n          ...this._clearedChildAcceptanceData()\n        },\n        conditions: {handoff_id: handoffId, id: jobId, status: \"handed_off\"}\n      })\n      if (affectedRows === 1) {\n        await this._releaseConcurrency(db, job.concurrencyKey)\n        await this._recordStatusTransition(db, \"handed_off\", \"queued\")\n      }\n    })\n  }\n\n  /**\n   * Returns the active `handed_off` jobs (jobId + handoffId) held under a worker\n   * id. Used on worker reconnect: after a main restart a worker reconnects with\n   * its stable id, and the fresh main adopts these leases so they are tracked —\n   * and released if the reconnected worker later disconnects — instead of\n   * sitting stuck until the age-based orphan sweep. This never reclaims, so a\n   * gracefully-draining worker that keeps running its in-flight jobs is left\n   * untouched. Rows with a null handoff id (legacy) are skipped; the orphan\n   * sweep reclaims those via its `handed_off_at_ms` fence.\n   * @param {object} args - Options.\n   * @param {string} args.workerId - Worker id.\n   * @returns {Promise<Array<{jobId: string, handoffId: string}>>} - Active handoffs.\n   */\n  async handedOffJobsForWorker({workerId}) {\n    await this.ensureReady()\n\n    const rows = await this._withDb(async (db) =>\n      await db.newQuery().from(JOBS_TABLE).where({status: \"handed_off\", worker_id: workerId}).results()\n    )\n\n    /** @type {Array<{jobId: string, handoffId: string}>} */\n    const handoffs = []\n\n    for (const row of rows) {\n      const job = this._normalizeJobRow(row)\n\n      if (job.handoffId) handoffs.push({jobId: job.id, handoffId: job.handoffId})\n    }\n\n    return handoffs\n  }\n\n  /**\n   * Snapshots exact, lease-aware active handoffs before a new main generation\n   * starts accepting worker reconnects. Legacy rows without a complete worker,\n   * lease, and timestamp identity stay owned by the age-based orphan sweep.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobHandoffSnapshot[]>} - Exact startup handoffs.\n   */\n  async snapshotHandedOffJobs() {\n    await this.ensureReady()\n\n    const rows = await this._withDb(async (db) => await db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .where({status: \"handed_off\"})\n      .order(\"created_at_ms ASC\")\n      .order(\"id ASC\")\n      .results())\n    /** @type {import(\"./types.js\").BackgroundJobHandoffSnapshot[]} */\n    const handoffs = []\n\n    for (const row of rows) {\n      const job = this._normalizeJobRow(row)\n\n      if (!job.handoffId || !job.workerId || typeof job.handedOffAtMs !== \"number\") continue\n\n      handoffs.push({\n        handedOffAtMs: job.handedOffAtMs,\n        handoffId: job.handoffId,\n        jobId: job.id,\n        workerId: job.workerId\n      })\n    }\n\n    return handoffs\n  }\n\n  /**\n   * Reclaims only unchanged exact handoffs selected by a main-generation startup\n   * snapshot. The ordinary orphan failure path owns retries, terminal status,\n   * count transitions, schedule ownership, and concurrency release.\n   * @param {object} args - Options.\n   * @param {import(\"./types.js\").BackgroundJobHandoffSnapshot[]} args.handoffs - Exact startup snapshots.\n   * @param {ReturnType<typeof JSON.parse>} args.error - Orphan reason.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow[]>} - Accepted transitions.\n   */\n  async markOrphanedHandoffs({handoffs, error}) {\n    await this.ensureReady()\n\n    return await this._serializedCountMutation(async (db) => {\n      /** @type {BackgroundJobOrphanSelection[]} */\n      const selections = []\n\n      for (const handoff of handoffs) {\n        const job = await this._getJobRowById(db, handoff.jobId)\n\n        if (!job || job.status !== \"handed_off\") continue\n        if (job.handoffId !== handoff.handoffId) continue\n        if (job.workerId !== handoff.workerId) continue\n        if (job.handedOffAtMs !== handoff.handedOffAtMs) continue\n\n        selections.push({\n          conditions: {\n            handed_off_at_ms: handoff.handedOffAtMs,\n            handoff_id: handoff.handoffId,\n            id: handoff.jobId,\n            status: \"handed_off\",\n            worker_id: handoff.workerId\n          },\n          job\n        })\n      }\n\n      return await this._markOrphanSelections({db, error, selections})\n    })\n  }\n\n  /**\n   * Runs mark failed.\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {ReturnType<typeof JSON.parse>} args.error - Error.\n   * @param {string} [args.handoffId] - Handoff lease id.\n   * @param {string} [args.workerId] - Worker id.\n   * @param {number} [args.handedOffAtMs] - Handed off timestamp.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Updated job row when the report was accepted.\n   */\n  async markFailed({jobId, error, handoffId, workerId, handedOffAtMs}) {\n    await this.ensureReady()\n\n    return await this._serializedCountMutation(async (db) => {\n      const job = await this._getJobRowById(db, jobId)\n\n      if (!job) return null\n      if (!this._shouldAcceptReport({job, handoffId, workerId, handedOffAtMs})) return null\n\n      const updatedJob = await this._applyFailure({db, job, error, markOrphaned: false})\n\n      if (updatedJob) await this._recordStatusTransition(db, job.status, updatedJob.status)\n      return updatedJob\n    })\n  }\n\n  /**\n   * Runs mark orphaned jobs.\n   * @param {object} [args] - Options.\n   * @param {number} [args.orphanedAfterMs] - Mark jobs orphaned after this duration.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow[]>} - The jobs this sweep marked orphaned.\n   */\n  async markOrphanedJobs({orphanedAfterMs = ORPHANED_AFTER_MS} = {}) {\n    await this.ensureReady()\n\n    return await this._serializedCountMutation(async (db) => {\n      const cutoff = this.clock.now() - orphanedAfterMs\n      const query = db\n        .newQuery()\n        .from(JOBS_TABLE)\n        .where({status: \"handed_off\"})\n        .where(`handed_off_at_ms <= ${db.quote(cutoff)}`)\n\n      const rows = await query.results()\n\n      /** @type {BackgroundJobOrphanSelection[]} */\n      const selections = []\n\n      for (const row of rows) {\n        const job = this._normalizeJobRow(row)\n\n        // Fence the reclaim on the exact handoff this sweep selected, using its\n        // `handed_off_at_ms` rather than its `handoff_id`. Two reasons:\n        //   1. Null-safe. Some rows have a null `handoff_id` (handed off by an\n        //      older velocious before handoff-id fencing). `{handoff_id: null}`\n        //      renders as `handoff_id = NULL`, which matches nothing, so those\n        //      rows would be stranded in `handed_off` forever.\n        //   2. Race-safe. If the row is returned to the queue and re-handed-off\n        //      between the SELECT above and this update, it gets a fresh\n        //      `handed_off_at_ms` (always \"now\"), so this stale cutoff-era\n        //      timestamp no longer matches and we won't fail/orphan — or\n        //      wrongly release the concurrency reservation of — that new lease.\n        // `handed_off_at_ms` is always set on a handed-off row (and the SELECT\n        // required it `<= cutoff`), so it is a reliable null-safe lease pin.\n        selections.push({\n          conditions: {id: job.id, status: \"handed_off\", handed_off_at_ms: job.handedOffAtMs},\n          job\n        })\n      }\n\n      return await this._markOrphanSelections({\n        db,\n        error: \"Job orphaned after timeout\",\n        selections\n      })\n    })\n  }\n\n  /**\n   * Applies the common fenced orphan transition and records one aggregate count\n   * delta for the accepted rows.\n   * @param {object} args - Options.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Transaction connection.\n   * @param {ReturnType<typeof JSON.parse>} args.error - Orphan reason.\n   * @param {BackgroundJobOrphanSelection[]} args.selections - Selected handoffs and exact fences.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow[]>} - Accepted transitions.\n   */\n  async _markOrphanSelections({db, error, selections}) {\n    /** @type {import(\"./types.js\").BackgroundJobRow[]} */\n    const orphanedJobs = []\n\n    for (const {conditions, job} of selections) {\n      const orphanedJob = await this._applyFailure({\n        conditions,\n        db,\n        error,\n        job,\n        markOrphaned: true\n      })\n\n      if (orphanedJob) orphanedJobs.push(orphanedJob)\n    }\n\n    const statusCounts = this._statusCounts(orphanedJobs)\n    const deltas = this._emptyCountBuckets()\n\n    for (const [status, count] of Object.entries(statusCounts)) {\n      deltas.handed_off -= count\n      deltas[status] += count\n    }\n    await this._recordCountDelta(db, deltas)\n\n    return orphanedJobs\n  }\n\n  /**\n   * Deletes terminal job rows past their retention window so the jobs table\n   * does not grow unbounded (completed rows in particular accumulate forever\n   * otherwise). Batched by id — SELECT a page of ids, then\n   * `DELETE ... WHERE id IN (...)` — rather than `DELETE ... LIMIT`, which not\n   * every driver supports; each batch runs on its own connection so the sweep\n   * yields between batches instead of holding one long transaction.\n   * @param {object} [args] - Options.\n   * @param {number | null} [args.completedTtlMs] - Delete `completed` jobs whose `completed_at_ms` is older than this many ms. Falsy or `<= 0` disables completed pruning.\n   * @param {number | null} [args.failedTtlMs] - Delete terminal `failed`/`orphaned` jobs older than this many ms (by `failed_at_ms`/`orphaned_at_ms`). Falsy or `<= 0` disables.\n   * @param {number} [args.batchSize] - Max rows deleted per batch. Default `1000`.\n   * @returns {Promise<number>} - Total rows deleted.\n   */\n  async pruneTerminalJobs({completedTtlMs = null, failedTtlMs = null, batchSize = 1000} = {}) {\n    await this.ensureReady()\n\n    const now = this.clock.now()\n    const size = batchSize > 0 ? batchSize : 1000\n    let deleted = 0\n\n    if (completedTtlMs && completedTtlMs > 0) {\n      deleted += await this._pruneStatusBatches({status: \"completed\", column: \"completed_at_ms\", cutoff: now - completedTtlMs, batchSize: size})\n    }\n\n    if (failedTtlMs && failedTtlMs > 0) {\n      deleted += await this._pruneStatusBatches({status: \"failed\", column: \"failed_at_ms\", cutoff: now - failedTtlMs, batchSize: size})\n      deleted += await this._pruneStatusBatches({status: \"orphaned\", column: \"orphaned_at_ms\", cutoff: now - failedTtlMs, batchSize: size})\n    }\n\n    return deleted\n  }\n\n  /**\n   * Deletes rows of one terminal status older than a cutoff, batch by batch,\n   * until a page returns fewer than `batchSize` rows.\n   * @param {object} args - Options.\n   * @param {string} args.status - Terminal status to prune.\n   * @param {string} args.column - Timestamp column compared against the cutoff.\n   * @param {number} args.cutoff - Delete rows whose column value is `<= cutoff`.\n   * @param {number} args.batchSize - Max rows per batch.\n   * @returns {Promise<number>} - Rows deleted for this status.\n   */\n  async _pruneStatusBatches({status, column, cutoff, batchSize}) {\n    let deleted = 0\n\n    for (;;) {\n      const removed = await this._serializedCountMutation(async (db) => {\n        const rows = await db\n          .newQuery()\n          .from(JOBS_TABLE)\n          .select(\"id\")\n          .where({status})\n          .where(`${db.quoteColumn(column)} <= ${db.quote(cutoff)}`)\n          .limit(batchSize)\n          .results()\n\n        if (rows.length === 0) return 0\n\n        const ids = rows.map((/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ row) => db.quote(String(row.id))).join(\", \")\n\n        const removed = await db.affectedRows(\n          `DELETE FROM ${db.quoteTable(JOBS_TABLE)} WHERE ${db.quoteColumn(\"id\")} IN (${ids})`\n        )\n\n        await this._recordCountDelta(db, {all: -removed, [status]: -removed})\n\n        return removed\n      })\n\n      deleted += removed\n      if (removed < batchSize) break\n    }\n\n    return deleted\n  }\n\n  /**\n   * Runs clear all.\n   * @returns {Promise<void>} - Resolves when cleared.\n   */\n  async clearAll() {\n    await this.ensureReady()\n\n    await this._serializedCountMutation(async (db) => {\n      const snapshot = await this._countSnapshotOnLockedConnection(db)\n      if (await db.tableExists(MAIL_DELIVERY_OPERATIONS_TABLE)) await db.query(`DELETE FROM ${db.quoteTable(MAIL_DELIVERY_OPERATIONS_TABLE)}`)\n      if (await db.tableExists(IDEMPOTENCY_KEYS_TABLE)) await db.query(`DELETE FROM ${db.quoteTable(IDEMPOTENCY_KEYS_TABLE)}`)\n      if (await db.tableExists(SCHEDULE_KEYS_TABLE)) await db.query(`DELETE FROM ${db.quoteTable(SCHEDULE_KEYS_TABLE)}`)\n      await db.query(`DELETE FROM ${db.quoteTable(JOBS_TABLE)}`)\n      if (await db.tableExists(CONCURRENCY_TABLE)) await db.query(`DELETE FROM ${db.quoteTable(CONCURRENCY_TABLE)}`)\n      const deltas = Object.fromEntries(Object.entries(snapshot.counts).map(([key, value]) => [key, -value]))\n      await this._recordCountDelta(db, deltas)\n    })\n  }\n\n  /**\n   * Cancels a queued or handed-off job and releases any durable concurrency reservation.\n   * @param {string} jobId - Job id.\n   * @returns {Promise<boolean>} - Whether the job was cancelled.\n   */\n  async cancel(jobId) {\n    await this.ensureReady()\n    return await this._serializedCountMutation(async (db) => {\n      const job = await this._getJobRowById(db, jobId)\n      if (!job || (job.status !== \"queued\" && job.status !== \"handed_off\")) return false\n      // Only a handed_off job holds a concurrency reservation, so only that case touches the\n      // shared counter row and needs the concurrency-then-job lock ordering.\n      if (job.status === \"handed_off\") await this._lockConcurrencyRow(db, job.concurrencyKey)\n      const affectedRows = await this._updateAffectedRows(db, {tableName: JOBS_TABLE, data: {status: \"cancelled\"}, conditions: {id: job.id, status: job.status}})\n      if (affectedRows !== 1) return false\n      await this._releaseScheduleOwnershipForJob(db, job)\n      if (job.status === \"handed_off\") await this._releaseConcurrency(db, job.concurrencyKey)\n      await this._recordStatusTransition(db, job.status, \"cancelled\")\n      return true\n    })\n  }\n\n  /**\n   * Runs get retry delay ms.\n   * @param {number} retryCount - Retry attempt count (1-based).\n   * @returns {number} - Delay in milliseconds.\n   */\n  getRetryDelayMs(retryCount) {\n    return retryDelayMs(retryCount)\n  }\n\n  /**\n   * Normalizes one new job before entering its persistence transaction.\n   * @param {object} args - Job input.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job arguments.\n   * @param {string} args.jobName - Job name.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @returns {PreparedBackgroundJob} - Prepared job.\n   */\n  _prepareJob({args, jobName, options}) {\n    const createdAtMs = this.clock.now()\n    const queue = this._normalizeQueue(options)\n\n    return {\n      argsJson: JSON.stringify(args || []),\n      concurrency: this._resolveConcurrency(options, queue),\n      createdAtMs,\n      executionMode: this._normalizeExecutionMode(options),\n      jobId: randomUUID(),\n      jobName,\n      maxRetries: this._normalizeMaxRetries(options?.maxRetries),\n      queue,\n      scheduledAtMs: this._normalizeScheduledAtMs(options?.scheduledAtMs, createdAtMs),\n      timeoutMs: this._normalizeJobTimeoutMs(options)\n    }\n  }\n\n  /**\n   * Normalizes a per-job timeout while preserving omitted (worker fallback)\n   * separately from explicitly disabled.\n   * @param {import(\"./types.js\").BackgroundJobOptions | undefined} options - Job options.\n   * @returns {number | null} - Positive timeout, zero for disabled, or null when omitted.\n   */\n  _normalizeJobTimeoutMs(options) {\n    if (options?.timeoutMs === undefined) return null\n\n    const timeoutMs = options.timeoutMs\n\n    if (typeof timeoutMs !== \"number\" || !Number.isFinite(timeoutMs)) {\n      throw VelociousError.safe(JOB_TIMEOUT_VALIDATION_MESSAGE)\n    }\n\n    if (timeoutMs <= 0) return 0\n\n    if (!Number.isInteger(timeoutMs) || timeoutMs > MAX_JOB_TIMEOUT_MS) {\n      throw VelociousError.safe(JOB_TIMEOUT_VALIDATION_MESSAGE)\n    }\n\n    return timeoutMs\n  }\n\n  /**\n   * Inserts one prepared queued job, including its concurrency registration.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {object} args - Insert input.\n   * @param {PreparedBackgroundJob} args.preparedJob - Prepared job.\n   * @param {string | null} args.scheduleKey - Historical stable key.\n   * @returns {Promise<void>} - Resolves after insertion.\n   */\n  async _insertPreparedJob(db, {preparedJob, scheduleKey}) {\n    const {concurrency} = preparedJob\n\n    if (concurrency) {\n      if (concurrency.queueDerived) {\n        await this._ensureQueueConcurrencyKey(db, concurrency)\n      } else {\n        await this._ensureConcurrencyKey(db, concurrency)\n      }\n    }\n\n    await db.insert({\n      tableName: JOBS_TABLE,\n      data: {\n        id: preparedJob.jobId,\n        job_name: preparedJob.jobName,\n        args_json: preparedJob.argsJson,\n        execution_mode: preparedJob.executionMode,\n        queue: preparedJob.queue,\n        max_retries: preparedJob.maxRetries,\n        attempts: 0,\n        status: \"queued\",\n        scheduled_at_ms: preparedJob.scheduledAtMs,\n        created_at_ms: preparedJob.createdAtMs,\n        schedule_key: scheduleKey,\n        concurrency_key: concurrency?.concurrencyKey || null,\n        max_concurrency: concurrency?.maxConcurrency || null,\n        timeout_ms: preparedJob.timeoutMs,\n        handoff_id: null\n      }\n    })\n  }\n\n  /**\n   * Runs normalize max retries.\n   * @param {number | null | undefined} maxRetries - Input.\n   * @returns {number} - Normalized max retries.\n   */\n  _normalizeMaxRetries(maxRetries) {\n    return normalizeBackgroundJobMaxRetries(maxRetries)\n  }\n\n  /**\n   * Runs normalize scheduled at ms.\n   * @param {number | undefined} scheduledAtMs - Requested dispatch timestamp.\n   * @param {number} defaultScheduledAtMs - Default dispatch timestamp.\n   * @returns {number} - Dispatch timestamp.\n   */\n  _normalizeScheduledAtMs(scheduledAtMs, defaultScheduledAtMs) {\n    return normalizeBackgroundJobScheduledAtMs(scheduledAtMs, defaultScheduledAtMs)\n  }\n\n  /**\n   * Resolves a reschedule delay against persistence time.\n   * @param {number} delayMs - Delay in milliseconds.\n   * @returns {number} - Future eligibility timestamp.\n   */\n  _rescheduledAtMs(delayMs) {\n    return rescheduledBackgroundJobAtMs(delayMs, this.clock.now())\n  }\n\n  /**\n   * Validates a public reschedule delay before persistence work begins.\n   * @param {number} delayMs - Delay in milliseconds.\n   * @returns {void}\n   */\n  _validateRescheduleDelayMs(delayMs) {\n    rescheduledBackgroundJobAtMs(delayMs, 0)\n  }\n\n  /**\n   * Validates a stable schedule key at the public storage boundary.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @returns {string} - Validated key.\n   */\n  _normalizeScheduleKey(scheduleKey) {\n    if (typeof scheduleKey === \"string\" && scheduleKey.length > 0 && scheduleKey.length <= 255) return scheduleKey\n\n    throw VelociousError.safe(\"background job scheduleKey must be a non-empty string of at most 255 characters\")\n  }\n\n  /**\n   * Builds a bounded advisory-lock name for one stable schedule key.\n   * @param {string} scheduleKey - Validated stable schedule key.\n   * @returns {string} - Advisory-lock name.\n   */\n  _scheduleKeyLockName(scheduleKey) {\n    const hash = createHash(\"sha256\").update(scheduleKey).digest(\"hex\").slice(0, 32)\n\n    return `background-jobs:schedule:${hash}`\n  }\n\n  /**\n   * Ensures the background-jobs schema exists, reusing a caller-held connection when\n   * one is given rather than checking out its own.\n   * @param {import(\"../database/drivers/base.js\").default} [existingDb] - Reuse an\n   *   already-checked-out connection (e.g. the one `db:migrate` holds) instead of\n   *   checking out a nested one — the nested checkout would deadlock a database\n   *   whose pool is capped at a single connection already held by the caller.\n   * @returns {Promise<void>} - Resolves when the schema is present.\n   */\n  async _ensureSchema(existingDb) {\n    await this._applySchema(existingDb)\n  }\n\n  /**\n   * Serializes creation or upgrade of the background-jobs schema, checking out a\n   * connection only after earlier schema work has completed when one is not supplied.\n   * @param {import(\"../database/drivers/base.js\").default} [existingDb] - Caller-owned\n   *   database connection.\n   * @returns {Promise<void>} - Resolves when the schema is present.\n   */\n  async _applySchema(existingDb) {\n    // Serialize concurrent schema applies within this process, keyed by database\n    // identifier (see `schemaApplyChains`). The per-step locks inside the steps use\n    // DIFFERENT lock names, so two concurrent callers could otherwise each hold a\n    // different step lock while both rebuild the jobs table — and on SQLite/MSSQL an\n    // add-column is a create-copy-drop-rename rebuild, so overlapping rebuilds\n    // corrupt it. This mutex makes the whole apply mutually exclusive per process;\n    // the second caller then re-checks and finds every step already done.\n    const identifier = this.getDatabaseIdentifier() ?? \"default\"\n    const previous = schemaApplyChains.get(identifier) ?? Promise.resolve()\n    const applyWithConnection = async () => {\n      if (existingDb) {\n        await this._applySchemaSteps(existingDb)\n\n        return\n      }\n\n      await this._withDb((db) => this._applySchemaSteps(db))\n    }\n    const run = previous.then(applyWithConnection, applyWithConnection)\n\n    // Keep the chain alive regardless of this run's outcome so one failed apply does\n    // not wedge later callers; this run still propagates its own result/error.\n    schemaApplyChains.set(identifier, run.then(() => {}, () => {}))\n\n    return await run\n  }\n\n  /**\n   * Creates or upgrades the background-jobs tables, columns and concurrency rows on\n   * the given connection. Serialized per process by {@link BackgroundJobsStore#_applySchema}.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when the schema is present.\n   */\n  async _applySchemaSteps(db) {\n    await this._ensureMigrationsTable(db)\n\n    const alreadyApplied = await this._hasMigration(db)\n    const schemaRecoveryPending = await this._hasMigration(db, SCHEMA_RECOVERY_PENDING_VERSION)\n    const jobsTableExists = await db.tableExists(JOBS_TABLE)\n\n    // Even when the migration row is present, the jobs table itself can have\n    // been dropped underneath us by a transaction rollback in another caller\n    // (DDL is transactional on SQLite/MSSQL). Verify the table physically\n    // exists and recreate it when missing rather than trusting the migration\n    // row alone, otherwise later callers fail with \"no such table\".\n    if (alreadyApplied && jobsTableExists && !schemaRecoveryPending) {\n      await this._ensureJobsTableColumns(db)\n      await this._ensureIdempotencyKeysTable(db)\n      await this._ensureMailDeliveryOperationsTable(db)\n      await this._ensureScheduleKeysTable(db)\n      await this._ensureConcurrencyTable(db)\n      await this._ensureCountRevisionTable(db)\n\n      return\n    }\n\n    if (alreadyApplied && !schemaRecoveryPending) {\n      await this._recordMigration(db, SCHEMA_RECOVERY_PENDING_VERSION)\n    }\n\n    await this._applyMigrations(db)\n    await this._ensureJobsTableColumns(db)\n    await this._ensureIdempotencyKeysTable(db)\n    await this._ensureMailDeliveryOperationsTable(db)\n    await this._ensureScheduleKeysTable(db)\n    await this._ensureConcurrencyTable(db)\n    await this._ensureCountRevisionTable(db)\n\n    if (alreadyApplied) {\n      // The recreated jobs table is empty, but the surviving concurrency table\n      // can still count handoffs that disappeared with the dropped jobs table.\n      await this._reconcileConcurrency(db)\n      await db.delete({\n        tableName: MIGRATIONS_TABLE,\n        conditions: {key: this._migrationKey(SCHEMA_RECOVERY_PENDING_VERSION)}\n      })\n\n      return\n    }\n\n    await this._recordMigration(db, MIGRATION_VERSION)\n  }\n\n  /**\n   * Runs ensure migrations table.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _ensureMigrationsTable(db) {\n    if (await db.tableExists(MIGRATIONS_TABLE)) return\n\n    const table = new TableData(MIGRATIONS_TABLE, {ifNotExists: true})\n\n    table.string(\"key\", {null: false, primaryKey: true})\n    table.string(\"scope\", {null: false})\n    table.string(\"version\", {null: false})\n    table.bigint(\"applied_at_ms\", {null: false})\n\n    await db.createTable(table)\n  }\n\n  /**\n   * Runs has migration.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} [version] - Migration version.\n   * @returns {Promise<boolean>} - Whether migration exists.\n   */\n  async _hasMigration(db, version = MIGRATION_VERSION) {\n    const query = db\n      .newQuery()\n      .from(MIGRATIONS_TABLE)\n      .where({key: this._migrationKey(version)})\n      .limit(1)\n\n    const rows = await query.results()\n\n    return rows.length > 0\n  }\n\n  /**\n   * Runs apply migrations.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _applyMigrations(db) {\n    this.logger.info(\"Applying background jobs schema\")\n\n    if (await db.tableExists(JOBS_TABLE)) {\n      this.logger.info(\"Background jobs table already exists - skipping create\")\n      return\n    }\n\n    const table = new TableData(JOBS_TABLE, {ifNotExists: true})\n\n    table.string(\"id\", {primaryKey: true})\n    table.string(\"job_name\", {null: false, index: true})\n    table.text(\"args_json\", {null: false})\n    table.string(\"execution_mode\", {null: false})\n    table.string(\"queue\", {null: true, index: true})\n    table.integer(\"max_retries\", {null: false})\n    table.integer(\"attempts\", {null: false})\n    table.string(\"status\", {null: false, index: true})\n    table.bigint(\"scheduled_at_ms\", {null: false, index: true})\n    table.bigint(\"created_at_ms\", {null: false, index: true})\n    table.string(\"schedule_key\", {null: true, index: true})\n    table.bigint(\"handed_off_at_ms\", {null: true, index: true})\n    table.string(\"handoff_id\", {null: true})\n    table.bigint(\"completed_at_ms\", {null: true})\n    table.bigint(\"failed_at_ms\", {null: true})\n    table.bigint(\"orphaned_at_ms\", {null: true, index: true})\n    table.string(\"worker_id\", {null: true})\n    table.text(\"last_error\", {null: true})\n    table.string(\"concurrency_key\", {null: true, index: true})\n    table.integer(\"max_concurrency\", {null: true})\n    table.bigint(\"timeout_ms\", {null: true})\n    table.bigint(\"child_received_at_ms\", {null: true})\n    table.bigint(\"child_started_at_ms\", {null: true})\n    table.string(\"child_instance_id\", {null: true})\n    table.integer(\"child_pid\", {null: true})\n\n    await db.createTable(table)\n  }\n\n  /**\n   * Runs ensure jobs table columns.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _ensureJobsTableColumns(db) {\n    if (!(await db.tableExists(JOBS_TABLE))) return\n\n    const table = await db.getTableByNameOrFail(JOBS_TABLE)\n    const executionModeColumn = await table.getColumnByName(\"execution_mode\")\n\n    if (!executionModeColumn) {\n      const tableData = new TableData(JOBS_TABLE)\n      tableData.string(\"execution_mode\", {null: true})\n      const sqls = await db.alterTableSQLs(tableData)\n\n      for (const sql of sqls) {\n        await db.query(sql)\n      }\n\n      db.clearSchemaCache()\n    }\n\n    const refreshedTable = await db.getTableByNameOrFail(JOBS_TABLE)\n    const handoffIdColumn = await refreshedTable.getColumnByName(\"handoff_id\")\n\n    if (!handoffIdColumn) {\n      const lockName = `${MIGRATION_SCOPE}:handoff_id_column`\n      const acquired = await db.acquireAdvisoryLock(lockName)\n\n      if (!acquired) throw new Error(\"Failed to acquire background jobs handoff schema lock\")\n\n      try {\n        db.clearSchemaCache()\n        const lockedTable = await db.getTableByNameOrFail(JOBS_TABLE)\n\n        if (!(await lockedTable.getColumnByName(\"handoff_id\"))) {\n          const tableData = new TableData(JOBS_TABLE)\n          tableData.string(\"handoff_id\", {null: true})\n          const sqls = await db.alterTableSQLs(tableData)\n\n          for (const sql of sqls) {\n            await db.query(sql)\n          }\n\n          db.clearSchemaCache()\n        }\n      } finally {\n        await db.releaseAdvisoryLock(lockName)\n      }\n    }\n\n    await this._backfillExecutionModesOnce(db)\n    await this._dropForkedColumnOnce(db)\n\n    const lockName = `${MIGRATION_SCOPE}:concurrency_columns`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs concurrency schema lock\")\n\n    try {\n      // SQL Server schema reads can deadlock with a concurrent ALTER TABLE, so\n      // acquire the lock before inspecting either column rather than only\n      // protecting the mutation.\n      db.clearSchemaCache()\n      const lockedTable = await db.getTableByNameOrFail(JOBS_TABLE)\n      const concurrencyColumnNames = [\"concurrency_key\", \"max_concurrency\"]\n\n      for (const concurrencyColumnName of concurrencyColumnNames) {\n        if (await lockedTable.getColumnByName(concurrencyColumnName)) continue\n\n        const tableData = new TableData(JOBS_TABLE)\n        if (concurrencyColumnName == \"concurrency_key\") {\n          tableData.string(\"concurrency_key\", {null: true, index: true})\n        } else {\n          tableData.integer(\"max_concurrency\", {null: true})\n        }\n\n        for (const sql of await db.alterTableSQLs(tableData)) await db.query(sql)\n      }\n\n      db.clearSchemaCache()\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n\n    await this._ensureQueueColumn(db)\n    await this._ensureScheduleKeyColumn(db)\n    await this._ensureJobTimeoutColumn(db)\n    await this._ensureChildAcceptanceColumns(db)\n    await this._ensureJobsTableIndexesOnce(db)\n  }\n\n  /**\n   * Idempotently adds the pooled-child acceptance evidence columns to existing\n   * job tables. They record when the executing runner child received and\n   * started a job plus that child's identity, so a handed-off job can be told\n   * apart from one whose runner never picked it up.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ensured.\n   */\n  async _ensureChildAcceptanceColumns(db) {\n    const lockName = `${MIGRATION_SCOPE}:child_acceptance_columns`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs child-acceptance schema lock\")\n\n    try {\n      db.clearSchemaCache()\n      const table = await db.getTableByNameOrFail(JOBS_TABLE)\n      const tableData = new TableData(JOBS_TABLE)\n      let added = false\n\n      if (!(await table.getColumnByName(\"child_received_at_ms\"))) {\n        tableData.bigint(\"child_received_at_ms\", {null: true})\n        added = true\n      }\n      if (!(await table.getColumnByName(\"child_started_at_ms\"))) {\n        tableData.bigint(\"child_started_at_ms\", {null: true})\n        added = true\n      }\n      if (!(await table.getColumnByName(\"child_instance_id\"))) {\n        tableData.string(\"child_instance_id\", {null: true})\n        added = true\n      }\n      if (!(await table.getColumnByName(\"child_pid\"))) {\n        tableData.integer(\"child_pid\", {null: true})\n        added = true\n      }\n\n      if (added) {\n        for (const sql of await db.alterTableSQLs(tableData)) await db.query(sql)\n        db.clearSchemaCache()\n      }\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Repairs secondary indexes that older add-column upgrades declared but did\n   * not create on every SQL driver. The migration ledger keeps routine store\n   * readiness from repeatedly introspecting the full index set.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when all expected indexes exist.\n   */\n  async _ensureJobsTableIndexesOnce(db) {\n    const migrationVersion = JOBS_INDEX_REPAIR_MIGRATION_VERSION\n    const migrationKey = this._migrationKey(migrationVersion)\n\n    if (await this._hasMigration(db, migrationVersion)) return\n\n    const acquired = await db.acquireAdvisoryLock(migrationKey)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs index repair lock\")\n\n    try {\n      if (await this._hasMigration(db, migrationVersion)) return\n\n      db.clearSchemaCache()\n      const table = await db.getTableByNameOrFail(JOBS_TABLE)\n      const indexedColumnNames = new Set(\n        (await table.getIndexes())\n          .filter((index) => !index.isPrimaryKey() && index.getColumnNames().length === 1)\n          .map((index) => index.getColumnNames()[0])\n      )\n\n      for (const columnName of JOBS_INDEX_COLUMN_NAMES) {\n        if (indexedColumnNames.has(columnName)) continue\n\n        for (const sql of await db.createIndexSQLs({columns: [columnName], ifNotExists: db.getType() === \"sqlite\", tableName: JOBS_TABLE})) {\n          await db.query(sql)\n        }\n      }\n\n      db.clearSchemaCache()\n      await this._recordMigration(db, migrationVersion)\n    } finally {\n      await db.releaseAdvisoryLock(migrationKey)\n    }\n  }\n\n  /**\n   * Idempotently adds the per-job wall-clock timeout to existing job tables.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ensured.\n   */\n  async _ensureJobTimeoutColumn(db) {\n    const lockName = `${MIGRATION_SCOPE}:timeout_ms_column`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs timeout schema lock\")\n\n    try {\n      db.clearSchemaCache()\n      const table = await db.getTableByNameOrFail(JOBS_TABLE)\n\n      if (!(await table.getColumnByName(\"timeout_ms\"))) {\n        const tableData = new TableData(JOBS_TABLE)\n        tableData.bigint(\"timeout_ms\", {null: true})\n\n        for (const sql of await db.alterTableSQLs(tableData)) await db.query(sql)\n\n        db.clearSchemaCache()\n      }\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Idempotently adds the historical stable schedule key to existing jobs.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ensured.\n   */\n  async _ensureScheduleKeyColumn(db) {\n    const lockName = `${MIGRATION_SCOPE}:schedule_key_column`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs schedule-key schema lock\")\n\n    try {\n      db.clearSchemaCache()\n      const lockedTable = await db.getTableByNameOrFail(JOBS_TABLE)\n\n      if (!(await lockedTable.getColumnByName(\"schedule_key\"))) {\n        const tableData = new TableData(JOBS_TABLE)\n\n        tableData.string(\"schedule_key\", {null: true, index: true})\n\n        for (const sql of await db.alterTableSQLs(tableData)) await db.query(sql)\n\n        db.clearSchemaCache()\n      }\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Idempotently adds the `queue` column to an existing jobs table. Existing\n   * rows read back as the default queue (see {@link _normalizeJobRow}), so no\n   * data backfill is required.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ensured.\n   */\n  async _ensureQueueColumn(db) {\n    const lockName = `${MIGRATION_SCOPE}:queue_column`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs queue schema lock\")\n\n    try {\n      // SQL Server schema reads can deadlock with a concurrent ALTER TABLE, so\n      // acquire the lock before inspecting the column rather than only\n      // protecting the mutation (mirrors the concurrency-column migration).\n      db.clearSchemaCache()\n      const lockedTable = await db.getTableByNameOrFail(JOBS_TABLE)\n\n      if (!(await lockedTable.getColumnByName(\"queue\"))) {\n        const tableData = new TableData(JOBS_TABLE)\n\n        tableData.string(\"queue\", {null: true, index: true})\n\n        for (const sql of await db.alterTableSQLs(tableData)) await db.query(sql)\n\n        db.clearSchemaCache()\n      }\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Runs backfill execution modes once.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _backfillExecutionModesOnce(db) {\n    const migrationVersion = EXECUTION_MODE_BACKFILL_MIGRATION_VERSION\n    const migrationKey = this._migrationKey(migrationVersion)\n\n    if (await this._hasMigration(db, migrationVersion)) return\n\n    await db.acquireAdvisoryLock(migrationKey)\n\n    try {\n      if (await this._hasMigration(db, migrationVersion)) return\n\n      // A table created after the `forked` column was dropped has nothing to\n      // backfill from; record the migration so it is not re-attempted.\n      db.clearSchemaCache()\n      if (!(await (await db.getTableByNameOrFail(JOBS_TABLE)).getColumnByName(\"forked\"))) {\n        await this._recordMigration(db, migrationVersion)\n        return\n      }\n\n      const tableNameSql = db.quoteTable(JOBS_TABLE)\n      const forkedColumnSql = db.quoteColumn(\"forked\")\n      const executionModeColumnSql = db.quoteColumn(\"execution_mode\")\n\n      await db.query(\n        `UPDATE ${tableNameSql} SET ${executionModeColumnSql} = ${db.quote(\"forked\")} ` +\n        `WHERE ${forkedColumnSql} = ${db.quote(true)} AND ${executionModeColumnSql} IS NULL`\n      )\n      await db.query(\n        `UPDATE ${tableNameSql} SET ${executionModeColumnSql} = ${db.quote(\"inline\")} ` +\n        `WHERE ${forkedColumnSql} = ${db.quote(false)} AND ${executionModeColumnSql} IS NULL`\n      )\n\n      await this._recordMigration(db, migrationVersion)\n    } finally {\n      await db.releaseAdvisoryLock(migrationKey)\n    }\n  }\n\n  /**\n   * Rewrites pre-existing pooled rows (persisted as `execution_mode = \"forked\"`\n   * plus a `velocious-pooled:*` handoff marker) to `execution_mode = \"pooled\"`,\n   * clears the queued marker, then drops the now-redundant `forked` column so\n   * `execution_mode` is the single source of truth. Runs once, guarded by the\n   * migration ledger and a per-key advisory lock; a fresh table (created without\n   * the column) short-circuits.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _dropForkedColumnOnce(db) {\n    const migrationVersion = DROP_FORKED_COLUMN_MIGRATION_VERSION\n    const migrationKey = this._migrationKey(migrationVersion)\n\n    if (await this._hasMigration(db, migrationVersion)) return\n\n    await db.acquireAdvisoryLock(migrationKey)\n\n    try {\n      if (await this._hasMigration(db, migrationVersion)) return\n\n      db.clearSchemaCache()\n\n      if (await (await db.getTableByNameOrFail(JOBS_TABLE)).getColumnByName(\"forked\")) {\n        const tableNameSql = db.quoteTable(JOBS_TABLE)\n        const executionModeColumnSql = db.quoteColumn(\"execution_mode\")\n        const handoffIdColumnSql = db.quoteColumn(\"handoff_id\")\n\n        // Pooled rows used to persist as execution_mode \"forked\" + a pooled handoff\n        // marker; recover their real mode before the marker is cleared.\n        await db.query(\n          `UPDATE ${tableNameSql} SET ${executionModeColumnSql} = ${db.quote(\"pooled\")} ` +\n          `WHERE ${executionModeColumnSql} = ${db.quote(\"forked\")} ` +\n          `AND ${handoffIdColumnSql} LIKE ${db.quote(`${LEGACY_POOLED_HANDOFF_ID_PREFIX}%`)}`\n        )\n        // The queued-pooled marker was a sentinel, not a real lease; clear it.\n        await db.query(\n          `UPDATE ${tableNameSql} SET ${handoffIdColumnSql} = NULL ` +\n          `WHERE ${handoffIdColumnSql} = ${db.quote(LEGACY_POOLED_QUEUED_HANDOFF_ID)}`\n        )\n\n        const dropForked = new TableData(JOBS_TABLE)\n        dropForked.addColumn(\"forked\", {dropColumn: true})\n        for (const sql of await db.alterTableSQLs(dropForked)) await db.query(sql)\n\n        db.clearSchemaCache()\n      }\n\n      await this._recordMigration(db, migrationVersion)\n    } finally {\n      await db.releaseAdvisoryLock(migrationKey)\n    }\n  }\n\n  /**\n   * Runs record migration.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} version - Migration version.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _recordMigration(db, version) {\n    await db.upsert({\n      tableName: MIGRATIONS_TABLE,\n      data: {\n        key: this._migrationKey(version),\n        scope: MIGRATION_SCOPE,\n        version,\n        applied_at_ms: Date.now()\n      },\n      conflictColumns: [\"key\"],\n      updateColumns: [\"scope\", \"version\", \"applied_at_ms\"]\n    })\n  }\n\n  async _initializeModel() {\n    if (BackgroundJobRecord.isInitialized()) return\n\n    BackgroundJobRecord.setDatabaseIdentifier(this.getDatabaseIdentifier())\n    const pool = this.configuration.getDatabasePool(this.getDatabaseIdentifier())\n\n    await pool.withConnection({name: \"Background jobs store initialize model\"}, async () => {\n      await BackgroundJobRecord.initializeRecord({configuration: this.configuration})\n    })\n  }\n\n  /**\n   * Runs get job row by id.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} jobId - Job id.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Job row.\n   */\n  async _getJobRowById(db, jobId) {\n    const query = db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .where({id: jobId})\n      .limit(1)\n\n    const rows = await query.results()\n\n    if (!rows[0]) return null\n\n    return this._normalizeJobRow(rows[0])\n  }\n\n  /**\n   * Releases ownership only when the key still points at the expected job.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {object} args - Ownership identity.\n   * @param {string} args.jobId - Expected owner job id.\n   * @param {string} args.scheduleKey - Stable schedule key.\n   * @returns {Promise<void>} - Resolves when deleted or already superseded.\n   */\n  async _releaseScheduleOwnership(db, {jobId, scheduleKey}) {\n    await db.delete({\n      tableName: SCHEDULE_KEYS_TABLE,\n      conditions: {job_id: jobId, schedule_key: scheduleKey}\n    })\n  }\n\n  /**\n   * Releases a job's ownership when it has a historical schedule key.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {import(\"./types.js\").BackgroundJobRow} job - Terminal job.\n   * @returns {Promise<void>} - Resolves when deleted or not applicable.\n   */\n  async _releaseScheduleOwnershipForJob(db, job) {\n    if (!job.scheduleKey) return\n\n    await this._releaseScheduleOwnership(db, {jobId: job.id, scheduleKey: job.scheduleKey})\n  }\n\n  /**\n   * Runs apply failure.\n   * @param {object} args - Options.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Database connection.\n   * @param {import(\"./types.js\").BackgroundJobRow} args.job - Job row.\n   * @param {ReturnType<typeof JSON.parse>} args.error - Error.\n   * @param {boolean} args.markOrphaned - Whether marking orphaned.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} [args.conditions] - Update fencing conditions. Defaults to the active-handoff lease match; the time-based orphan sweep overrides this with an id/status match so it can reclaim rows whose `handoff_id` is null (e.g. handed off by an older velocious before handoff-id fencing existed).\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Updated job row when the lease transition won.\n   */\n  async _applyFailure({db, job, error, markOrphaned, conditions}) {\n    const now = this.clock.now()\n    const nextAttempt = (job.attempts || 0) + 1\n    const maxRetries = this._normalizeMaxRetries(job.maxRetries)\n    const shouldRetry = nextAttempt <= maxRetries\n    const failureMessage = normalizeBackgroundJobError(error)\n    const scheduledAt = shouldRetry ? now + this.getRetryDelayMs(nextAttempt) : job.scheduledAtMs\n    const update = this._failureUpdate({\n      failureMessage,\n      markOrphaned,\n      nextAttempt,\n      now,\n      scheduledAt,\n      shouldRetry\n    })\n\n    await this._lockConcurrencyRow(db, job.concurrencyKey)\n    const affectedRows = await this._updateAffectedRows(db, {\n      tableName: JOBS_TABLE,\n      data: update,\n      conditions: conditions ?? this._activeHandoffConditions(job)\n    })\n\n    if (affectedRows !== 1) return null\n    if (!shouldRetry) await this._releaseScheduleOwnershipForJob(db, job)\n    await this._releaseConcurrency(db, job.concurrencyKey)\n\n    // Return a snapshot of the transition this update just applied rather than re-reading the row.\n    // We won the conditional update (affectedRows === 1), so this state is authoritative; re-reading\n    // could instead observe a newer state if another dispatcher reclaims a requeued job between the\n    // update and the read (overlapping mains / polling dispatch), which would misreport the\n    // status/terminal/willRetry of this transition to failure/orphan event listeners.\n    const status = shouldRetry ? \"queued\" : (markOrphaned ? \"orphaned\" : \"failed\")\n    /** @type {import(\"./types.js\").BackgroundJobRow} */\n    const transitionedJob = {\n      ...job,\n      ...(shouldRetry ? this._clearedChildAcceptanceRow() : {}),\n      attempts: nextAttempt,\n      handedOffAtMs: null,\n      lastError: failureMessage,\n      status,\n      workerId: null\n    }\n\n    if (markOrphaned) transitionedJob.orphanedAtMs = now\n    if (shouldRetry) {\n      transitionedJob.scheduledAtMs = scheduledAt\n    } else if (!markOrphaned) {\n      transitionedJob.failedAtMs = now\n    }\n\n    return transitionedJob\n  }\n\n  /**\n   * Runs failure update.\n   * @param {object} args - Options.\n   * @param {string} args.failureMessage - Last failure message.\n   * @param {boolean} args.markOrphaned - Whether marking orphaned.\n   * @param {number} args.nextAttempt - Next attempt count.\n   * @param {number} args.now - Current timestamp.\n   * @param {number | null} args.scheduledAt - Next scheduled timestamp.\n   * @param {boolean} args.shouldRetry - Whether the job should retry.\n   * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Database update data.\n   */\n  _failureUpdate({failureMessage, markOrphaned, nextAttempt, now, scheduledAt, shouldRetry}) {\n    /**\n     * Update.\n     * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n    const update = {\n      attempts: nextAttempt,\n      handed_off_at_ms: null,\n      worker_id: null,\n      last_error: failureMessage\n    }\n\n    // A retry starts a fresh handoff with a possibly different runner, so the\n    // previous child's acceptance evidence must not leak into the next attempt.\n    // Terminal failures keep it as historical evidence for the lost attempt.\n    if (shouldRetry) Object.assign(update, this._clearedChildAcceptanceData())\n\n    this._applyOrphanedFailureUpdate({markOrphaned, now, update})\n    this._applyFailureStatusUpdate({markOrphaned, now, scheduledAt, shouldRetry, update})\n\n    return update\n  }\n\n  /**\n   * Runs apply orphaned failure update.\n   * @param {object} args - Options.\n   * @param {boolean} args.markOrphaned - Whether marking orphaned.\n   * @param {number} args.now - Current timestamp.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.update - Database update data.\n   * @returns {void}\n   */\n  _applyOrphanedFailureUpdate({markOrphaned, now, update}) {\n    if (markOrphaned) update.orphaned_at_ms = now\n  }\n\n  /**\n   * Runs apply failure status update.\n   * @param {object} args - Options.\n   * @param {boolean} args.markOrphaned - Whether marking orphaned.\n   * @param {number} args.now - Current timestamp.\n   * @param {number | null} args.scheduledAt - Next scheduled timestamp.\n   * @param {boolean} args.shouldRetry - Whether the job should retry.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.update - Database update data.\n   * @returns {void}\n   */\n  _applyFailureStatusUpdate({markOrphaned, now, scheduledAt, shouldRetry, update}) {\n    if (shouldRetry) {\n      update.status = \"queued\"\n      update.scheduled_at_ms = scheduledAt\n      return\n    }\n\n    if (markOrphaned) {\n      update.status = \"orphaned\"\n      return\n    }\n\n    update.status = \"failed\"\n    update.failed_at_ms = now\n  }\n\n  /**\n   * Runs normalize job row.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} row - Raw database row.\n   * @returns {import(\"./types.js\").BackgroundJobRow} - Normalized job row.\n   */\n  _normalizeJobRow(row) {\n    const handoffId = row.handoff_id ? String(row.handoff_id) : null\n    // `execution_mode` is the single source of truth for a job's runtime and is\n    // written on every enqueue; the drop-forked migration backfills any pre-existing\n    // rows before the legacy `forked` column is removed.\n    const executionMode = row.execution_mode ? this._normalizeExecutionModeName(String(row.execution_mode)) : DEFAULT_BACKGROUND_JOB_EXECUTION_MODE\n\n    return {\n      id: String(row.id),\n      jobName: String(row.job_name),\n      args: this._parseArgs(row.args_json),\n      executionMode,\n      queue: row.queue ? String(row.queue) : DEFAULT_BACKGROUND_JOB_QUEUE,\n      scheduleKey: row.schedule_key ? String(row.schedule_key) : null,\n      status: row.status ? String(row.status) : \"queued\",\n      attempts: this._normalizeNumber(row.attempts),\n      maxRetries: this._normalizeNumber(row.max_retries),\n      scheduledAtMs: this._normalizeNumber(row.scheduled_at_ms),\n      createdAtMs: this._normalizeNumber(row.created_at_ms),\n      handedOffAtMs: this._normalizeNumber(row.handed_off_at_ms),\n      handoffId,\n      completedAtMs: this._normalizeNumber(row.completed_at_ms),\n      failedAtMs: this._normalizeNumber(row.failed_at_ms),\n      orphanedAtMs: this._normalizeNumber(row.orphaned_at_ms),\n      workerId: row.worker_id ? String(row.worker_id) : null,\n      lastError: row.last_error ? String(row.last_error) : null,\n      concurrencyKey: row.concurrency_key ? String(row.concurrency_key) : null,\n      maxConcurrency: this._normalizeNumber(row.max_concurrency),\n      timeoutMs: this._normalizeNumber(row.timeout_ms),\n      childReceivedAtMs: this._normalizeNumber(row.child_received_at_ms),\n      childStartedAtMs: this._normalizeNumber(row.child_started_at_ms),\n      childInstanceId: row.child_instance_id ? String(row.child_instance_id) : null,\n      childPid: this._normalizeNumber(row.child_pid)\n    }\n  }\n\n  /**\n   * Normalizes a job's queue name, defaulting to \"default\".\n   * @param {import(\"./types.js\").BackgroundJobOptions | undefined} options - Job options.\n   * @returns {string} - Queue name.\n   */\n  _normalizeQueue(options) {\n    return normalizeBackgroundJobQueue(options)\n  }\n\n  /**\n   * Resolves a job's durable concurrency. An explicit concurrencyKey/maxConcurrency\n   * pair always wins. Otherwise, when the job's queue has a configured cap\n   * (`backgroundJobs.queues[queue].maxConcurrent`), derive a queue-scoped\n   * concurrency key so the queue cap is enforced cluster-wide through the\n   * existing durable concurrency mechanism.\n   * @param {import(\"./types.js\").BackgroundJobOptions | undefined} options - Job options.\n   * @param {string} queue - Normalized queue name.\n   * @returns {{concurrencyKey: string, maxConcurrency: number, queueDerived: boolean} | null} - Resolved concurrency.\n   */\n  _resolveConcurrency(options, queue) {\n    return normalizeBackgroundJobConcurrency({\n      options: options || {},\n      queue,\n      queues: this.configuration.getBackgroundJobsConfig().queues\n    })\n  }\n\n  /**\n   * Applies the active generation's queue policy immediately before handoff.\n   * Explicit concurrency remains owned by the enqueue request.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {import(\"./types.js\").BackgroundJobRow} job - Queued job snapshot.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Reconciled job, or null when its queued-state fence lost.\n   */\n  async _reconcileQueuedJobConcurrency(db, job) {\n    if (job.concurrencyKey && !job.concurrencyKey.startsWith(QUEUE_CONCURRENCY_KEY_PREFIX)) {\n      return job\n    }\n\n    const concurrency = this._resolveConcurrency({}, job.queue)\n    /** @type {BackgroundJobQueuedConcurrency} */\n    const current = concurrency\n      ? {concurrencyKey: concurrency.concurrencyKey, maxConcurrency: concurrency.maxConcurrency}\n      : {concurrencyKey: null, maxConcurrency: null}\n\n    if (concurrency) await this._ensureQueueConcurrencyKey(db, concurrency)\n    if (job.concurrencyKey === current.concurrencyKey && job.maxConcurrency === current.maxConcurrency) return job\n\n    const affectedRows = await this._updateAffectedRows(db, {\n      tableName: JOBS_TABLE,\n      data: {\n        concurrency_key: current.concurrencyKey,\n        max_concurrency: current.maxConcurrency\n      },\n      conditions: {concurrency_key: job.concurrencyKey, id: job.id, status: \"queued\"}\n    })\n\n    if (affectedRows !== 1) return null\n\n    return {...job, concurrencyKey: current.concurrencyKey, maxConcurrency: current.maxConcurrency}\n  }\n\n  /**\n   * Reads the configured max concurrency for a queue from the background-jobs config.\n   * @param {string} queue - Queue name.\n   * @returns {number | null} - Positive integer cap, or null when the queue has no configured cap.\n   */\n  _queueMaxConcurrency(queue) {\n    const queues = this.configuration.getBackgroundJobsConfig().queues\n    const cap = queues?.[queue]?.maxConcurrent\n\n    if (Number.isInteger(cap) && Number(cap) > 0) return Number(cap)\n\n    return null\n  }\n\n  /**\n   * Like {@link _ensureConcurrencyKey}, but for queue-derived keys the configured\n   * queue cap is the source of truth: if it changed, update the stored cap\n   * instead of throwing on conflict (config-driven caps must be tunable).\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {{concurrencyKey: string, maxConcurrency: number}} concurrency - Concurrency configuration.\n   * @returns {Promise<void>} - Resolves when ensured.\n   */\n  async _ensureQueueConcurrencyKey(db, {concurrencyKey, maxConcurrency}) {\n    const rows = await db.newQuery().from(CONCURRENCY_TABLE).where({concurrency_key: concurrencyKey}).limit(1).results()\n\n    if (!rows[0]) {\n      try {\n        await db.insert({tableName: CONCURRENCY_TABLE, data: {active_count: 0, concurrency_key: concurrencyKey, max_concurrency: maxConcurrency}})\n\n        return\n      } catch (error) {\n        const racedRows = await db.newQuery().from(CONCURRENCY_TABLE).where({concurrency_key: concurrencyKey}).limit(1).results()\n\n        if (!racedRows[0]) throw error\n\n        rows[0] = racedRows[0]\n      }\n    }\n\n    const configured = /** @type {{max_concurrency?: number | string}} */ (rows[0])\n\n    if (this._normalizeNumber(configured.max_concurrency) !== maxConcurrency) {\n      const table = db.quoteTable(CONCURRENCY_TABLE)\n\n      await db.query(`UPDATE ${table} SET ${db.quoteColumn(\"max_concurrency\")} = ${Number(maxConcurrency)} WHERE ${db.quoteColumn(\"concurrency_key\")} = ${db.quote(concurrencyKey)}`)\n    }\n  }\n\n  /**\n   * Ensures the concurrency state table exists.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ready.\n   */\n  async _ensureConcurrencyTable(db) {\n    if (await db.tableExists(CONCURRENCY_TABLE)) return\n    const table = new TableData(CONCURRENCY_TABLE, {ifNotExists: true})\n    table.string(\"concurrency_key\", {primaryKey: true})\n    table.integer(\"max_concurrency\", {null: false})\n    table.integer(\"active_count\", {null: false})\n    await db.createTable(table)\n  }\n\n  /**\n   * Ensures the stable schedule-key ownership table exists.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ready.\n   */\n  async _ensureScheduleKeysTable(db) {\n    if (await db.tableExists(SCHEDULE_KEYS_TABLE)) return\n\n    const lockName = `${MIGRATION_SCOPE}:schedule_keys_table`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs schedule-key table schema lock\")\n\n    try {\n      db.clearSchemaCache()\n      if (await db.tableExists(SCHEDULE_KEYS_TABLE)) return\n\n      const table = new TableData(SCHEDULE_KEYS_TABLE, {ifNotExists: true})\n\n      table.string(\"schedule_key\", {primaryKey: true})\n      table.string(\"job_id\", {null: false, index: true})\n      await db.createTable(table)\n      db.clearSchemaCache()\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Ensures durable generic enqueue ownership exists independently of job rows.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ready.\n   */\n  async _ensureIdempotencyKeysTable(db) {\n    if (await db.tableExists(IDEMPOTENCY_KEYS_TABLE)) return\n\n    const lockName = `${MIGRATION_SCOPE}:idempotency_keys_table`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background job idempotency-key table schema lock\")\n\n    try {\n      db.clearSchemaCache()\n      if (await db.tableExists(IDEMPOTENCY_KEYS_TABLE)) return\n\n      const table = new TableData(IDEMPOTENCY_KEYS_TABLE, {ifNotExists: true})\n\n      table.string(\"scope_digest\", {primaryKey: true})\n      table.string(\"job_name\", {null: false})\n      table.string(\"queue\", {null: false})\n      table.text(\"idempotency_key\", {null: false})\n      table.string(\"job_id\", {index: true, null: false})\n      table.string(\"request_digest\", {null: false})\n      table.bigint(\"created_at_ms\", {null: false})\n      await db.createTable(table)\n      db.clearSchemaCache()\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Ensures durable provider-backed mail operation state exists independently of jobs.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ready.\n   */\n  async _ensureMailDeliveryOperationsTable(db) {\n    if (await db.tableExists(MAIL_DELIVERY_OPERATIONS_TABLE)) return\n\n    const lockName = `${MIGRATION_SCOPE}:mail_delivery_operations_table`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire mail delivery operation table schema lock\")\n\n    try {\n      db.clearSchemaCache()\n      if (await db.tableExists(MAIL_DELIVERY_OPERATIONS_TABLE)) return\n\n      const table = new TableData(MAIL_DELIVERY_OPERATIONS_TABLE, {ifNotExists: true})\n\n      table.string(\"operation_key\", {primaryKey: true})\n      table.text(\"operation_id\", {null: false})\n      table.string(\"payload_digest\", {null: false})\n      table.string(\"background_job_id\", {index: true, null: false})\n      table.bigint(\"first_attempt_started_at_ms\", {null: true})\n      table.string(\"provider_kind\", {null: false})\n      table.bigint(\"provider_retention_ms\", {null: false})\n      table.bigint(\"created_at_ms\", {null: false})\n      await db.createTable(table)\n      db.clearSchemaCache()\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Ensures the singleton durable count-revision row exists.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} Resolves when ready.\n   */\n  async _ensureCountRevisionTable(db) {\n    if (!(await db.tableExists(COUNTS_REVISION_TABLE))) {\n      const table = new TableData(COUNTS_REVISION_TABLE, {ifNotExists: true})\n\n      table.string(\"key\", {primaryKey: true})\n      table.bigint(\"revision\", {null: false})\n      await db.createTable(table)\n    }\n\n    const rows = await db.newQuery().from(COUNTS_REVISION_TABLE).where({key: COUNTS_REVISION_KEY}).limit(1).results()\n\n    if (rows.length > 0) return\n\n    try {\n      await db.insert({tableName: COUNTS_REVISION_TABLE, data: {key: COUNTS_REVISION_KEY, revision: 0}})\n    } catch (error) {\n      const racedRows = await db.newQuery().from(COUNTS_REVISION_TABLE).where({key: COUNTS_REVISION_KEY}).limit(1).results()\n\n      if (racedRows.length === 0) throw error\n    }\n  }\n\n  /**\n   * Records one logical count mutation atomically and broadcasts it after commit.\n   * Zero entries are omitted; a wholly zero-net mutation does not consume a revision.\n   * @param {import(\"../database/drivers/base.js\").default} db - Transaction connection.\n   * @param {Record<string, number>} requestedDeltas - Signed bucket changes.\n   * @returns {Promise<void>} Resolves when recorded.\n   */\n  async _recordCountDelta(db, requestedDeltas) {\n    /** @type {Record<string, number>} */\n    const deltas = {}\n\n    for (const bucket of BACKGROUND_JOB_COUNT_BUCKETS) {\n      const amount = requestedDeltas[bucket] || 0\n\n      if (!Number.isInteger(amount)) throw new Error(`Invalid background job count delta for ${bucket}: ${amount}`)\n      if (amount !== 0) deltas[bucket] = amount\n    }\n\n    if (Object.keys(deltas).length === 0) return\n\n    const table = db.quoteTable(COUNTS_REVISION_TABLE)\n    const revisionColumn = db.quoteColumn(\"revision\")\n    const affectedRows = await db.affectedRows(\n      `UPDATE ${table} SET ${revisionColumn} = ${revisionColumn} + 1 WHERE ${db.quoteColumn(\"key\")} = ${db.quote(COUNTS_REVISION_KEY)}`\n    )\n\n    if (affectedRows !== 1) throw new Error(\"Background job count revision row is missing\")\n\n    const revision = await this._countRevision(db)\n    const body = {deltas, revision, type: \"background-job-count-delta\"}\n    const databaseIdentifier = this.getDatabaseIdentifier() || \"default\"\n\n    await db.afterCommit(() => {\n      this.configuration.broadcastToChannel(BACKGROUND_JOB_COUNTS_CHANNEL, {databaseIdentifier}, body)\n    })\n  }\n\n  /**\n   * Records a transition between persisted statuses.\n   * @param {import(\"../database/drivers/base.js\").default} db - Transaction connection.\n   * @param {string} oldStatus - Previous status.\n   * @param {string} newStatus - New status.\n   * @returns {Promise<void>} Resolves when recorded.\n   */\n  async _recordStatusTransition(db, oldStatus, newStatus) {\n    const oldCounted = COUNTED_JOB_STATUSES.includes(oldStatus)\n    const newCounted = COUNTED_JOB_STATUSES.includes(newStatus)\n\n    if (!oldCounted && oldStatus !== \"cancelled\") throw new Error(`Unknown previous background job status: ${oldStatus}`)\n    if (!newCounted && newStatus !== \"cancelled\") throw new Error(`Unknown next background job status: ${newStatus}`)\n    if (oldStatus === newStatus) return\n\n    /** @type {Record<string, number>} */\n    const deltas = {}\n\n    if (oldCounted) deltas[oldStatus] = -1\n    if (newCounted) deltas[newStatus] = 1\n    if (oldCounted !== newCounted) deltas.all = newCounted ? 1 : -1\n    await this._recordCountDelta(db, deltas)\n  }\n\n  /**\n   * Reads the locked revision.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<number>} Revision.\n   */\n  async _countRevision(db) {\n    const rows = await db.newQuery().from(COUNTS_REVISION_TABLE).select(\"revision\").where({key: COUNTS_REVISION_KEY}).limit(1).results()\n    const revision = this._normalizeNumber(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (rows[0] || {}).revision)\n\n    if (revision === null || !Number.isSafeInteger(revision) || revision < 0) {\n      throw new Error(`Invalid background job count revision: ${revision}`)\n    }\n\n    return revision\n  }\n\n  /**\n   * Takes a portable write lock on the singleton revision row.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} Resolves when locked.\n   */\n  async _lockCountRevision(db) {\n    const table = db.quoteTable(COUNTS_REVISION_TABLE)\n    const revision = db.quoteColumn(\"revision\")\n\n    await db.query(`UPDATE ${table} SET ${revision} = ${revision} WHERE ${db.quoteColumn(\"key\")} = ${db.quote(COUNTS_REVISION_KEY)}`)\n  }\n\n  /**\n   * Builds zeroed canonical buckets.\n   * @returns {Record<string, number>} Zeroed canonical buckets.\n   */\n  _emptyCountBuckets() {\n    return Object.fromEntries(BACKGROUND_JOB_COUNT_BUCKETS.map((bucket) => [bucket, 0]))\n  }\n\n  /**\n   * Counts normalized rows by canonical status.\n   * @param {import(\"./types.js\").BackgroundJobRow[]} jobs - Jobs.\n   * @returns {Record<string, number>} Counts.\n   */\n  _statusCounts(jobs) {\n    /** @type {Record<string, number>} */\n    const counts = {}\n\n    for (const job of jobs) {\n      if (!COUNTED_JOB_STATUSES.includes(job.status)) throw new Error(`Unknown background job status: ${job.status}`)\n      counts[job.status] = (counts[job.status] || 0) + 1\n    }\n\n    return counts\n  }\n\n  /**\n   * Reads a canonical snapshot after locking the revision row.\n   * @param {import(\"../database/drivers/base.js\").default} db - Transaction connection.\n   * @returns {Promise<{counts: Record<string, number>, revision: number, total: number}>} Snapshot.\n   */\n  async _countSnapshotOnLockedConnection(db) {\n    const rows = await db.newQuery().from(JOBS_TABLE).select(\"status\").select(\"COUNT(*) AS count\").group(\"status\").results()\n    const counts = this._emptyCountBuckets()\n    let total = 0\n\n    for (const row of rows) {\n      const typedRow = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (row)\n      const status = String(typedRow.status)\n      const count = this._normalizeNumber(typedRow.count) || 0\n\n      total += count\n\n      if (!COUNTED_JOB_STATUSES.includes(status)) continue\n      counts[status] = count\n      counts.all += counts[status]\n    }\n\n    return {counts, revision: await this._countRevision(db), total}\n  }\n\n  /**\n   * Registers or verifies a stable key configuration.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {object} concurrency - Concurrency configuration.\n   * @param {string} concurrency.concurrencyKey - Concurrency key.\n   * @param {number} concurrency.maxConcurrency - Stable cap.\n   * @returns {Promise<void>} - Resolves when verified.\n   */\n  async _ensureConcurrencyKey(db, {concurrencyKey, maxConcurrency}) {\n    const rows = await db.newQuery().from(CONCURRENCY_TABLE).where({concurrency_key: concurrencyKey}).limit(1).results()\n    if (!rows[0]) {\n      try {\n        await db.insert({tableName: CONCURRENCY_TABLE, data: {active_count: 0, concurrency_key: concurrencyKey, max_concurrency: maxConcurrency}})\n        return\n      } catch (error) {\n        const racedRows = await db.newQuery().from(CONCURRENCY_TABLE).where({concurrency_key: concurrencyKey}).limit(1).results()\n        if (!racedRows[0]) throw error\n        rows[0] = racedRows[0]\n      }\n    }\n    const configured = /** @type {{max_concurrency?: number | string}} */ (rows[0])\n    if (this._normalizeNumber(configured.max_concurrency) !== maxConcurrency) throw new Error(`Conflicting maxConcurrency for background job concurrencyKey: ${concurrencyKey}`)\n  }\n\n  /**\n   * Locks the concurrency counter row so a job-release transaction acquires it *before* the job\n   * row. {@link markHandedOff} reserves capacity (locking the counter row) before it updates the\n   * job, so it locks concurrency-then-job; the release paths update the job before releasing\n   * capacity, which is job-then-concurrency. Those opposite orders on the same shared counter row\n   * are what deadlock (AB-BA) under a draining worker. Taking this lock first gives every\n   * transaction a single concurrency-then-job order and removes the cycle.\n   *\n   * Uses a value-preserving `UPDATE` rather than `SELECT ... FOR UPDATE` so it stays portable\n   * across drivers without row-level locking reads (e.g. SQLite); on row-locking engines the\n   * matched row is write-locked for the rest of the transaction even though its value is unchanged.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string | null} concurrencyKey - Concurrency key.\n   * @returns {Promise<void>} - Resolves when the counter row is locked.\n   */\n  async _lockConcurrencyRow(db, concurrencyKey) {\n    if (!concurrencyKey) return\n    const table = db.quoteTable(CONCURRENCY_TABLE)\n    const count = db.quoteColumn(\"active_count\")\n    await db.query(`UPDATE ${table} SET ${count} = ${count} WHERE ${db.quoteColumn(\"concurrency_key\")} = ${db.quote(concurrencyKey)}`)\n  }\n\n  /**\n   * Atomically reserves capacity for a key.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} concurrencyKey - Concurrency key.\n   * @returns {Promise<boolean>} - Whether capacity was reserved.\n   */\n  async _reserveConcurrency(db, concurrencyKey) {\n    const table = db.quoteTable(CONCURRENCY_TABLE)\n    const count = db.quoteColumn(\"active_count\")\n    const affectedRows = await db.affectedRows(`UPDATE ${table} SET ${count} = ${count} + 1 WHERE ${db.quoteColumn(\"concurrency_key\")} = ${db.quote(concurrencyKey)} AND ${count} < ${db.quoteColumn(\"max_concurrency\")}`)\n    return affectedRows === 1\n  }\n\n  /**\n   * Runs a portable update and returns its affected-row count.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {import(\"../database/drivers/base.js\").UpdateSqlArgsType} args - Update options.\n   * @returns {Promise<number>} - Affected row count.\n   */\n  async _updateAffectedRows(db, args) {\n    return await db.affectedRows(db.updateSql(args))\n  }\n\n  /**\n   * Releases capacity for a key.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string | null} concurrencyKey - Concurrency key.\n   * @returns {Promise<void>} - Resolves when released.\n   */\n  async _releaseConcurrency(db, concurrencyKey) {\n    if (!concurrencyKey) return\n    const table = db.quoteTable(CONCURRENCY_TABLE)\n    const count = db.quoteColumn(\"active_count\")\n    await db.query(`UPDATE ${table} SET ${count} = ${count} - 1 WHERE ${db.quoteColumn(\"concurrency_key\")} = ${db.quote(concurrencyKey)} AND ${count} > 0`)\n  }\n\n  /**\n   * Rebuilds durable counts from active handoffs.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {{insideTransaction?: boolean}} [options] - Reuse an enclosing transaction.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobConcurrencyReconciliation>} - Repair summary.\n   */\n  async _reconcileConcurrency(db, {insideTransaction = false} = {}) {\n    if (!(await db.tableExists(CONCURRENCY_TABLE))) {\n      return {candidateCount: 0, checkedCount: 0, repairedCount: 0, repairs: [], repairsTruncatedCount: 0}\n    }\n\n    const activeRows = await db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .select(\"concurrency_key\")\n      .select(\"COUNT(*) AS active_count\")\n      .where({status: \"handed_off\"})\n      .where(`${db.quoteColumn(\"concurrency_key\")} IS NOT NULL`)\n      .group(\"concurrency_key\")\n      .results()\n    const staleRows = await db\n      .newQuery()\n      .from(CONCURRENCY_TABLE)\n      .select(\"concurrency_key\")\n      .select(\"active_count\")\n      .where(`${db.quoteColumn(\"active_count\")} != 0`)\n      .results()\n    /** @type {Map<string, number>} */\n    const activeCounts = new Map()\n    /** @type {Map<string, number>} */\n    const persistedCounts = new Map()\n\n    for (const rawRow of activeRows) {\n      const row = /** @type {BackgroundJobConcurrencyCountRow} */ (rawRow)\n      activeCounts.set(row.concurrency_key, this._validatedConcurrencyCount(row.active_count, row.concurrency_key))\n    }\n\n    for (const rawRow of staleRows) {\n      const row = /** @type {BackgroundJobConcurrencyCountRow} */ (rawRow)\n      persistedCounts.set(row.concurrency_key, this._validatedConcurrencyCount(row.active_count, row.concurrency_key))\n    }\n\n    const concurrencyKeys = [...new Set([...activeCounts.keys(), ...persistedCounts.keys()])].sort()\n    const candidateKeys = concurrencyKeys.filter((concurrencyKey) => {\n      return (activeCounts.get(concurrencyKey) || 0) !== (persistedCounts.get(concurrencyKey) || 0)\n    })\n    /** @type {import(\"./types.js\").BackgroundJobConcurrencyRepair[]} */\n    const repairs = []\n    let repairedCount = 0\n\n    for (const concurrencyKey of candidateKeys) {\n      const repair = insideTransaction\n        ? await this._reconcileConcurrencyKey(db, concurrencyKey)\n        : await this._transactionResult(db, async () => await this._reconcileConcurrencyKey(db, concurrencyKey))\n\n      if (!repair) continue\n\n      repairedCount++\n      if (repairs.length < CONCURRENCY_REPAIR_SAMPLE_LIMIT) repairs.push(repair)\n    }\n\n    return {\n      candidateCount: candidateKeys.length,\n      checkedCount: concurrencyKeys.length,\n      repairedCount,\n      repairs,\n      repairsTruncatedCount: repairedCount - repairs.length\n    }\n  }\n\n  /**\n   * Rebuilds one counter after locking it ahead of the job rows, matching the\n   * lock order used by handoff and completion transitions.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} concurrencyKey - Counter key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobConcurrencyRepair | null>} - Applied repair.\n   */\n  async _reconcileConcurrencyKey(db, concurrencyKey) {\n    await this._lockConcurrencyRow(db, concurrencyKey)\n    const persistedRows = await db\n      .newQuery()\n      .from(CONCURRENCY_TABLE)\n      .select(\"active_count\")\n      .select(\"concurrency_key\")\n      .where({concurrency_key: concurrencyKey})\n      .limit(1)\n      .results()\n\n    if (!persistedRows[0]) throw new Error(`Missing background job concurrency counter for ${concurrencyKey}`)\n\n    const persistedRow = /** @type {BackgroundJobConcurrencyCountRow} */ (persistedRows[0])\n    const previousActiveCount = this._validatedConcurrencyCount(persistedRow.active_count, concurrencyKey)\n    const rows = await db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .select(\"COUNT(*) AS active_count\")\n      .where({concurrency_key: concurrencyKey, status: \"handed_off\"})\n      .results()\n    const countRow = /** @type {{active_count: number | string}} */ (rows[0])\n    const activeCount = this._validatedConcurrencyCount(countRow.active_count, concurrencyKey)\n\n    if (activeCount === previousActiveCount) return null\n\n    await db.update({\n      tableName: CONCURRENCY_TABLE,\n      data: {active_count: activeCount},\n      conditions: {concurrency_key: concurrencyKey}\n    })\n\n    return {activeCount, concurrencyKey, previousActiveCount}\n  }\n\n  /**\n   * Validates a database count before it participates in reconciliation.\n   * @param {number | string} value - Raw count.\n   * @param {string} concurrencyKey - Counter key for diagnostics.\n   * @returns {number} - Safe non-negative count.\n   */\n  _validatedConcurrencyCount(value, concurrencyKey) {\n    const count = this._normalizeNumber(value)\n\n    if (count === null || !Number.isSafeInteger(count) || count < 0) {\n      throw new Error(`Invalid reconciled background job concurrency count for ${concurrencyKey}: ${count}`)\n    }\n\n    return count\n  }\n\n  /**\n   * Reconciles queue-derived concurrency with the current configuration. Only\n   * invoked through {@link reconcileQueueConcurrency} — the explicit lifecycle\n   * path run at main-process startup under a cross-process advisory lock —\n   * never from schema/tenant checks or routine connection initialization,\n   * which stay read-only regarding queued job rows. The per-process memo is\n   * latched by {@link reconcileQueueConcurrency} only after the following\n   * count rebuild also succeeds, so a failed rebuild re-enters here on retry\n   * (the adoption UPDATEs below are idempotent). Enqueue only consults config for new jobs, so a cap added, removed, or changed\n   * while a backlog exists otherwise leaves persisted rows stale: pre-cap jobs\n   * keep a null key and bypass the cap, post-removal jobs stay capped under a\n   * now-unconfigured key, and a changed numeric cap stays stale until the next\n   * enqueue. Bring queued durable state in line with config: sync each configured\n   * queue's stored cap, adopt not-yet-keyed queued jobs onto their queue key,\n   * and release queued jobs from queue keys whose queue is no longer capped.\n   * Existing handoffs retain the policy and reservation they started with, so\n   * reconciliation cannot race their completion/retry transitions. Runs before\n   * {@link _reconcileConcurrency} so any pre-existing active counts are exact.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when reconciled.\n   */\n  async _reconcileQueueConcurrency(db) {\n    if (this._queueConcurrencyReconciled) return\n    if (!(await db.tableExists(CONCURRENCY_TABLE))) return\n\n    const queuesConfig = this.configuration.getBackgroundJobsConfig().queues || {}\n    const jobsTable = db.quoteTable(JOBS_TABLE)\n    const keyColumn = db.quoteColumn(\"concurrency_key\")\n    const capColumn = db.quoteColumn(\"max_concurrency\")\n    const queueColumn = db.quoteColumn(\"queue\")\n    const queued = `${db.quoteColumn(\"status\")} = ${db.quote(\"queued\")}`\n    /** @type {Set<string>} */\n    const cappedQueues = new Set()\n\n    for (const queue of Object.keys(queuesConfig)) {\n      const cap = this._queueMaxConcurrency(queue)\n\n      if (cap === null) continue\n\n      cappedQueues.add(queue)\n      const concurrencyKey = `${QUEUE_CONCURRENCY_KEY_PREFIX}${queue}`\n\n      await this._ensureQueueConcurrencyKey(db, {concurrencyKey, maxConcurrency: cap})\n      await db.query(\n        `UPDATE ${jobsTable} SET ${keyColumn} = ${db.quote(concurrencyKey)}, ${capColumn} = ${Number(cap)} ` +\n        `WHERE ${queueColumn} = ${db.quote(queue)} AND ${keyColumn} IS NULL AND ${queued}`\n      )\n    }\n\n    const concurrencyRows = await db\n      .newQuery()\n      .from(CONCURRENCY_TABLE)\n      .select(\"concurrency_key\")\n      .where(`${db.quoteColumn(\"concurrency_key\")} LIKE ${db.quote(`${QUEUE_CONCURRENCY_KEY_PREFIX}%`)}`)\n      .results()\n\n    for (const row of concurrencyRows) {\n      const concurrencyKey = String(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (row).concurrency_key)\n\n      if (!concurrencyKey.startsWith(QUEUE_CONCURRENCY_KEY_PREFIX)) continue\n      if (cappedQueues.has(concurrencyKey.slice(QUEUE_CONCURRENCY_KEY_PREFIX.length))) continue\n\n      await db.query(\n        `UPDATE ${jobsTable} SET ${keyColumn} = NULL, ${capColumn} = NULL ` +\n        `WHERE ${keyColumn} = ${db.quote(concurrencyKey)} AND ${queued}`\n      )\n    }\n  }\n\n  /**\n   * Runs normalize number.\n   * @param {ReturnType<typeof JSON.parse>} value - Input value.\n   * @returns {number | null} - Normalized number.\n   */\n  _normalizeNumber(value) {\n    if (value === null || value === undefined || value === \"\") return null\n\n    const numeric = Number(value)\n\n    if (Number.isNaN(numeric)) return null\n\n    return numeric\n  }\n\n  /**\n   * Runs normalize execution mode.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [options] - Job options.\n   * @returns {import(\"./types.js\").BackgroundJobExecutionMode} - Normalized execution mode.\n   */\n  _normalizeExecutionMode(options) {\n    return normalizeBackgroundJobExecutionMode(options || {}, DEFAULT_BACKGROUND_JOB_EXECUTION_MODE)\n  }\n\n  /**\n   * Runs normalize execution mode name.\n   * @param {string} executionMode - Execution mode name.\n   * @returns {import(\"./types.js\").BackgroundJobExecutionMode} - Normalized execution mode.\n   */\n  _normalizeExecutionModeName(executionMode) {\n    return normalizeBackgroundJobExecutionMode(\n      {executionMode: /** @type {import(\"./types.js\").BackgroundJobExecutionMode} */ (executionMode)},\n      DEFAULT_BACKGROUND_JOB_EXECUTION_MODE,\n      BACKGROUND_JOB_EXECUTION_MODES\n    )\n  }\n\n  /**\n   * Filters queued jobs by one or more execution modes against the\n   * `execution_mode` column (the single source of truth).\n   * @param {object} args - Options.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Database connection.\n   * @param {import(\"./types.js\").BackgroundJobExecutionMode | import(\"./types.js\").BackgroundJobExecutionMode[]} args.executionMode - Runtime modes.\n   * @param {import(\"../database/query/index.js\").default} args.query - Query to filter.\n   * @returns {import(\"../database/query/index.js\").default} - Filtered query.\n   */\n  _whereExecutionMode({db, executionMode, query}) {\n    const executionModes = Array.isArray(executionMode) ? executionMode : [executionMode]\n    const executionModeColumn = db.quoteColumn(\"execution_mode\")\n    const conditions = executionModes.map((mode) => `${executionModeColumn} = ${db.quote(mode)}`)\n\n    return query.where(`(${conditions.join(\" OR \")})`)\n  }\n\n  /**\n   * Runs parse args.\n   * @param {ReturnType<typeof JSON.parse>} value - Input value.\n   * @returns {Array<ReturnType<typeof JSON.parse>>} - Parsed args.\n   */\n  _parseArgs(value) {\n    if (!value) return []\n\n    try {\n      const parsed = JSON.parse(String(value))\n\n      if (Array.isArray(parsed)) return parsed\n    } catch {\n      // Ignore parse errors.\n    }\n\n    return []\n  }\n\n  /**\n   * Runs with db.\n   * @template T\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<T>} callback - Callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async _withDb(callback) {\n    const databaseIdentifier = this.getDatabaseIdentifier()\n    const pool = this.configuration.getDatabasePool(databaseIdentifier)\n\n    if (!pool.testSharedConnection()) {\n      return await pool.withConnection({name: \"Background jobs store\"}, callback)\n    }\n\n    return await this.configuration.runWithTestSharedConnectionContexts(async () => {\n      return await this.configuration.ensureConnections({databaseIdentifiers: [databaseIdentifier], name: \"Background jobs store\"}, async (dbs) => {\n        const connection = dbs[databaseIdentifier]\n        return await coordinateSharedTransactionConnection(connection, async () => await callback(connection))\n      })\n    })\n  }\n\n  /**\n   * Runs a value-returning callback inside the driver's void-typed transaction API.\n   * @template T\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {() => Promise<T>} callback - Transaction callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async _transactionResult(db, callback) {\n    let completed = false\n    /** @type {T | undefined} */\n    let result\n    await db.transaction(async () => {\n      result = await callback()\n      completed = true\n    })\n    if (!completed) throw new Error(\"Background jobs transaction callback was not invoked\")\n    return /** @type {T} */ (result)\n  }\n\n  /**\n   * Serializes count-changing transactions before checking out their connection.\n   * Database row locking still provides cross-process ordering; this guard\n   * prevents concurrent callers on SQLite's shared connection from attempting\n   * overlapping top-level transactions.\n   * @template T\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<T>} callback - Transaction callback.\n   * @param {BackgroundJobTransactionSerializationOptions} [options] - Serialization options.\n   * @returns {Promise<T>} Callback result.\n   */\n  async _serializedCountMutation(callback, options = {}) {\n    return await this._serializedTransactionMutation(async (db) => {\n      await this._lockCountRevision(db)\n\n      return await callback(db)\n    }, options)\n  }\n\n  /**\n   * Runs a serialized callback inside one transaction.\n   * @template T\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<T>} callback - Transaction callback.\n   * @param {BackgroundJobTransactionSerializationOptions} [options] - Serialization options.\n   * @returns {Promise<T>} Callback result.\n   */\n  async _serializedTransactionMutation(callback, options = {}) {\n    return await this._serializedConnectionMutation(\n      async (db) => await this._transactionResult(db, async () => await callback(db)),\n      options\n    )\n  }\n\n  /**\n   * Admits mutation callbacks to the process-local FIFO before they check out a\n   * connection. Cross-process ordering remains the responsibility of durable\n   * row/advisory locks and unique constraints acquired around the callback.\n   * @template T\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<T>} callback - Connection callback.\n   * @param {BackgroundJobTransactionSerializationOptions} [options] - Serialization options.\n   * @returns {Promise<T>} Callback result.\n   */\n  async _serializedConnectionMutation(callback, options = {}) {\n    const identifier = this.getDatabaseIdentifier() || \"default\"\n    const previous = transactionMutationChains.get(identifier) || Promise.resolve()\n    let resolveRun = () => {}\n    /** @type {Promise<void>} */\n    const run = new Promise((resolve) => {\n      resolveRun = () => resolve(undefined)\n    })\n    const chain = previous.then(() => run)\n\n    transactionMutationChains.set(identifier, chain)\n    await previous\n\n    try {\n      return await this._withDb(async (db) => {\n        const {advisoryLock} = options\n\n        if (advisoryLock) {\n          const acquired = await db.acquireAdvisoryLock(advisoryLock.name)\n\n          if (!acquired) throw new Error(advisoryLock.failureMessage)\n        }\n\n        try {\n          return await callback(db)\n        } finally {\n          if (advisoryLock) await db.releaseAdvisoryLock(advisoryLock.name)\n        }\n      })\n    } finally {\n      resolveRun()\n      if (transactionMutationChains.get(identifier) === chain) transactionMutationChains.delete(identifier)\n    }\n  }\n\n  /**\n   * Runs should accept report.\n   * @param {object} args - Options.\n   * @param {import(\"./types.js\").BackgroundJobRow} args.job - Job row.\n   * @param {string | null | undefined} args.handoffId - Handoff lease id from report.\n   * @param {string | null | undefined} args.workerId - Worker id from report.\n   * @param {number | null | undefined} args.handedOffAtMs - Handed off timestamp from report.\n   * @returns {boolean} - Whether to accept the report.\n   */\n  _shouldAcceptReport({job, handoffId, workerId, handedOffAtMs}) {\n    if (job.status !== \"handed_off\") return false\n\n    return this._handoffIdReportMatches({handoffId, job})\n      && this._workerReportMatches({job, workerId})\n      && this._handoffReportMatches({handedOffAtMs, job})\n  }\n\n  /**\n   * Runs active handoff conditions.\n   * @param {import(\"./types.js\").BackgroundJobRow} job - Job row.\n   * @returns {Record<string, string | null>} - Conditional transition fence.\n   */\n  _activeHandoffConditions(job) {\n    return {handoff_id: job.handoffId, id: job.id, status: \"handed_off\"}\n  }\n\n  /**\n   * Runs handoff id report matches.\n   * @param {object} args - Options.\n   * @param {string | null | undefined} args.handoffId - Handoff lease id from report.\n   * @param {import(\"./types.js\").BackgroundJobRow} args.job - Job row.\n   * @returns {boolean} - Whether the handoff lease matches.\n   */\n  _handoffIdReportMatches({handoffId, job}) {\n    if (!job.handoffId) return true\n\n    return handoffId === job.handoffId\n  }\n\n  /**\n   * Runs worker report matches.\n   * @param {object} args - Options.\n   * @param {import(\"./types.js\").BackgroundJobRow} args.job - Job row.\n   * @param {string | null | undefined} args.workerId - Worker id from report.\n   * @returns {boolean} - Whether the worker report matches.\n   */\n  _workerReportMatches({job, workerId}) {\n    if (!workerId) return true\n    if (!job.workerId) return true\n\n    return workerId === job.workerId\n  }\n\n  /**\n   * Runs handoff report matches.\n   * @param {object} args - Options.\n   * @param {number | null | undefined} args.handedOffAtMs - Handed off timestamp from report.\n   * @param {import(\"./types.js\").BackgroundJobRow} args.job - Job row.\n   * @returns {boolean} - Whether the handoff report matches.\n   */\n  _handoffReportMatches({handedOffAtMs, job}) {\n    if (!handedOffAtMs) return true\n    if (!job.handedOffAtMs) return true\n\n    return handedOffAtMs === job.handedOffAtMs\n  }\n\n  /**\n   * Runs migration key.\n   * @param {string} [version] - Migration version.\n   * @returns {string} - Migration key.\n   */\n  _migrationKey(version = MIGRATION_VERSION) {\n    return `${MIGRATION_SCOPE}:${version}`\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../src/background-jobs/store.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {createHash, randomUUID} from \"crypto\"\nimport BackgroundJobsAdapter from \"./adapter.js\"\nimport Logger from \"../logger.js\"\nimport TableData from \"../database/table-data/index.js\"\nimport VelociousError from \"../velocious-error.js\"\nimport BackgroundJobRecord from \"./job-record.js\"\nimport normalizeBackgroundJobError from \"./normalize-error.js\"\nimport { coordinateSharedTransactionConnection } from \"../testing/shared-transaction-connection-coordinator.js\"\nimport stableJsonStringify from \"../utils/stable-json.js\"\nimport {\n  BACKGROUND_JOB_TERMINAL_STATUSES,\n  BACKGROUND_JOB_EXECUTION_MODES,\n  DEFAULT_BACKGROUND_JOB_EXECUTION_MODE,\n  DEFAULT_BACKGROUND_JOB_QUEUE,\n  QUEUE_CONCURRENCY_KEY_PREFIX,\n  normalizeBackgroundJobConcurrency,\n  normalizeBackgroundJobExecutionMode,\n  normalizeBackgroundJobMaxRetries,\n  normalizeBackgroundJobQueue,\n  normalizeBackgroundJobScheduleKey,\n  normalizeBackgroundJobScheduledAtMs,\n  normalizeBackgroundJobStatus,\n  rescheduledBackgroundJobAtMs,\n  retryDelayMs\n} from \"./job-semantics.js\"\nimport {\n  MAIL_DELIVERY_OPERATIONS_TABLE,\n  mailDeliveryOperationForJob,\n  mailDeliveryOperationKey\n} from \"../mailer/delivery-operation.js\"\n\n/**\n * PreparedBackgroundJob type.\n * @typedef {object} PreparedBackgroundJob\n * @property {string} argsJson - Serialized arguments.\n * @property {{concurrencyKey: string, maxConcurrency: number, queueDerived: boolean} | null} concurrency - Resolved concurrency.\n * @property {number} createdAtMs - Creation timestamp.\n * @property {import(\"./types.js\").BackgroundJobExecutionMode} executionMode - Execution mode.\n * @property {string} jobId - New job id.\n * @property {string} jobName - Job name.\n * @property {number} maxRetries - Retry cap.\n * @property {string} queue - Queue name.\n * @property {number} scheduledAtMs - Eligibility timestamp.\n * @property {number | null} timeoutMs - Per-job timeout override, or null when omitted.\n */\n\n/**\n * BackgroundJobOrphanSelection type.\n * @typedef {object} BackgroundJobOrphanSelection\n * @property {Record<string, ReturnType<typeof JSON.parse>>} conditions - Exact update fence.\n * @property {import(\"./types.js\").BackgroundJobRow} job - Selected active handoff.\n */\n\n/**\n * BackgroundJobTransactionSerializationOptions type.\n * @typedef {object} BackgroundJobTransactionSerializationOptions\n * @property {{failureMessage: string, name: string}} [advisoryLock] - Session lock held around the transaction.\n */\n\n/**\n * BackgroundJobConcurrencyCountRow type.\n * @typedef {object} BackgroundJobConcurrencyCountRow\n * @property {number | string} active_count - Persisted or aggregated active count.\n * @property {string} concurrency_key - Durable cap identity.\n */\n\n/**\n * BackgroundJobQueuedConcurrency type.\n * @typedef {object} BackgroundJobQueuedConcurrency\n * @property {string | null} concurrencyKey - Current concurrency key for queued work.\n * @property {number | null} maxConcurrency - Current concurrency cap for queued work.\n */\n\nconst MIGRATIONS_TABLE = \"velocious_internal_migrations\"\nconst MIGRATION_SCOPE = \"background_jobs\"\nconst MIGRATION_VERSION = \"20250215000000\"\nconst SCHEMA_RECOVERY_PENDING_VERSION = \"schema-recovery-pending\"\nconst EXECUTION_MODE_BACKFILL_MIGRATION_VERSION = \"20260607131010\"\n// Drops the redundant legacy `forked` boolean column and rewrites pooled rows to\n// persist `execution_mode = \"pooled\"` directly (retiring the pooled-as-forked\n// handoff-marker workaround), leaving `execution_mode` as the single source of\n// truth for a job's runtime.\nconst DROP_FORKED_COLUMN_MIGRATION_VERSION = \"20260719000000\"\nconst JOBS_INDEX_REPAIR_MIGRATION_VERSION = \"20260903120000\"\n// Legacy marker prefix used by rows written before this migration: pooled jobs\n// used to persist as `execution_mode = \"forked\"` plus a `velocious-pooled:*`\n// handoff id. Retained only to detect and convert those rows in the migration.\nconst LEGACY_POOLED_HANDOFF_ID_PREFIX = \"velocious-pooled:\"\nconst LEGACY_POOLED_QUEUED_HANDOFF_ID = `${LEGACY_POOLED_HANDOFF_ID_PREFIX}queued`\nconst JOBS_TABLE = \"background_jobs\"\nconst JOBS_INDEX_COLUMN_NAMES = [\n  \"job_name\",\n  \"queue\",\n  \"status\",\n  \"scheduled_at_ms\",\n  \"created_at_ms\",\n  \"schedule_key\",\n  \"handed_off_at_ms\",\n  \"orphaned_at_ms\",\n  \"concurrency_key\"\n]\nconst IDEMPOTENCY_KEYS_TABLE = \"background_job_idempotency_keys\"\nconst SCHEDULE_KEYS_TABLE = \"background_job_schedule_keys\"\nconst SCHEDULE_ORDER_WATERMARKS_TABLE = \"background_job_schedule_order_watermarks\"\nconst SCHEDULE_ORDER_WATERMARK_MIGRATION_VERSION = \"20260911120000\"\nconst SCHEDULE_HISTORY_ORDER_INDEX = \"index_background_jobs_schedule_history_order\"\nconst CONCURRENCY_TABLE = \"background_job_concurrency\"\nconst COUNTS_REVISION_TABLE = \"background_job_count_revisions\"\nconst COUNTS_REVISION_KEY = \"counts\"\nconst CONCURRENCY_RECONCILIATION_LOCK = \"background-jobs:queue-concurrency-reconcile\"\nconst CONCURRENCY_REPAIR_SAMPLE_LIMIT = 10\nexport const BACKGROUND_JOB_COUNTS_CHANNEL = \"velocious-background-job-counts\"\nexport const BACKGROUND_JOB_COUNT_BUCKETS = [\"all\", \"queued\", \"handed_off\", \"completed\", \"failed\", \"orphaned\"]\nconst COUNTED_JOB_STATUSES = BACKGROUND_JOB_COUNT_BUCKETS.slice(1)\nconst MAX_JOB_TIMEOUT_MS = 2_147_483_647\nconst JOB_TIMEOUT_VALIDATION_MESSAGE = `background job timeoutMs must be a finite non-positive number or an integer between 1 and ${MAX_JOB_TIMEOUT_MS}`\nconst ORPHANED_AFTER_MS = 2 * 60 * 60 * 1000\n\n/**\n * Columns the dashboard is allowed to sort job listings by, mapped to their\n * database column names. Restricting to this set keeps the sort parameter\n * (which originates from untrusted query strings) from reaching raw SQL.\n * @type {Record<string, string>}\n */\nconst SORTABLE_COLUMNS = {\n  attempts: \"attempts\",\n  completedAtMs: \"completed_at_ms\",\n  createdAtMs: \"created_at_ms\",\n  failedAtMs: \"failed_at_ms\",\n  handedOffAtMs: \"handed_off_at_ms\",\n  scheduledAtMs: \"scheduled_at_ms\"\n}\n\n/**\n * Serializes concurrent `_applySchema` runs within THIS process, keyed by database\n * identifier, before callers without an existing connection check one out. Two\n * stores that share one connection (SingleMultiUse / SQLite)\n * otherwise interleave the multi-step table rebuild and corrupt it (the jobs table\n * is left as its `*_velocious_rebuild` temp). A DB advisory lock can't fix that: on\n * a session-scoped / re-entrant driver (MySQL `GET_LOCK`) a second acquire on the\n * same session succeeds immediately so both callers proceed, and taking it on a\n * separate connection blocks cross-session forever. An in-process promise-chain\n * mutex serializes same-process callers with neither hazard. Cross-process schema\n * races stay covered by the per-step advisory locks + rechecks inside the steps.\n * @type {Map<string, Promise<void>>}\n */\nconst schemaApplyChains = new Map()\n/** @type {Map<string, Promise<void>>} */\nconst transactionMutationChains = new Map()\n\nexport default class BackgroundJobsStore extends BackgroundJobsAdapter {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration.\n   * @param {string} [args.databaseIdentifier] - Database identifier.\n   * @param {{now: () => number}} [args.clock] - Injectable persistence clock.\n   * @param {(producerProof: import(\"./types.js\").BackgroundJobProducerProof) => void | Promise<void>} [args.afterOwnedProducerValidation] - Exact owned-enqueue validation hook.\n   */\n  constructor({configuration, databaseIdentifier, clock, afterOwnedProducerValidation}) {\n    super()\n    this.configuration = configuration\n    this.databaseIdentifier = databaseIdentifier\n    this.clock = clock || {now: () => Date.now()}\n    this.afterOwnedProducerValidation = afterOwnedProducerValidation\n    this.logger = new Logger(this)\n    this._readyPromise = null\n    this._queueConcurrencyReconciled = false\n  }\n\n  /**\n   * Runs get database identifier.\n   * @returns {string} - Database identifier.\n   */\n  getDatabaseIdentifier() {\n    if (this.databaseIdentifier) return this.databaseIdentifier\n\n    return this.configuration.getBackgroundJobsConfig().databaseIdentifier\n  }\n\n  /**\n   * Runs ensure ready.\n   * @returns {Promise<void>} - Resolves when ready.\n   */\n  async ensureReady() {\n    if (this._readyPromise) return await this._readyPromise\n\n    this._readyPromise = (async () => {\n      this.configuration.setCurrent()\n      await this._ensureSchema()\n      await this._initializeModel()\n    })()\n\n    try {\n      await this._readyPromise\n    } finally {\n      this._readyPromise = null\n    }\n  }\n\n  /**\n   * Ensures the background-jobs schema (tables + columns) exists on the configured\n   * database, without initializing the runtime model. Lets `db:migrate` create the\n   * framework's own schema deterministically alongside app migrations — and capture\n   * it in the dumped structure SQL — instead of it only appearing once a store boots.\n   * Idempotent: reuses the same `_ensureSchema` the runtime store uses, which skips\n   * work already applied (tracked in `velocious_internal_migrations`).\n   * @param {import(\"../database/drivers/base.js\").default} [db] - Reuse an already\n   *   checked-out connection (e.g. the one `db:migrate` holds) rather than opening a\n   *   nested checkout that would deadlock a single-connection pool.\n   * @returns {Promise<void>} - Resolves when the schema is present.\n   */\n  async ensureSchema(db) {\n    // When a connection is handed in (the db:migrate path), the caller already owns\n    // the active configuration + connection context; calling setCurrent() here would\n    // clobber it (e.g. the browser test runner juggles multiple configurations).\n    if (!db) this.configuration.setCurrent()\n\n    await this._ensureSchema(db)\n  }\n\n  /**\n   * Reconciles queue-derived concurrency with the current configuration: the\n   * explicit lifecycle path that adopts/releases persisted queued jobs onto\n   * queue concurrency keys when `queues[name].maxConcurrent` is added, removed,\n   * or changed. Called by the background-jobs main process on startup — the\n   * deploy-time moment queue configuration changes take effect. Schema/tenant\n   * checks and routine connection initialization deliberately never run this:\n   * they stay read-only regarding queued job rows, because the broad\n   * adoption/release UPDATEs deadlock against active job processes under\n   * concurrent tenant initialization. Serialized across processes with a\n   * database advisory lock so concurrently started mains cannot interleave the\n   * UPDATEs; the per-instance memo only skips repeat work within this process.\n   * @returns {Promise<void>} - Resolves when reconciled.\n   */\n  async reconcileQueueConcurrency() {\n    if (this._queueConcurrencyReconciled) return\n\n    const databaseIdentifier = this.getDatabaseIdentifier()\n    const startedAtMs = Date.now()\n\n    await this.logger.info(() => [\n      \"Starting background jobs queue-concurrency startup reconciliation\",\n      {databaseIdentifier}\n    ])\n    await this.ensureReady()\n\n    await this._withDb(async (db) => {\n      const acquired = await db.acquireAdvisoryLock(CONCURRENCY_RECONCILIATION_LOCK)\n\n      if (!acquired) throw new Error(\"Failed to acquire background job queue-concurrency reconcile lock\")\n\n      try {\n        await this._reconcileQueueConcurrency(db)\n        await this._reconcileConcurrency(db)\n\n        // Latch the memo only after BOTH steps succeed: if the count rebuild\n        // fails after adoption, a retry on this store must re-enter and repair\n        // the counts (adoption itself is idempotent).\n        this._queueConcurrencyReconciled = true\n      } finally {\n        await db.releaseAdvisoryLock(CONCURRENCY_RECONCILIATION_LOCK)\n      }\n    })\n\n    await this.logger.info(() => [\n      \"Completed background jobs queue-concurrency startup reconciliation\",\n      {databaseIdentifier, durationMs: Date.now() - startedAtMs}\n    ])\n  }\n\n  /**\n   * Repairs durable active-count drift while a main process remains live. The\n   * initial snapshot is read-only; only suspected mismatches take their\n   * counter lock and re-count inside the serialized transaction path.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobConcurrencyReconciliation>} - Repair summary.\n   */\n  async reconcileActiveConcurrency() {\n    const databaseIdentifier = this.getDatabaseIdentifier()\n    const startedAtMs = Date.now()\n\n    await this.ensureReady()\n\n    const result = await this._serializedConnectionMutation(\n      async (db) => await this._reconcileConcurrency(db),\n      {\n        advisoryLock: {\n          failureMessage: \"Failed to acquire background job active-concurrency reconcile lock\",\n          name: CONCURRENCY_RECONCILIATION_LOCK\n        }\n      }\n    )\n\n    if (result.repairedCount > 0) {\n      await this.logger.warn(() => [\n        \"Repaired background jobs active-concurrency count drift\",\n        {\n          databaseIdentifier,\n          durationMs: Date.now() - startedAtMs,\n          repairedCount: result.repairedCount,\n          repairs: result.repairs,\n          repairsTruncatedCount: result.repairsTruncatedCount\n        }\n      ])\n    }\n\n    return result\n  }\n\n  /**\n   * Runs enqueue.\n   * @param {object} args - Options.\n   * @param {string} args.jobName - Job name.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Arguments.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Options.\n   * @returns {Promise<string>} - Job id.\n   */\n  async enqueue({jobName, args, options}) {\n    await this.ensureReady()\n\n    const preparedJob = this._prepareJob({jobName, args, options})\n\n    if (options?.idempotencyKey !== undefined) {\n      return await this._enqueueIdempotently({args: args || [], options, preparedJob})\n    }\n\n    /** @type {string} */\n    let resultJobId = preparedJob.jobId\n\n    await this._serializedCountMutation(async (db) => {\n      if (options?.deduplicateWhileQueued) {\n        const duplicateJobId = await this._deduplicatedQueuedJobId(db, preparedJob)\n\n        if (duplicateJobId) {\n          resultJobId = duplicateJobId\n          return\n        }\n      }\n\n      await this._insertPreparedJob(db, {preparedJob, scheduleKey: null})\n      await this._recordCountDelta(db, {all: 1, queued: 1})\n    })\n\n    return resultJobId\n  }\n\n  /**\n   * Atomically validates an exact producing handoff and enqueues its follow-up.\n   * Every exact request owns an internal durable replay identity, while queued\n   * deduplication can point several distinct producer events at one covering row.\n   * @param {object} args - Owned enqueue request.\n   * @param {string} args.jobName - Job name.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Arguments.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Options.\n   * @param {string} [args.producerInvocationId] - Stable identity for one owned enqueue invocation.\n   * @param {import(\"./types.js\").BackgroundJobProducerProof} args.producerProof - Exact producer lease.\n   * @returns {Promise<string>} - Durable follow-up id.\n   */\n  async enqueueFromOwnedHandoff({jobName, args, options, producerInvocationId, producerProof}) {\n    await this.ensureReady()\n\n    const normalizedProducerProof = this._normalizeProducerProof(producerProof)\n    const normalizedProducerInvocationId = this._normalizeProducerInvocationId(producerInvocationId)\n    const preparedJob = this._prepareJob({jobName, args, options})\n\n    return await this._serializedCountMutation(async (db) => {\n      await this._validateOwnedProducerProof(db, normalizedProducerProof)\n      if (this.afterOwnedProducerValidation) await this.afterOwnedProducerValidation(normalizedProducerProof)\n\n      if (options?.idempotencyKey !== undefined) {\n        return await this._enqueueIdempotentlyInTransaction({\n          args: args || [],\n          countRevisionLocked: true,\n          db,\n          options,\n          preparedJob\n        })\n      }\n\n      return await this._enqueueOwnedReplayInTransaction({\n        db,\n        options: options || {},\n        preparedJob,\n        producerInvocationId: normalizedProducerInvocationId,\n        producerProof: normalizedProducerProof\n      })\n    })\n  }\n\n  /**\n   * Finds the earliest queued job that covers this enqueue's identity and time.\n   * @param {import(\"../database/drivers/base.js\").default} db - Transaction connection.\n   * @param {PreparedBackgroundJob} preparedJob - Normalized job.\n   * @returns {Promise<string | null>} - Covering job id.\n   */\n  async _deduplicatedQueuedJobId(db, preparedJob) {\n    // Dedupe on the job's identity (name + args + queue), NOT its concurrency key, so a job\n    // keeps whatever concurrency it resolves to. Only an existing job scheduled no later than\n    // this enqueue can cover it; a retry backed off into the future must not suppress earlier\n    // work. Ordering returns the earliest covering job when several queued rows already exist.\n    const existing = await db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .select(\"id\")\n      .where({status: \"queued\", job_name: preparedJob.jobName, args_json: preparedJob.argsJson, queue: preparedJob.queue})\n      .where(`scheduled_at_ms <= ${db.quote(preparedJob.scheduledAtMs)}`)\n      .order(\"scheduled_at_ms ASC\")\n      .limit(1)\n      .results()\n    const row = existing[0]\n\n    return row ? String(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (row).id) : null\n  }\n\n  /**\n   * Persists one internal exact-replay owner and its queued job in the caller's\n   * producer-validation transaction.\n   * @param {object} args - Transaction input.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Transaction connection.\n   * @param {import(\"./types.js\").BackgroundJobOptions} args.options - Enqueue options.\n   * @param {PreparedBackgroundJob} args.preparedJob - Normalized job.\n   * @param {string} args.producerInvocationId - Stable identity for one owned enqueue invocation.\n   * @param {import(\"./types.js\").BackgroundJobProducerProof} args.producerProof - Exact producer lease.\n   * @returns {Promise<string>} - Stable replay job id.\n   */\n  async _enqueueOwnedReplayInTransaction({db, options, preparedJob, producerInvocationId, producerProof}) {\n    const requestDigest = this._ownedEnqueueRequestDigest({options, preparedJob})\n    const scopeDigest = this._ownedEnqueueScopeDigest({preparedJob, producerInvocationId, producerProof, requestDigest})\n    const idempotencyKey = `owned-handoff:${scopeDigest}`\n    const existing = await this._idempotencyOwnership(db, scopeDigest)\n    const baseOwnership = {\n      created_at_ms: preparedJob.createdAtMs,\n      idempotency_key: idempotencyKey,\n      job_name: preparedJob.jobName,\n      queue: preparedJob.queue,\n      request_digest: requestDigest,\n      scope_digest: scopeDigest\n    }\n\n    if (existing) {\n      this._validateIdempotencyOwnership({existing, ownership: {...baseOwnership, job_id: String(existing.job_id)}})\n      return String(existing.job_id)\n    }\n\n    const duplicateJobId = options.deduplicateWhileQueued\n      ? await this._deduplicatedQueuedJobId(db, preparedJob)\n      : null\n    const ownership = {...baseOwnership, job_id: duplicateJobId || preparedJob.jobId}\n    const claimed = await this._claimIdempotencyOwnership(db, ownership)\n\n    if (!claimed.created) {\n      this._validateIdempotencyOwnership({existing: claimed.row, ownership})\n      return String(claimed.row.job_id)\n    }\n    if (duplicateJobId) return duplicateJobId\n\n    await this._insertPreparedJob(db, {preparedJob, scheduleKey: null})\n    await this._recordCountDelta(db, {all: 1, queued: 1})\n\n    return preparedJob.jobId\n  }\n\n  /**\n   * Atomically owns one durable idempotency scope and creates its job exactly once.\n   * @param {object} args - Enqueue input.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job arguments.\n   * @param {import(\"./types.js\").BackgroundJobOptions} args.options - Job options.\n   * @param {PreparedBackgroundJob} args.preparedJob - Normalized job.\n   * @returns {Promise<string>} - Stable original job id.\n   */\n  async _enqueueIdempotently({args, options, preparedJob}) {\n    // Reuse ordinary enqueue transaction admission because this path changes\n    // the same durable count revision. The scope primary key remains the\n    // cross-process convergence owner.\n    return await this._idempotentEnqueueTransaction(async (db) => {\n      return await this._enqueueIdempotentlyInTransaction({args, db, options, preparedJob})\n    })\n  }\n\n  /**\n   * Owns or replays one public idempotency key inside the caller's transaction.\n   * @param {object} args - Transaction input.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job arguments.\n   * @param {boolean} [args.countRevisionLocked] - Whether the caller already owns count serialization.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Transaction connection.\n   * @param {import(\"./types.js\").BackgroundJobOptions} args.options - Job options.\n   * @param {PreparedBackgroundJob} args.preparedJob - Normalized job.\n   * @returns {Promise<string>} - Stable original job id.\n   */\n  async _enqueueIdempotentlyInTransaction({args, countRevisionLocked = false, db, options, preparedJob}) {\n    const idempotencyKey = this._normalizeIdempotencyKey(options.idempotencyKey)\n    const scopeDigest = this._idempotencyScopeDigest({idempotencyKey, jobName: preparedJob.jobName, queue: preparedJob.queue})\n    const requestDigest = this._idempotencyRequestDigest({args, options, preparedJob})\n    const ownership = {\n      created_at_ms: preparedJob.createdAtMs,\n      idempotency_key: idempotencyKey,\n      job_id: preparedJob.jobId,\n      job_name: preparedJob.jobName,\n      queue: preparedJob.queue,\n      request_digest: requestDigest,\n      scope_digest: scopeDigest\n    }\n    const mailOperationInput = mailDeliveryOperationForJob(preparedJob.jobName, args)\n\n    if (mailOperationInput && mailOperationInput.operation.id !== idempotencyKey) {\n      throw VelociousError.safe(\"Mail delivery operation id must equal its background job idempotency key.\", {\n        code: \"mail-delivery-idempotency-key-mismatch\"\n      })\n    }\n\n    const existing = await this._idempotencyOwnership(db, scopeDigest)\n\n    if (existing) {\n      this._validateIdempotencyOwnership({existing, ownership})\n      await this._validateMailDeliveryOperation(db, {jobId: String(existing.job_id), mailOperationInput})\n      return String(existing.job_id)\n    }\n\n    const claimed = await this._claimIdempotencyOwnership(db, ownership)\n\n    if (!claimed.created) {\n      this._validateIdempotencyOwnership({existing: claimed.row, ownership})\n      await this._validateMailDeliveryOperation(db, {jobId: String(claimed.row.job_id), mailOperationInput})\n      return String(claimed.row.job_id)\n    }\n\n    if (!countRevisionLocked) await this._lockCountRevision(db)\n    await this._insertPreparedJob(db, {preparedJob, scheduleKey: null})\n    await this._persistMailDeliveryOperation(db, {jobId: preparedJob.jobId, mailOperationInput, createdAtMs: preparedJob.createdAtMs})\n    await this._recordCountDelta(db, {all: 1, queued: 1})\n\n    return preparedJob.jobId\n  }\n\n  /**\n   * Serializes one physical connection locally without taking ownership away\n   * from the database uniqueness constraint shared by all processes.\n   * @template T\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<T>} callback - Transaction work.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async _idempotentEnqueueTransaction(callback) {\n    return await this._serializedTransactionMutation(callback)\n  }\n\n  /**\n   * Inserts an ownership row, resolving only a database uniqueness race.\n   * @param {import(\"../database/drivers/base.js\").default} db - Transaction connection.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} ownership - Ownership row.\n   * @returns {Promise<{created: boolean, row: Record<string, ReturnType<typeof JSON.parse>>}>} - Claim result.\n   */\n  async _claimIdempotencyOwnership(db, ownership) {\n    try {\n      // The savepoint keeps PostgreSQL's outer transaction usable after a\n      // concurrent unique-key loss. The unique primary key, not a process\n      // mutex, is the cross-process convergence authority.\n      await db.transaction(async () => {\n        await db.insert({tableName: IDEMPOTENCY_KEYS_TABLE, data: ownership})\n      })\n\n      return {created: true, row: ownership}\n    } catch (error) {\n      const raced = await this._idempotencyOwnership(db, String(ownership.scope_digest))\n\n      if (!raced) throw error\n      return {created: false, row: raced}\n    }\n  }\n\n  /**\n   * Loads one durable enqueue owner.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} scopeDigest - Fixed-size scope digest.\n   * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>> | null>} - Row or null.\n   */\n  async _idempotencyOwnership(db, scopeDigest) {\n    const rows = await db.newQuery().from(IDEMPOTENCY_KEYS_TABLE).where({scope_digest: scopeDigest}).limit(1).results()\n\n    return rows[0] ? /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (rows[0]) : null\n  }\n\n  /**\n   * Fails closed when a durable key is reused for a different canonical request.\n   * @param {object} args - Validation input.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.existing - Stored owner.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.ownership - Requested owner.\n   * @returns {void}\n   */\n  _validateIdempotencyOwnership({existing, ownership}) {\n    const exactScope = String(existing.job_name) === ownership.job_name\n      && String(existing.queue) === ownership.queue\n      && String(existing.idempotency_key) === ownership.idempotency_key\n\n    if (!exactScope || String(existing.request_digest) !== ownership.request_digest) {\n      throw VelociousError.safe(\"The background job idempotency key was already used for a different request.\", {\n        code: \"background-job-idempotency-conflict\"\n      })\n    }\n  }\n\n  /**\n   * Persists the built-in mail operation in the same first-enqueue transaction.\n   * @param {import(\"../database/drivers/base.js\").default} db - Transaction connection.\n   * @param {object} args - Operation input.\n   * @param {number} args.createdAtMs - Creation timestamp.\n   * @param {string} args.jobId - Native job id.\n   * @param {{operation: import(\"../mailer/index.js\").MailerDeliveryOperation, payload: import(\"../mailer/index.js\").MailerDeliveryPayload} | null} args.mailOperationInput - Mail operation.\n   * @returns {Promise<void>} - Resolves after persistence.\n   */\n  async _persistMailDeliveryOperation(db, {createdAtMs, jobId, mailOperationInput}) {\n    if (!mailOperationInput) return\n    const {operation} = mailOperationInput\n    const operationKey = mailDeliveryOperationKey(operation.id)\n    const row = {\n      background_job_id: jobId,\n      created_at_ms: createdAtMs,\n      first_attempt_started_at_ms: null,\n      operation_id: operation.id,\n      operation_key: operationKey,\n      payload_digest: operation.payloadDigest,\n      provider_kind: operation.providerKind,\n      provider_retention_ms: operation.providerRetentionMs\n    }\n\n    try {\n      await db.transaction(async () => {\n        await db.insert({tableName: MAIL_DELIVERY_OPERATIONS_TABLE, data: row})\n      })\n    } catch (error) {\n      const existing = await this._mailDeliveryOperation(db, operationKey)\n\n      if (!existing) throw error\n      this._validateMailDeliveryOperationRow({existing, requested: row})\n    }\n  }\n\n  /**\n   * Validates the durable mail row during an exact generic enqueue replay.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {object} args - Validation input.\n   * @param {string} args.jobId - Owned job id.\n   * @param {{operation: import(\"../mailer/index.js\").MailerDeliveryOperation, payload: import(\"../mailer/index.js\").MailerDeliveryPayload} | null} args.mailOperationInput - Mail operation.\n   * @returns {Promise<void>} - Resolves when exact.\n   */\n  async _validateMailDeliveryOperation(db, {jobId, mailOperationInput}) {\n    if (!mailOperationInput) return\n    const {operation} = mailOperationInput\n    const existing = await this._mailDeliveryOperation(db, mailDeliveryOperationKey(operation.id))\n\n    if (!existing) {\n      throw new Error(\"Background job idempotency ownership is missing its durable mail delivery operation\")\n    }\n\n    this._validateMailDeliveryOperationRow({\n      existing,\n      requested: {\n        background_job_id: jobId,\n        operation_id: operation.id,\n        payload_digest: operation.payloadDigest,\n        provider_kind: operation.providerKind,\n        provider_retention_ms: operation.providerRetentionMs\n      }\n    })\n  }\n\n  /**\n   * Loads a durable mail operation.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} operationKey - Fixed-size operation key.\n   * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>> | null>} - Row or null.\n   */\n  async _mailDeliveryOperation(db, operationKey) {\n    const rows = await db.newQuery().from(MAIL_DELIVERY_OPERATIONS_TABLE).where({operation_key: operationKey}).limit(1).results()\n\n    return rows[0] ? /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (rows[0]) : null\n  }\n\n  /**\n   * Compares provider-relevant durable mail operation fields.\n   * @param {object} args - Validation input.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.existing - Stored row.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.requested - Requested row.\n   * @returns {void}\n   */\n  _validateMailDeliveryOperationRow({existing, requested}) {\n    const matches = String(existing.operation_id) === requested.operation_id\n      && String(existing.payload_digest) === requested.payload_digest\n      && String(existing.background_job_id) === requested.background_job_id\n      && String(existing.provider_kind) === requested.provider_kind\n      && this._normalizeNumber(existing.provider_retention_ms) === requested.provider_retention_ms\n\n    if (!matches) {\n      throw VelociousError.safe(\"The mail delivery operation was already used for a different payload or provider.\", {\n        code: \"mail-delivery-idempotency-conflict\"\n      })\n    }\n  }\n\n  /**\n   * Canonical request digest excluding generated ids and immediate enqueue time.\n   * @param {object} args - Digest input.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job arguments.\n   * @param {import(\"./types.js\").BackgroundJobOptions} args.options - Job options.\n   * @param {PreparedBackgroundJob} args.preparedJob - Normalized job.\n   * @returns {string} - SHA-256 digest.\n   */\n  _idempotencyRequestDigest({args, options, preparedJob}) {\n    const serialized = stableJsonStringify({\n      args,\n      concurrency: preparedJob.concurrency,\n      executionMode: preparedJob.executionMode,\n      format: \"velocious-background-job-idempotency-v1\",\n      jobName: preparedJob.jobName,\n      maxRetries: preparedJob.maxRetries,\n      queue: preparedJob.queue,\n      scheduledAtMs: options.scheduledAtMs === undefined ? null : preparedJob.scheduledAtMs,\n      scheduling: options.scheduledAtMs === undefined ? \"immediate\" : \"scheduled\",\n      ...(preparedJob.timeoutMs === null ? {} : {timeoutMs: preparedJob.timeoutMs})\n    })\n\n    return createHash(\"sha256\").update(serialized).digest(\"hex\")\n  }\n\n  /**\n   * Fixed-size globally indexed representation of the documented scope tuple.\n   * @param {object} args - Scope input.\n   * @param {string} args.idempotencyKey - Caller key.\n   * @param {string} args.jobName - Job class name.\n   * @param {string} args.queue - Queue name.\n   * @returns {string} - SHA-256 scope digest.\n   */\n  _idempotencyScopeDigest({idempotencyKey, jobName, queue}) {\n    return createHash(\"sha256\")\n      .update(stableJsonStringify({format: \"velocious-background-job-idempotency-scope-v1\", idempotencyKey, jobName, queue}))\n      .digest(\"hex\")\n  }\n\n  /**\n   * Validates one caller key.\n   * @param {string | undefined} idempotencyKey - Caller key.\n   * @returns {string} - Valid key.\n   */\n  _normalizeIdempotencyKey(idempotencyKey) {\n    if (typeof idempotencyKey !== \"string\" || idempotencyKey.length === 0) {\n      throw VelociousError.safe(\"Background job idempotencyKey must be a non-empty string.\", {\n        code: \"background-job-idempotency-key-invalid\"\n      })\n    }\n\n    return idempotencyKey\n  }\n\n  /**\n   * Canonical request identity for an internal owned-handoff replay.\n   * Immediate enqueue wall time and generated job ids remain excluded.\n   * @param {object} args - Digest input.\n   * @param {import(\"./types.js\").BackgroundJobOptions} args.options - Enqueue options.\n   * @param {PreparedBackgroundJob} args.preparedJob - Normalized job.\n   * @returns {string} - SHA-256 digest.\n   */\n  _ownedEnqueueRequestDigest({options, preparedJob}) {\n    const serialized = stableJsonStringify({\n      argsJson: preparedJob.argsJson,\n      concurrency: preparedJob.concurrency,\n      deduplicateWhileQueued: options.deduplicateWhileQueued === true,\n      executionMode: preparedJob.executionMode,\n      format: \"velocious-background-job-owned-enqueue-v1\",\n      jobName: preparedJob.jobName,\n      maxRetries: preparedJob.maxRetries,\n      queue: preparedJob.queue,\n      scheduledAtMs: options.scheduledAtMs === undefined ? null : preparedJob.scheduledAtMs,\n      scheduling: options.scheduledAtMs === undefined ? \"immediate\" : \"scheduled\",\n      ...(preparedJob.timeoutMs === null ? {} : {timeoutMs: preparedJob.timeoutMs})\n    })\n\n    return createHash(\"sha256\").update(serialized).digest(\"hex\")\n  }\n\n  /**\n   * Isolates internal producer replay ownership from caller idempotency scopes.\n   * @param {object} args - Scope input.\n   * @param {PreparedBackgroundJob} args.preparedJob - Normalized job.\n   * @param {string} args.producerInvocationId - Stable identity for one owned enqueue invocation.\n   * @param {import(\"./types.js\").BackgroundJobProducerProof} args.producerProof - Exact producer lease.\n   * @param {string} args.requestDigest - Canonical request digest.\n   * @returns {string} - SHA-256 scope digest.\n   */\n  _ownedEnqueueScopeDigest({preparedJob, producerInvocationId, producerProof, requestDigest}) {\n    return createHash(\"sha256\")\n      .update(stableJsonStringify({\n        format: \"velocious-background-job-owned-enqueue-scope-v1\",\n        jobName: preparedJob.jobName,\n        producerInvocationId,\n        producerProof,\n        queue: preparedJob.queue,\n        requestDigest\n      }))\n      .digest(\"hex\")\n  }\n\n  /**\n   * Validates the untrusted identity of one producer-owned enqueue invocation.\n   * @param {string | undefined} producerInvocationId - Producer invocation identity.\n   * @returns {string} - Validated identity.\n   */\n  _normalizeProducerInvocationId(producerInvocationId) {\n    if (typeof producerInvocationId !== \"string\" || producerInvocationId.length === 0) {\n      throw VelociousError.safe(\"Background job producer invocation id is invalid.\", {\n        code: \"background-job-producer-invocation-id-invalid\"\n      })\n    }\n\n    return producerInvocationId\n  }\n\n  /**\n   * Validates the untrusted transport shape before transaction admission.\n   * @param {import(\"./types.js\").BackgroundJobProducerProof} producerProof - Producer proof.\n   * @returns {import(\"./types.js\").BackgroundJobProducerProof} - Normalized immutable proof.\n   */\n  _normalizeProducerProof(producerProof) {\n    const exactKeys = [\"handedOffAtMs\", \"handoffId\", \"jobId\", \"workerId\"]\n    const keys = producerProof && typeof producerProof === \"object\" ? Object.keys(producerProof) : []\n    const valid = producerProof\n      && typeof producerProof === \"object\"\n      && keys.length === exactKeys.length\n      && keys.every((key) => exactKeys.includes(key))\n      && typeof producerProof.jobId === \"string\"\n      && producerProof.jobId.length > 0\n      && typeof producerProof.handoffId === \"string\"\n      && producerProof.handoffId.length > 0\n      && typeof producerProof.workerId === \"string\"\n      && producerProof.workerId.length > 0\n      && Number.isSafeInteger(producerProof.handedOffAtMs)\n      && producerProof.handedOffAtMs >= 0\n\n    if (!valid) {\n      throw VelociousError.safe(\"Background job producer proof is invalid.\", {\n        code: \"background-job-producer-proof-invalid\"\n      })\n    }\n\n    return Object.freeze({\n      handedOffAtMs: producerProof.handedOffAtMs,\n      handoffId: producerProof.handoffId,\n      jobId: producerProof.jobId,\n      workerId: producerProof.workerId\n    })\n  }\n\n  /**\n   * Confirms exact active ownership while the enqueue transaction holds the\n   * shared mutation fence used by terminal producer transitions.\n   * @param {import(\"../database/drivers/base.js\").default} db - Transaction connection.\n   * @param {import(\"./types.js\").BackgroundJobProducerProof} producerProof - Exact producer lease.\n   * @returns {Promise<void>} - Resolves while ownership remains exact.\n   */\n  async _validateOwnedProducerProof(db, producerProof) {\n    const producer = await this._getJobRowById(db, producerProof.jobId)\n    const owned = producer\n      && producer.status === \"handed_off\"\n      && producer.handoffId === producerProof.handoffId\n      && producer.workerId === producerProof.workerId\n      && producer.handedOffAtMs === producerProof.handedOffAtMs\n\n    if (!owned) {\n      throw VelociousError.safe(\"Background job producer handoff is no longer owned.\", {\n        code: \"background-job-producer-handoff-not-owned\"\n      })\n    }\n  }\n\n  /**\n   * Replaces the queued owner of a stable schedule key with a new one-off job.\n   * A handed-off owner is left running and reported truthfully.\n   * @param {object} args - Options.\n   * @param {string} args.scheduleKey - Stable logical schedule key.\n   * @param {string} args.jobName - Job name.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Arguments.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Options.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobReplacementResult>} - Replacement result.\n   */\n  async replaceScheduled({scheduleKey, jobName, args, options}) {\n    await this.ensureReady()\n\n    const normalizedScheduleKey = this._normalizeScheduleKey(scheduleKey)\n    const preparedJob = this._prepareJob({jobName, args, options})\n\n    return await this._serializedCountMutation(async (db) => {\n      const ownerRows = await db\n        .newQuery()\n        .from(SCHEDULE_KEYS_TABLE)\n        .where({schedule_key: normalizedScheduleKey})\n        .limit(1)\n        .results()\n      const ownerJobId = ownerRows[0] ? String(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (ownerRows[0]).job_id) : null\n      const ownerJob = ownerJobId ? await this._getJobRowById(db, ownerJobId) : null\n      /** @type {import(\"./types.js\").BackgroundJobReplacementPreviousStatus} */\n      let previousStatus = null\n      let previousJobId = null\n\n      if (ownerJob?.status === \"queued\") {\n        const affectedRows = await this._updateAffectedRows(db, {\n          tableName: JOBS_TABLE,\n          data: {status: \"cancelled\"},\n          conditions: {id: ownerJob.id, status: \"queued\"}\n        })\n\n        if (affectedRows === 1) {\n          previousJobId = ownerJob.id\n          previousStatus = \"queued\"\n        } else {\n          const currentOwnerJob = await this._getJobRowById(db, ownerJob.id)\n\n          if (currentOwnerJob?.status === \"handed_off\") {\n            previousJobId = currentOwnerJob.id\n            previousStatus = \"handed_off\"\n          }\n        }\n      } else if (ownerJob?.status === \"handed_off\") {\n        previousJobId = ownerJob.id\n        previousStatus = \"handed_off\"\n      }\n\n      const scheduleOrder = await this._nextScheduleOrder(db, normalizedScheduleKey)\n\n      await this._insertPreparedJob(db, {preparedJob, scheduleKey: normalizedScheduleKey, scheduleOrder})\n      await db.upsert({\n        tableName: SCHEDULE_KEYS_TABLE,\n        data: {schedule_key: normalizedScheduleKey, job_id: preparedJob.jobId},\n        conflictColumns: [\"schedule_key\"],\n        updateColumns: [\"job_id\"]\n      })\n\n      if (previousStatus !== \"queued\") await this._recordCountDelta(db, {all: 1, queued: 1})\n      return {jobId: preparedJob.jobId, previousJobId, previousStatus}\n    }, {\n      advisoryLock: {\n        failureMessage: \"Failed to acquire background job schedule-key lock\",\n        name: this._scheduleKeyLockName(normalizedScheduleKey)\n      }\n    })\n  }\n\n  /**\n   * Cancels the queued owner of a stable schedule key. A handed-off owner is\n   * detached but not marked stopped because execution may already be running.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobCancellationResult>} - Cancellation result.\n   */\n  async cancelScheduled(scheduleKey) {\n    await this.ensureReady()\n\n    const normalizedScheduleKey = this._normalizeScheduleKey(scheduleKey)\n\n    return await this._serializedCountMutation(async (db) => {\n      const ownerRows = await db\n        .newQuery()\n        .from(SCHEDULE_KEYS_TABLE)\n        .where({schedule_key: normalizedScheduleKey})\n        .limit(1)\n        .results()\n\n      if (!ownerRows[0]) return {jobId: null, outcome: \"not_found\"}\n\n      const jobId = String(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (ownerRows[0]).job_id)\n      const job = await this._getJobRowById(db, jobId)\n\n      if (job?.status === \"queued\") {\n        const affectedRows = await this._updateAffectedRows(db, {\n          tableName: JOBS_TABLE,\n          data: {status: \"cancelled\"},\n          conditions: {id: job.id, status: \"queued\"}\n        })\n\n        if (affectedRows === 1) {\n          await this._releaseScheduleOwnership(db, {jobId, scheduleKey: normalizedScheduleKey})\n          await this._recordStatusTransition(db, \"queued\", \"cancelled\")\n\n          return {jobId, outcome: \"cancelled\"}\n        }\n      }\n\n      const currentJob = await this._getJobRowById(db, jobId)\n\n      await this._releaseScheduleOwnership(db, {jobId, scheduleKey: normalizedScheduleKey})\n\n      if (currentJob?.status === \"handed_off\") return {jobId, outcome: \"handed_off\"}\n      return {jobId: null, outcome: \"not_found\"}\n    }, {\n      advisoryLock: {\n        failureMessage: \"Failed to acquire background job schedule-key lock\",\n        name: this._scheduleKeyLockName(normalizedScheduleKey)\n      }\n    })\n  }\n\n  /**\n   * Reads stable ownership and optional latest terminal history in one fenced transaction.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @param {{includeLatestTerminal?: boolean}} [options] - Lookup options.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobScheduledLookupResult>} - Normalized public jobs.\n   */\n  async getScheduledJob(scheduleKey, {includeLatestTerminal = false} = {}) {\n    await this.ensureReady()\n\n    const normalizedScheduleKey = this._normalizeScheduleKey(scheduleKey)\n\n    if (typeof includeLatestTerminal !== \"boolean\") {\n      throw VelociousError.safe(\"background job includeLatestTerminal must be a boolean\")\n    }\n\n    return await this._serializedCountMutation(async (db) => {\n      return await this._scheduledJobLookup(db, {\n        includeLatestTerminal,\n        scheduleKey: normalizedScheduleKey\n      })\n    }, {\n      advisoryLock: {\n        failureMessage: \"Failed to acquire background job schedule-key lock\",\n        name: this._scheduleKeyLockName(normalizedScheduleKey)\n      }\n    })\n  }\n\n  /**\n   * Moves only a future queued stable owner to the current time.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobWakeResult>} - Exact wake outcome.\n   */\n  async wakeScheduled(scheduleKey) {\n    await this.ensureReady()\n\n    const normalizedScheduleKey = this._normalizeScheduleKey(scheduleKey)\n\n    return await this._serializedCountMutation(async (db) => {\n      const job = await this._scheduledOwnerJob(db, normalizedScheduleKey)\n\n      if (!job || (job.status !== \"queued\" && job.status !== \"handed_off\")) return {jobId: null, outcome: \"not_found\"}\n      if (job.status === \"handed_off\") return {jobId: job.id, outcome: \"handed_off\"}\n\n      const nowMs = this.clock.now()\n\n      if (Number(job.scheduledAtMs) <= nowMs) return {jobId: job.id, outcome: \"already_due\"}\n\n      const affectedRows = await this._updateAffectedRows(db, {\n        tableName: JOBS_TABLE,\n        data: {scheduled_at_ms: nowMs},\n        conditions: {id: job.id, scheduled_at_ms: job.scheduledAtMs, status: \"queued\"}\n      })\n\n      if (affectedRows === 1) return {jobId: job.id, outcome: \"woken\"}\n\n      const currentJob = await this._scheduledOwnerJob(db, normalizedScheduleKey)\n\n      if (currentJob?.status === \"handed_off\") return {jobId: currentJob.id, outcome: \"handed_off\"}\n      if (currentJob?.status === \"queued\" && Number(currentJob.scheduledAtMs) <= nowMs) {\n        return {jobId: currentJob.id, outcome: \"already_due\"}\n      }\n\n      return {jobId: null, outcome: \"not_found\"}\n    }, {\n      advisoryLock: {\n        failureMessage: \"Failed to acquire background job schedule-key lock\",\n        name: this._scheduleKeyLockName(normalizedScheduleKey)\n      }\n    })\n  }\n\n  /**\n   * Runs next available job.\n   * @param {object} [args] - Options.\n   * @param {import(\"./types.js\").BackgroundJobExecutionMode | import(\"./types.js\").BackgroundJobExecutionMode[]} [args.executionMode] - Execution mode or modes to match.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Next job.\n   */\n  async nextAvailableJob(args = {}) {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      return await this._nextQueuedJob({\n        db,\n        scheduledAtOperator: \"<=\",\n        executionMode: args.executionMode\n      })\n    })\n  }\n\n  /**\n   * Returns the soonest future-scheduled queued job (one whose\n   * `scheduled_at_ms` is in the future), or null when there are no\n   * future-scheduled jobs. Used by the event-driven dispatcher to arm a\n   * `setTimeout` for the exact moment the next scheduled job becomes\n   * eligible, replacing the legacy 1-second polling loop.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Soonest future-scheduled job, or null.\n   */\n  async nextScheduledJob() {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      return await this._nextQueuedJob({db, scheduledAtOperator: \">\"})\n    })\n  }\n\n  /**\n   * Runs next queued job.\n   * @param {object} args - Options.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Database connection.\n   * @param {\"<=\" | \">\"} args.scheduledAtOperator - Scheduled timestamp operator.\n   * @param {import(\"./types.js\").BackgroundJobExecutionMode | import(\"./types.js\").BackgroundJobExecutionMode[]} [args.executionMode] - Execution mode or modes to match.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Next matching queued job.\n   */\n  async _nextQueuedJob({db, scheduledAtOperator, executionMode}) {\n    const now = this.clock.now()\n    let query = db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .where({status: \"queued\"})\n      .where(`scheduled_at_ms ${scheduledAtOperator} ${db.quote(now)}`)\n\n    if (scheduledAtOperator === \"<=\") {\n      const jobsTable = db.quoteTable(JOBS_TABLE)\n      const concurrencyTable = db.quoteTable(CONCURRENCY_TABLE)\n      query = query.where(\n        `(${jobsTable}.${db.quoteColumn(\"concurrency_key\")} IS NULL OR EXISTS (` +\n        `SELECT 1 FROM ${concurrencyTable} WHERE ` +\n        `${concurrencyTable}.${db.quoteColumn(\"concurrency_key\")} = ${jobsTable}.${db.quoteColumn(\"concurrency_key\")} AND ` +\n        `${concurrencyTable}.${db.quoteColumn(\"active_count\")} < ${concurrencyTable}.${db.quoteColumn(\"max_concurrency\")}))`\n      )\n    }\n\n    if (executionMode) query = this._whereExecutionMode({db, executionMode, query})\n\n    if (scheduledAtOperator === \"<=\") {\n      const priorityOrder = this._queuePriorityOrderSql(db)\n\n      if (priorityOrder) query = query.order(`${priorityOrder} DESC`)\n    }\n\n    query = query\n      .order(\"scheduled_at_ms ASC\")\n      .order(\"created_at_ms ASC\")\n      .limit(1)\n\n    const rows = await query.results()\n    const row = rows[0]\n\n    if (!row) return null\n\n    return this._normalizeJobRow(row)\n  }\n\n  /**\n   * Builds a raw SQL ORDER BY expression ranking queued jobs by their queue's\n   * configured priority (`backgroundJobs.queues[queue].priority`, default `0`),\n   * so the dispatcher picks higher-priority queues first regardless of enqueue\n   * order. Only applied to the dispatch path (`scheduledAtOperator === \"<=\"`);\n   * the future-scheduled lookup must stay strictly time-ordered. Composes with\n   * the concurrency EXISTS filter: a higher-priority queue already at its cap is\n   * filtered out, so dispatch falls through to the next eligible lower-priority\n   * job. Returns null when no queue configures a non-zero priority so the plain\n   * FIFO ordering is left untouched (and no needless filesort is introduced).\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {string | null} - Raw SQL CASE expression, or null when no queue is prioritized.\n   */\n  _queuePriorityOrderSql(db) {\n    const queues = this.configuration.getBackgroundJobsConfig().queues || {}\n    /** @type {Array<[string, number]>} */\n    const prioritized = []\n\n    for (const [queue, queueConfig] of Object.entries(queues)) {\n      const priority = queueConfig?.priority\n\n      if (Number.isFinite(priority) && Number(priority) !== 0) prioritized.push([queue, Number(priority)])\n    }\n\n    if (prioritized.length === 0) return null\n\n    const queueColumn = db.quoteColumn(\"queue\")\n    const whens = prioritized\n      .map(([queue, priority]) => `WHEN ${db.quote(queue)} THEN ${priority}`)\n      .join(\" \")\n\n    return `CASE COALESCE(${queueColumn}, ${db.quote(DEFAULT_BACKGROUND_JOB_QUEUE)}) ${whens} ELSE 0 END`\n  }\n\n  /**\n   * Runs get job.\n   * @param {string} jobId - Job id.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Job row.\n   */\n  async getJob(jobId) {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      const query = db\n        .newQuery()\n        .from(JOBS_TABLE)\n        .where({id: jobId})\n        .limit(1)\n\n      const rows = await query.results()\n      const row = rows[0]\n\n      if (!row) return null\n\n      return this._normalizeJobRow(row)\n    })\n  }\n\n  /**\n   * Counts jobs grouped by status. Used by the dashboard overview.\n   * @returns {Promise<Record<string, number>>} - Counts keyed by status.\n   */\n  async countsByStatus() {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      const rows = await db\n        .newQuery()\n        .from(JOBS_TABLE)\n        .select(\"status\")\n        .select(\"COUNT(*) AS count\")\n        .group(\"status\")\n        .results()\n\n      /**\n       * Counts.\n       * @type {Record<string, number>} */\n      const counts = {}\n\n      for (const row of rows) {\n        const typedRow = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (row)\n\n        counts[String(typedRow.status)] = this._normalizeNumber(typedRow.count) || 0\n      }\n\n      return counts\n    })\n  }\n\n  /**\n   * Returns the authoritative dashboard count snapshot and its matching durable\n   * revision. Locking the revision row before counting prevents a writer from\n   * committing between the count query and revision read.\n   * @returns {Promise<{counts: Record<string, number>, revision: number, total: number}>} Snapshot.\n   */\n  async countSnapshot() {\n    await this.ensureReady()\n\n    return await this._serializedCountMutation(async (db) => {\n      return await this._countSnapshotOnLockedConnection(db)\n    })\n  }\n\n  /**\n   * Counts jobs matching the given filters.\n   * @param {object} [args] - Options.\n   * @param {string} [args.status] - Filter by status.\n   * @param {string} [args.jobName] - Filter by job name.\n   * @returns {Promise<number>} - Matching job count.\n   */\n  async countJobs({status, jobName} = {}) {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      let query = db.newQuery().from(JOBS_TABLE).select(\"COUNT(*) AS count\")\n\n      if (status) query = query.where({status})\n      if (jobName) query = query.where({job_name: jobName})\n\n      const rows = await query.results()\n      const countRow = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (rows[0] || {})\n\n      return this._normalizeNumber(countRow.count) || 0\n    })\n  }\n\n  /**\n   * Lists jobs for the dashboard, filtered, sorted and paginated.\n   * @param {object} [args] - Options.\n   * @param {string} [args.status] - Filter by status.\n   * @param {string} [args.jobName] - Filter by job name.\n   * @param {number} [args.limit] - Maximum rows to return.\n   * @param {number} [args.offset] - Rows to skip.\n   * @param {string} [args.sortColumn] - Camel-cased column to sort by (see SORTABLE_COLUMNS).\n   * @param {\"ASC\" | \"DESC\"} [args.sortDirection] - Sort direction.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow[]>} - Normalized job rows.\n   */\n  async listJobs({status, jobName, limit = 25, offset = 0, sortColumn = \"createdAtMs\", sortDirection = \"DESC\"} = {}) {\n    await this.ensureReady()\n\n    const column = SORTABLE_COLUMNS[sortColumn] || SORTABLE_COLUMNS.createdAtMs\n    const direction = sortDirection === \"ASC\" ? \"ASC\" : \"DESC\"\n\n    return await this._withDb(async (db) => {\n      let query = db.newQuery().from(JOBS_TABLE)\n\n      if (status) query = query.where({status})\n      if (jobName) query = query.where({job_name: jobName})\n\n      query = query.order({column, direction})\n      if (column !== SORTABLE_COLUMNS.createdAtMs) query = query.order({column: SORTABLE_COLUMNS.createdAtMs, direction: \"DESC\"})\n\n      const rows = await query.limit(limit).offset(offset).results()\n\n      return rows.map((row) => this._normalizeJobRow(row))\n    })\n  }\n\n  /**\n   * Runs mark handed off.\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {string} [args.handoffId] - Caller-selected exact lease id. Generated for legacy direct callers when omitted.\n   * @param {string} [args.workerId] - Worker id.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobHandoff | null>} - Claimed handoff lease, or null when no longer queued.\n   */\n  async markHandedOff({jobId, handoffId = randomUUID(), workerId}) {\n    await this.ensureReady()\n\n    const handedOffAtMs = this.clock.now()\n\n    return await this._serializedCountMutation(async (db) => {\n      const selectedJob = await this._getJobRowById(db, jobId)\n      if (!selectedJob || selectedJob.status !== \"queued\") return null\n      const queuedJob = await this._reconcileQueuedJobConcurrency(db, selectedJob)\n\n      if (!queuedJob) return null\n      if (queuedJob.concurrencyKey && !(await this._reserveConcurrency(db, queuedJob.concurrencyKey))) return null\n      const affectedRows = await this._updateAffectedRows(db, {\n        tableName: JOBS_TABLE,\n        data: {\n          status: \"handed_off\",\n          handed_off_at_ms: handedOffAtMs,\n          handoff_id: handoffId,\n          worker_id: workerId || null,\n          ...this._clearedChildAcceptanceData()\n        },\n        conditions: {concurrency_key: queuedJob.concurrencyKey, id: jobId, status: \"queued\"}\n      })\n\n      if (affectedRows !== 1) {\n        await this._releaseConcurrency(db, queuedJob.concurrencyKey)\n        return null\n      }\n\n      await this._recordStatusTransition(db, \"queued\", \"handed_off\")\n      /** @type {import(\"./types.js\").BackgroundJobRow} */\n      const handedOffJob = {\n        ...queuedJob,\n        ...this._clearedChildAcceptanceRow(),\n        handedOffAtMs,\n        handoffId,\n        status: \"handed_off\",\n        workerId: workerId || null\n      }\n\n      return {handedOffAtMs, handoffId, job: handedOffJob}\n    })\n  }\n\n  /**\n   * Runs mark completed.\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {string} [args.handoffId] - Handoff lease id.\n   * @param {string} [args.workerId] - Worker id.\n   * @param {number} [args.handedOffAtMs] - Handed off timestamp.\n   * @returns {Promise<boolean>} - Whether the fenced report was accepted.\n   */\n  async markCompleted({jobId, handoffId, workerId, handedOffAtMs}) {\n    await this.ensureReady()\n\n    return await this._serializedCountMutation(async (db) => {\n      const job = await this._getJobRowById(db, jobId)\n\n      if (!job) return false\n      if (!this._shouldAcceptReport({job, handoffId, workerId, handedOffAtMs})) return false\n\n      await this._lockConcurrencyRow(db, job.concurrencyKey)\n      const affectedRows = await this._updateAffectedRows(db, {\n        tableName: JOBS_TABLE,\n        data: {\n          status: \"completed\",\n          completed_at_ms: this.clock.now()\n        },\n        conditions: this._activeHandoffConditions(job)\n      })\n\n      if (affectedRows !== 1) return false\n      await this._releaseScheduleOwnershipForJob(db, job)\n      await this._releaseConcurrency(db, job.concurrencyKey)\n      await this._recordStatusTransition(db, \"handed_off\", \"completed\")\n      return true\n    })\n  }\n\n  /**\n   * Records pooled-child acceptance evidence for an active handoff: when the\n   * executing runner child received and/or started the job, plus that child's\n   * stable identity and pid. Only the fields supplied are written, so a\n   * received-then-started observation lands as two fenced partial updates. The\n   * update is fenced by the exact active handoff lease, so a report for a\n   * reclaimed or re-handed-off job is dropped instead of stamping the wrong\n   * attempt.\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {string} [args.handoffId] - Handoff lease id.\n   * @param {string} [args.workerId] - Worker id.\n   * @param {number} [args.handedOffAtMs] - Handed off timestamp.\n   * @param {number} [args.receivedAtMs] - Epoch ms the runner child received the job.\n   * @param {number} [args.startedAtMs] - Epoch ms the job's perform started in the child.\n   * @param {string} [args.childInstanceId] - Stable pooled child identity.\n   * @param {number} [args.childPid] - Pooled child OS pid.\n   * @returns {Promise<boolean>} - Whether the fenced report was accepted.\n   */\n  async markChildAccepted({jobId, handoffId, workerId, handedOffAtMs, receivedAtMs, startedAtMs, childInstanceId, childPid}) {\n    await this.ensureReady()\n\n    return await this._serializedConnectionMutation(async (db) => {\n      const job = await this._getJobRowById(db, jobId)\n\n      if (!job) return false\n      if (!this._shouldAcceptReport({job, handoffId, workerId, handedOffAtMs})) return false\n\n      const data = {}\n      if (typeof receivedAtMs === \"number\") data.child_received_at_ms = receivedAtMs\n      if (typeof startedAtMs === \"number\") data.child_started_at_ms = startedAtMs\n      if (typeof childInstanceId === \"string\") data.child_instance_id = childInstanceId\n      if (typeof childPid === \"number\") data.child_pid = childPid\n      if (Object.keys(data).length === 0) return false\n\n      const affectedRows = await this._updateAffectedRows(db, {\n        tableName: JOBS_TABLE,\n        data,\n        conditions: this._activeHandoffConditions(job)\n      })\n\n      return affectedRows === 1\n    })\n  }\n\n  /**\n   * Returns the database data that clears pooled-child acceptance evidence.\n   * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Cleared acceptance columns.\n   */\n  _clearedChildAcceptanceData() {\n    return {child_instance_id: null, child_pid: null, child_received_at_ms: null, child_started_at_ms: null}\n  }\n\n  /**\n   * Returns the row-shape counterpart of the cleared acceptance columns.\n   * @returns {Pick<import(\"./types.js\").BackgroundJobRow, \"childInstanceId\" | \"childPid\" | \"childReceivedAtMs\" | \"childStartedAtMs\">} - Cleared acceptance fields.\n   */\n  _clearedChildAcceptanceRow() {\n    return {childInstanceId: null, childPid: null, childReceivedAtMs: null, childStartedAtMs: null}\n  }\n\n  /**\n   * Returns an active handoff to the queue at a caller-requested future time.\n   * This is normal job control flow: it preserves failure attempts and metadata.\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {number} args.delayMs - Delay from persistence time in milliseconds.\n   * @param {string} [args.handoffId] - Handoff lease id.\n   * @param {string} [args.workerId] - Worker id.\n   * @param {number} [args.handedOffAtMs] - Handed off timestamp.\n   * @returns {Promise<boolean>} - Whether the fenced report was accepted.\n   */\n  async markRescheduled({jobId, delayMs, handoffId, workerId, handedOffAtMs}) {\n    await this.ensureReady()\n    this._validateRescheduleDelayMs(delayMs)\n\n    return await this._serializedCountMutation(async (db) => {\n      const job = await this._getJobRowById(db, jobId)\n\n      if (!job) return false\n      if (!this._shouldAcceptReport({job, handoffId, workerId, handedOffAtMs})) return false\n\n      await this._lockConcurrencyRow(db, job.concurrencyKey)\n      const scheduledAtMs = this._rescheduledAtMs(delayMs)\n      const affectedRows = await this._updateAffectedRows(db, {\n        tableName: JOBS_TABLE,\n        data: {\n          status: \"queued\",\n          scheduled_at_ms: scheduledAtMs,\n          handed_off_at_ms: null,\n          handoff_id: null,\n          worker_id: null,\n          ...this._clearedChildAcceptanceData()\n        },\n        conditions: this._activeHandoffConditions(job)\n      })\n\n      if (affectedRows !== 1) return false\n      await this._releaseConcurrency(db, job.concurrencyKey)\n      await this._recordStatusTransition(db, \"handed_off\", \"queued\")\n      return true\n    })\n  }\n\n  /**\n   * Runs mark returned to queue.\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {string} args.handoffId - Handoff lease id.\n   * @returns {Promise<void>} - Resolves when updated.\n   */\n  async markReturnedToQueue({jobId, handoffId}) {\n    await this.ensureReady()\n\n    await this._serializedCountMutation(async (db) => {\n      const job = await this._getJobRowById(db, jobId)\n      if (!job || job.handoffId !== handoffId || job.status !== \"handed_off\") return\n      await this._lockConcurrencyRow(db, job.concurrencyKey)\n      const affectedRows = await this._updateAffectedRows(db, {\n        tableName: JOBS_TABLE,\n        data: {\n          status: \"queued\",\n          scheduled_at_ms: this.clock.now(),\n          handed_off_at_ms: null,\n          handoff_id: null,\n          worker_id: null,\n          ...this._clearedChildAcceptanceData()\n        },\n        conditions: {handoff_id: handoffId, id: jobId, status: \"handed_off\"}\n      })\n      if (affectedRows === 1) {\n        await this._releaseConcurrency(db, job.concurrencyKey)\n        await this._recordStatusTransition(db, \"handed_off\", \"queued\")\n      }\n    })\n  }\n\n  /**\n   * Returns the active `handed_off` jobs (jobId + handoffId) held under a worker\n   * id. Used on worker reconnect: after a main restart a worker reconnects with\n   * its stable id, and the fresh main adopts these leases so they are tracked —\n   * and released if the reconnected worker later disconnects — instead of\n   * sitting stuck until the age-based orphan sweep. This never reclaims, so a\n   * gracefully-draining worker that keeps running its in-flight jobs is left\n   * untouched. Rows with a null handoff id (legacy) are skipped; the orphan\n   * sweep reclaims those via its `handed_off_at_ms` fence.\n   * @param {object} args - Options.\n   * @param {string} args.workerId - Worker id.\n   * @returns {Promise<Array<{jobId: string, handoffId: string}>>} - Active handoffs.\n   */\n  async handedOffJobsForWorker({workerId}) {\n    await this.ensureReady()\n\n    const rows = await this._withDb(async (db) =>\n      await db.newQuery().from(JOBS_TABLE).where({status: \"handed_off\", worker_id: workerId}).results()\n    )\n\n    /** @type {Array<{jobId: string, handoffId: string}>} */\n    const handoffs = []\n\n    for (const row of rows) {\n      const job = this._normalizeJobRow(row)\n\n      if (job.handoffId) handoffs.push({jobId: job.id, handoffId: job.handoffId})\n    }\n\n    return handoffs\n  }\n\n  /**\n   * Snapshots exact, lease-aware active handoffs before a new main generation\n   * starts accepting worker reconnects. Legacy rows without a complete worker,\n   * lease, and timestamp identity stay owned by the age-based orphan sweep.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobHandoffSnapshot[]>} - Exact startup handoffs.\n   */\n  async snapshotHandedOffJobs() {\n    await this.ensureReady()\n\n    const rows = await this._withDb(async (db) => await db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .where({status: \"handed_off\"})\n      .order(\"created_at_ms ASC\")\n      .order(\"id ASC\")\n      .results())\n    /** @type {import(\"./types.js\").BackgroundJobHandoffSnapshot[]} */\n    const handoffs = []\n\n    for (const row of rows) {\n      const job = this._normalizeJobRow(row)\n\n      if (!job.handoffId || !job.workerId || typeof job.handedOffAtMs !== \"number\") continue\n\n      handoffs.push({\n        handedOffAtMs: job.handedOffAtMs,\n        handoffId: job.handoffId,\n        jobId: job.id,\n        workerId: job.workerId\n      })\n    }\n\n    return handoffs\n  }\n\n  /**\n   * Reclaims only unchanged exact handoffs selected by a main-generation startup\n   * snapshot. The ordinary orphan failure path owns retries, terminal status,\n   * count transitions, schedule ownership, and concurrency release.\n   * @param {object} args - Options.\n   * @param {import(\"./types.js\").BackgroundJobHandoffSnapshot[]} args.handoffs - Exact startup snapshots.\n   * @param {ReturnType<typeof JSON.parse>} args.error - Orphan reason.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow[]>} - Accepted transitions.\n   */\n  async markOrphanedHandoffs({handoffs, error}) {\n    await this.ensureReady()\n\n    return await this._serializedCountMutation(async (db) => {\n      /** @type {BackgroundJobOrphanSelection[]} */\n      const selections = []\n\n      for (const handoff of handoffs) {\n        const job = await this._getJobRowById(db, handoff.jobId)\n\n        if (!job || job.status !== \"handed_off\") continue\n        if (job.handoffId !== handoff.handoffId) continue\n        if (job.workerId !== handoff.workerId) continue\n        if (job.handedOffAtMs !== handoff.handedOffAtMs) continue\n\n        selections.push({\n          conditions: {\n            handed_off_at_ms: handoff.handedOffAtMs,\n            handoff_id: handoff.handoffId,\n            id: handoff.jobId,\n            status: \"handed_off\",\n            worker_id: handoff.workerId\n          },\n          job\n        })\n      }\n\n      return await this._markOrphanSelections({db, error, selections})\n    })\n  }\n\n  /**\n   * Runs mark failed.\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {ReturnType<typeof JSON.parse>} args.error - Error.\n   * @param {string} [args.handoffId] - Handoff lease id.\n   * @param {string} [args.workerId] - Worker id.\n   * @param {number} [args.handedOffAtMs] - Handed off timestamp.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Updated job row when the report was accepted.\n   */\n  async markFailed({jobId, error, handoffId, workerId, handedOffAtMs}) {\n    await this.ensureReady()\n\n    return await this._serializedCountMutation(async (db) => {\n      const job = await this._getJobRowById(db, jobId)\n\n      if (!job) return null\n      if (!this._shouldAcceptReport({job, handoffId, workerId, handedOffAtMs})) return null\n\n      const updatedJob = await this._applyFailure({db, job, error, markOrphaned: false})\n\n      if (updatedJob) await this._recordStatusTransition(db, job.status, updatedJob.status)\n      return updatedJob\n    })\n  }\n\n  /**\n   * Runs mark orphaned jobs.\n   * @param {object} [args] - Options.\n   * @param {number} [args.orphanedAfterMs] - Mark jobs orphaned after this duration.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow[]>} - The jobs this sweep marked orphaned.\n   */\n  async markOrphanedJobs({orphanedAfterMs = ORPHANED_AFTER_MS} = {}) {\n    await this.ensureReady()\n\n    return await this._serializedCountMutation(async (db) => {\n      const cutoff = this.clock.now() - orphanedAfterMs\n      const query = db\n        .newQuery()\n        .from(JOBS_TABLE)\n        .where({status: \"handed_off\"})\n        .where(`handed_off_at_ms <= ${db.quote(cutoff)}`)\n\n      const rows = await query.results()\n\n      /** @type {BackgroundJobOrphanSelection[]} */\n      const selections = []\n\n      for (const row of rows) {\n        const job = this._normalizeJobRow(row)\n\n        // Fence the reclaim on the exact handoff this sweep selected, using its\n        // `handed_off_at_ms` rather than its `handoff_id`. Two reasons:\n        //   1. Null-safe. Some rows have a null `handoff_id` (handed off by an\n        //      older velocious before handoff-id fencing). `{handoff_id: null}`\n        //      renders as `handoff_id = NULL`, which matches nothing, so those\n        //      rows would be stranded in `handed_off` forever.\n        //   2. Race-safe. If the row is returned to the queue and re-handed-off\n        //      between the SELECT above and this update, it gets a fresh\n        //      `handed_off_at_ms` (always \"now\"), so this stale cutoff-era\n        //      timestamp no longer matches and we won't fail/orphan — or\n        //      wrongly release the concurrency reservation of — that new lease.\n        // `handed_off_at_ms` is always set on a handed-off row (and the SELECT\n        // required it `<= cutoff`), so it is a reliable null-safe lease pin.\n        selections.push({\n          conditions: {id: job.id, status: \"handed_off\", handed_off_at_ms: job.handedOffAtMs},\n          job\n        })\n      }\n\n      return await this._markOrphanSelections({\n        db,\n        error: \"Job orphaned after timeout\",\n        selections\n      })\n    })\n  }\n\n  /**\n   * Applies the common fenced orphan transition and records one aggregate count\n   * delta for the accepted rows.\n   * @param {object} args - Options.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Transaction connection.\n   * @param {ReturnType<typeof JSON.parse>} args.error - Orphan reason.\n   * @param {BackgroundJobOrphanSelection[]} args.selections - Selected handoffs and exact fences.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow[]>} - Accepted transitions.\n   */\n  async _markOrphanSelections({db, error, selections}) {\n    /** @type {import(\"./types.js\").BackgroundJobRow[]} */\n    const orphanedJobs = []\n\n    for (const {conditions, job} of selections) {\n      const orphanedJob = await this._applyFailure({\n        conditions,\n        db,\n        error,\n        job,\n        markOrphaned: true\n      })\n\n      if (orphanedJob) orphanedJobs.push(orphanedJob)\n    }\n\n    const statusCounts = this._statusCounts(orphanedJobs)\n    const deltas = this._emptyCountBuckets()\n\n    for (const [status, count] of Object.entries(statusCounts)) {\n      deltas.handed_off -= count\n      deltas[status] += count\n    }\n    await this._recordCountDelta(db, deltas)\n\n    return orphanedJobs\n  }\n\n  /**\n   * Deletes terminal job rows past their retention window so the jobs table\n   * does not grow unbounded (completed rows in particular accumulate forever\n   * otherwise). Batched by id — SELECT a page of ids, then\n   * `DELETE ... WHERE id IN (...)` — rather than `DELETE ... LIMIT`, which not\n   * every driver supports; each batch runs on its own connection so the sweep\n   * yields between batches instead of holding one long transaction.\n   * @param {object} [args] - Options.\n   * @param {number | null} [args.completedTtlMs] - Delete `completed` jobs whose `completed_at_ms` is older than this many ms. Falsy or `<= 0` disables completed pruning.\n   * @param {number | null} [args.failedTtlMs] - Delete terminal `failed`/`orphaned` jobs older than this many ms (by `failed_at_ms`/`orphaned_at_ms`). Falsy or `<= 0` disables.\n   * @param {number} [args.batchSize] - Max rows deleted per batch. Default `1000`.\n   * @returns {Promise<number>} - Total rows deleted.\n   */\n  async pruneTerminalJobs({completedTtlMs = null, failedTtlMs = null, batchSize = 1000} = {}) {\n    await this.ensureReady()\n\n    const now = this.clock.now()\n    const size = batchSize > 0 ? batchSize : 1000\n    let deleted = 0\n\n    if (completedTtlMs && completedTtlMs > 0) {\n      deleted += await this._pruneStatusBatches({status: \"completed\", column: \"completed_at_ms\", cutoff: now - completedTtlMs, batchSize: size})\n    }\n\n    if (failedTtlMs && failedTtlMs > 0) {\n      deleted += await this._pruneStatusBatches({status: \"failed\", column: \"failed_at_ms\", cutoff: now - failedTtlMs, batchSize: size})\n      deleted += await this._pruneStatusBatches({status: \"orphaned\", column: \"orphaned_at_ms\", cutoff: now - failedTtlMs, batchSize: size})\n    }\n\n    return deleted\n  }\n\n  /**\n   * Deletes rows of one terminal status older than a cutoff, batch by batch,\n   * until a page returns fewer than `batchSize` rows.\n   * @param {object} args - Options.\n   * @param {string} args.status - Terminal status to prune.\n   * @param {string} args.column - Timestamp column compared against the cutoff.\n   * @param {number} args.cutoff - Delete rows whose column value is `<= cutoff`.\n   * @param {number} args.batchSize - Max rows per batch.\n   * @returns {Promise<number>} - Rows deleted for this status.\n   */\n  async _pruneStatusBatches({status, column, cutoff, batchSize}) {\n    let deleted = 0\n\n    for (;;) {\n      const removed = await this._serializedCountMutation(async (db) => {\n        const rows = await db\n          .newQuery()\n          .from(JOBS_TABLE)\n          .select(\"id\")\n          .where({status})\n          .where(`${db.quoteColumn(column)} <= ${db.quote(cutoff)}`)\n          .limit(batchSize)\n          .results()\n\n        if (rows.length === 0) return 0\n\n        const ids = rows.map((/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ row) => db.quote(String(row.id))).join(\", \")\n\n        const removed = await db.affectedRows(\n          `DELETE FROM ${db.quoteTable(JOBS_TABLE)} WHERE ${db.quoteColumn(\"id\")} IN (${ids})`\n        )\n\n        await this._recordCountDelta(db, {all: -removed, [status]: -removed})\n\n        return removed\n      })\n\n      deleted += removed\n      if (removed < batchSize) break\n    }\n\n    return deleted\n  }\n\n  /**\n   * Runs clear all.\n   * @returns {Promise<void>} - Resolves when cleared.\n   */\n  async clearAll() {\n    await this.ensureReady()\n\n    await this._serializedCountMutation(async (db) => {\n      const snapshot = await this._countSnapshotOnLockedConnection(db)\n      if (await db.tableExists(MAIL_DELIVERY_OPERATIONS_TABLE)) await db.query(`DELETE FROM ${db.quoteTable(MAIL_DELIVERY_OPERATIONS_TABLE)}`)\n      if (await db.tableExists(IDEMPOTENCY_KEYS_TABLE)) await db.query(`DELETE FROM ${db.quoteTable(IDEMPOTENCY_KEYS_TABLE)}`)\n      if (await db.tableExists(SCHEDULE_KEYS_TABLE)) await db.query(`DELETE FROM ${db.quoteTable(SCHEDULE_KEYS_TABLE)}`)\n      if (await db.tableExists(SCHEDULE_ORDER_WATERMARKS_TABLE)) {\n        const watermarkRows = await db\n          .newQuery()\n          .from(SCHEDULE_ORDER_WATERMARKS_TABLE)\n          .select(\"schedule_key\")\n          .results()\n\n        for (const watermarkRow of watermarkRows) {\n          await db.delete({\n            tableName: SCHEDULE_ORDER_WATERMARKS_TABLE,\n            conditions: {\n              schedule_key: String(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (watermarkRow).schedule_key)\n            }\n          })\n        }\n      }\n      await db.query(`DELETE FROM ${db.quoteTable(JOBS_TABLE)}`)\n      if (await db.tableExists(CONCURRENCY_TABLE)) await db.query(`DELETE FROM ${db.quoteTable(CONCURRENCY_TABLE)}`)\n      const deltas = Object.fromEntries(Object.entries(snapshot.counts).map(([key, value]) => [key, -value]))\n      await this._recordCountDelta(db, deltas)\n    })\n  }\n\n  /**\n   * Cancels a queued or handed-off job and releases any durable concurrency reservation.\n   * @param {string} jobId - Job id.\n   * @returns {Promise<boolean>} - Whether the job was cancelled.\n   */\n  async cancel(jobId) {\n    await this.ensureReady()\n    return await this._serializedCountMutation(async (db) => {\n      const job = await this._getJobRowById(db, jobId)\n      if (!job || (job.status !== \"queued\" && job.status !== \"handed_off\")) return false\n      // Only a handed_off job holds a concurrency reservation, so only that case touches the\n      // shared counter row and needs the concurrency-then-job lock ordering.\n      if (job.status === \"handed_off\") await this._lockConcurrencyRow(db, job.concurrencyKey)\n      const affectedRows = await this._updateAffectedRows(db, {tableName: JOBS_TABLE, data: {status: \"cancelled\"}, conditions: {id: job.id, status: job.status}})\n      if (affectedRows !== 1) return false\n      await this._releaseScheduleOwnershipForJob(db, job)\n      if (job.status === \"handed_off\") await this._releaseConcurrency(db, job.concurrencyKey)\n      await this._recordStatusTransition(db, job.status, \"cancelled\")\n      return true\n    })\n  }\n\n  /**\n   * Runs get retry delay ms.\n   * @param {number} retryCount - Retry attempt count (1-based).\n   * @returns {number} - Delay in milliseconds.\n   */\n  getRetryDelayMs(retryCount) {\n    return retryDelayMs(retryCount)\n  }\n\n  /**\n   * Normalizes one new job before entering its persistence transaction.\n   * @param {object} args - Job input.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Job arguments.\n   * @param {string} args.jobName - Job name.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @returns {PreparedBackgroundJob} - Prepared job.\n   */\n  _prepareJob({args, jobName, options}) {\n    const createdAtMs = this.clock.now()\n    const queue = this._normalizeQueue(options)\n\n    return {\n      argsJson: JSON.stringify(args || []),\n      concurrency: this._resolveConcurrency(options, queue),\n      createdAtMs,\n      executionMode: this._normalizeExecutionMode(options),\n      jobId: randomUUID(),\n      jobName,\n      maxRetries: this._normalizeMaxRetries(options?.maxRetries),\n      queue,\n      scheduledAtMs: this._normalizeScheduledAtMs(options?.scheduledAtMs, createdAtMs),\n      timeoutMs: this._normalizeJobTimeoutMs(options)\n    }\n  }\n\n  /**\n   * Normalizes a per-job timeout while preserving omitted (worker fallback)\n   * separately from explicitly disabled.\n   * @param {import(\"./types.js\").BackgroundJobOptions | undefined} options - Job options.\n   * @returns {number | null} - Positive timeout, zero for disabled, or null when omitted.\n   */\n  _normalizeJobTimeoutMs(options) {\n    if (options?.timeoutMs === undefined) return null\n\n    const timeoutMs = options.timeoutMs\n\n    if (typeof timeoutMs !== \"number\" || !Number.isFinite(timeoutMs)) {\n      throw VelociousError.safe(JOB_TIMEOUT_VALIDATION_MESSAGE)\n    }\n\n    if (timeoutMs <= 0) return 0\n\n    if (!Number.isInteger(timeoutMs) || timeoutMs > MAX_JOB_TIMEOUT_MS) {\n      throw VelociousError.safe(JOB_TIMEOUT_VALIDATION_MESSAGE)\n    }\n\n    return timeoutMs\n  }\n\n  /**\n   * Inserts one prepared queued job, including its concurrency registration.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {object} args - Insert input.\n   * @param {PreparedBackgroundJob} args.preparedJob - Prepared job.\n   * @param {string | null} args.scheduleKey - Historical stable key.\n   * @param {number | null} [args.scheduleOrder] - Monotonic stable ownership order.\n   * @returns {Promise<void>} - Resolves after insertion.\n   */\n  async _insertPreparedJob(db, {preparedJob, scheduleKey, scheduleOrder = null}) {\n    const {concurrency} = preparedJob\n\n    if (concurrency) {\n      if (concurrency.queueDerived) {\n        await this._ensureQueueConcurrencyKey(db, concurrency)\n      } else {\n        await this._ensureConcurrencyKey(db, concurrency)\n      }\n    }\n\n    await db.insert({\n      tableName: JOBS_TABLE,\n      data: {\n        id: preparedJob.jobId,\n        job_name: preparedJob.jobName,\n        args_json: preparedJob.argsJson,\n        execution_mode: preparedJob.executionMode,\n        queue: preparedJob.queue,\n        max_retries: preparedJob.maxRetries,\n        attempts: 0,\n        status: \"queued\",\n        scheduled_at_ms: preparedJob.scheduledAtMs,\n        created_at_ms: preparedJob.createdAtMs,\n        schedule_key: scheduleKey,\n        schedule_order: scheduleOrder,\n        concurrency_key: concurrency?.concurrencyKey || null,\n        max_concurrency: concurrency?.maxConcurrency || null,\n        timeout_ms: preparedJob.timeoutMs,\n        handoff_id: null\n      }\n    })\n  }\n\n  /**\n   * Runs normalize max retries.\n   * @param {number | null | undefined} maxRetries - Input.\n   * @returns {number} - Normalized max retries.\n   */\n  _normalizeMaxRetries(maxRetries) {\n    return normalizeBackgroundJobMaxRetries(maxRetries)\n  }\n\n  /**\n   * Runs normalize scheduled at ms.\n   * @param {number | undefined} scheduledAtMs - Requested dispatch timestamp.\n   * @param {number} defaultScheduledAtMs - Default dispatch timestamp.\n   * @returns {number} - Dispatch timestamp.\n   */\n  _normalizeScheduledAtMs(scheduledAtMs, defaultScheduledAtMs) {\n    return normalizeBackgroundJobScheduledAtMs(scheduledAtMs, defaultScheduledAtMs)\n  }\n\n  /**\n   * Resolves a reschedule delay against persistence time.\n   * @param {number} delayMs - Delay in milliseconds.\n   * @returns {number} - Future eligibility timestamp.\n   */\n  _rescheduledAtMs(delayMs) {\n    return rescheduledBackgroundJobAtMs(delayMs, this.clock.now())\n  }\n\n  /**\n   * Validates a public reschedule delay before persistence work begins.\n   * @param {number} delayMs - Delay in milliseconds.\n   * @returns {void}\n   */\n  _validateRescheduleDelayMs(delayMs) {\n    rescheduledBackgroundJobAtMs(delayMs, 0)\n  }\n\n  /**\n   * Validates a stable schedule key at the public storage boundary.\n   * @param {string} scheduleKey - Stable logical schedule key.\n   * @returns {string} - Validated key.\n   */\n  _normalizeScheduleKey(scheduleKey) {\n    return normalizeBackgroundJobScheduleKey(scheduleKey)\n  }\n\n  /**\n   * Builds a bounded advisory-lock name for one stable schedule key.\n   * @param {string} scheduleKey - Validated stable schedule key.\n   * @returns {string} - Advisory-lock name.\n   */\n  _scheduleKeyLockName(scheduleKey) {\n    const hash = createHash(\"sha256\").update(scheduleKey).digest(\"hex\").slice(0, 32)\n\n    return `background-jobs:schedule:${hash}`\n  }\n\n  /**\n   * Ensures the background-jobs schema exists, reusing a caller-held connection when\n   * one is given rather than checking out its own.\n   * @param {import(\"../database/drivers/base.js\").default} [existingDb] - Reuse an\n   *   already-checked-out connection (e.g. the one `db:migrate` holds) instead of\n   *   checking out a nested one — the nested checkout would deadlock a database\n   *   whose pool is capped at a single connection already held by the caller.\n   * @returns {Promise<void>} - Resolves when the schema is present.\n   */\n  async _ensureSchema(existingDb) {\n    await this._applySchema(existingDb)\n  }\n\n  /**\n   * Serializes creation or upgrade of the background-jobs schema, checking out a\n   * connection only after earlier schema work has completed when one is not supplied.\n   * @param {import(\"../database/drivers/base.js\").default} [existingDb] - Caller-owned\n   *   database connection.\n   * @returns {Promise<void>} - Resolves when the schema is present.\n   */\n  async _applySchema(existingDb) {\n    // Serialize concurrent schema applies within this process, keyed by database\n    // identifier (see `schemaApplyChains`). The per-step locks inside the steps use\n    // DIFFERENT lock names, so two concurrent callers could otherwise each hold a\n    // different step lock while both rebuild the jobs table — and on SQLite/MSSQL an\n    // add-column is a create-copy-drop-rename rebuild, so overlapping rebuilds\n    // corrupt it. This mutex makes the whole apply mutually exclusive per process;\n    // the second caller then re-checks and finds every step already done.\n    const identifier = this.getDatabaseIdentifier() ?? \"default\"\n    const previous = schemaApplyChains.get(identifier) ?? Promise.resolve()\n    const applyWithConnection = async () => {\n      if (existingDb) {\n        await this._applySchemaSteps(existingDb)\n\n        return\n      }\n\n      await this._withDb((db) => this._applySchemaSteps(db))\n    }\n    const run = previous.then(applyWithConnection, applyWithConnection)\n\n    // Keep the chain alive regardless of this run's outcome so one failed apply does\n    // not wedge later callers; this run still propagates its own result/error.\n    schemaApplyChains.set(identifier, run.then(() => {}, () => {}))\n\n    return await run\n  }\n\n  /**\n   * Creates or upgrades the background-jobs tables, columns and concurrency rows on\n   * the given connection. Serialized per process by {@link BackgroundJobsStore#_applySchema}.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when the schema is present.\n   */\n  async _applySchemaSteps(db) {\n    await this._ensureMigrationsTable(db)\n\n    const alreadyApplied = await this._hasMigration(db)\n    const schemaRecoveryPending = await this._hasMigration(db, SCHEMA_RECOVERY_PENDING_VERSION)\n    const jobsTableExists = await db.tableExists(JOBS_TABLE)\n\n    // Even when the migration row is present, the jobs table itself can have\n    // been dropped underneath us by a transaction rollback in another caller\n    // (DDL is transactional on SQLite/MSSQL). Verify the table physically\n    // exists and recreate it when missing rather than trusting the migration\n    // row alone, otherwise later callers fail with \"no such table\".\n    if (alreadyApplied && jobsTableExists && !schemaRecoveryPending) {\n      await this._ensureJobsTableColumns(db)\n      await this._ensureIdempotencyKeysTable(db)\n      await this._ensureMailDeliveryOperationsTable(db)\n      await this._ensureScheduleKeysTable(db)\n      await this._ensureConcurrencyTable(db)\n      await this._ensureCountRevisionTable(db)\n\n      return\n    }\n\n    if (alreadyApplied && !schemaRecoveryPending) {\n      await this._recordMigration(db, SCHEMA_RECOVERY_PENDING_VERSION)\n    }\n\n    await this._applyMigrations(db)\n    await this._ensureJobsTableColumns(db)\n    await this._ensureIdempotencyKeysTable(db)\n    await this._ensureMailDeliveryOperationsTable(db)\n    await this._ensureScheduleKeysTable(db)\n    await this._ensureConcurrencyTable(db)\n    await this._ensureCountRevisionTable(db)\n\n    if (alreadyApplied) {\n      // The recreated jobs table is empty, but the surviving concurrency table\n      // can still count handoffs that disappeared with the dropped jobs table.\n      await this._reconcileConcurrency(db)\n      await db.delete({\n        tableName: MIGRATIONS_TABLE,\n        conditions: {key: this._migrationKey(SCHEMA_RECOVERY_PENDING_VERSION)}\n      })\n\n      return\n    }\n\n    await this._recordMigration(db, MIGRATION_VERSION)\n  }\n\n  /**\n   * Runs ensure migrations table.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _ensureMigrationsTable(db) {\n    if (await db.tableExists(MIGRATIONS_TABLE)) return\n\n    const table = new TableData(MIGRATIONS_TABLE, {ifNotExists: true})\n\n    table.string(\"key\", {null: false, primaryKey: true})\n    table.string(\"scope\", {null: false})\n    table.string(\"version\", {null: false})\n    table.bigint(\"applied_at_ms\", {null: false})\n\n    await db.createTable(table)\n  }\n\n  /**\n   * Runs has migration.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} [version] - Migration version.\n   * @returns {Promise<boolean>} - Whether migration exists.\n   */\n  async _hasMigration(db, version = MIGRATION_VERSION) {\n    const query = db\n      .newQuery()\n      .from(MIGRATIONS_TABLE)\n      .where({key: this._migrationKey(version)})\n      .limit(1)\n\n    const rows = await query.results()\n\n    return rows.length > 0\n  }\n\n  /**\n   * Runs apply migrations.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _applyMigrations(db) {\n    this.logger.info(\"Applying background jobs schema\")\n\n    if (await db.tableExists(JOBS_TABLE)) {\n      this.logger.info(\"Background jobs table already exists - skipping create\")\n      return\n    }\n\n    const table = new TableData(JOBS_TABLE, {ifNotExists: true})\n\n    table.string(\"id\", {primaryKey: true})\n    table.string(\"job_name\", {null: false, index: true})\n    table.text(\"args_json\", {null: false})\n    table.string(\"execution_mode\", {null: false})\n    table.string(\"queue\", {null: true, index: true})\n    table.integer(\"max_retries\", {null: false})\n    table.integer(\"attempts\", {null: false})\n    table.string(\"status\", {null: false, index: true})\n    table.bigint(\"scheduled_at_ms\", {null: false, index: true})\n    table.bigint(\"created_at_ms\", {null: false, index: true})\n    table.string(\"schedule_key\", {null: true, index: true})\n    table.bigint(\"schedule_order\", {null: true})\n    table.bigint(\"handed_off_at_ms\", {null: true, index: true})\n    table.string(\"handoff_id\", {null: true})\n    table.bigint(\"completed_at_ms\", {null: true})\n    table.bigint(\"failed_at_ms\", {null: true})\n    table.bigint(\"orphaned_at_ms\", {null: true, index: true})\n    table.string(\"worker_id\", {null: true})\n    table.text(\"last_error\", {null: true})\n    table.string(\"concurrency_key\", {null: true, index: true})\n    table.integer(\"max_concurrency\", {null: true})\n    table.bigint(\"timeout_ms\", {null: true})\n    table.bigint(\"child_received_at_ms\", {null: true})\n    table.bigint(\"child_started_at_ms\", {null: true})\n    table.string(\"child_instance_id\", {null: true})\n    table.integer(\"child_pid\", {null: true})\n\n    await db.createTable(table)\n  }\n\n  /**\n   * Runs ensure jobs table columns.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _ensureJobsTableColumns(db) {\n    if (!(await db.tableExists(JOBS_TABLE))) return\n\n    const table = await db.getTableByNameOrFail(JOBS_TABLE)\n    const executionModeColumn = await table.getColumnByName(\"execution_mode\")\n\n    if (!executionModeColumn) {\n      const tableData = new TableData(JOBS_TABLE)\n      tableData.string(\"execution_mode\", {null: true})\n      const sqls = await db.alterTableSQLs(tableData)\n\n      for (const sql of sqls) {\n        await db.query(sql)\n      }\n\n      db.clearSchemaCache()\n    }\n\n    const refreshedTable = await db.getTableByNameOrFail(JOBS_TABLE)\n    const handoffIdColumn = await refreshedTable.getColumnByName(\"handoff_id\")\n\n    if (!handoffIdColumn) {\n      const lockName = `${MIGRATION_SCOPE}:handoff_id_column`\n      const acquired = await db.acquireAdvisoryLock(lockName)\n\n      if (!acquired) throw new Error(\"Failed to acquire background jobs handoff schema lock\")\n\n      try {\n        db.clearSchemaCache()\n        const lockedTable = await db.getTableByNameOrFail(JOBS_TABLE)\n\n        if (!(await lockedTable.getColumnByName(\"handoff_id\"))) {\n          const tableData = new TableData(JOBS_TABLE)\n          tableData.string(\"handoff_id\", {null: true})\n          const sqls = await db.alterTableSQLs(tableData)\n\n          for (const sql of sqls) {\n            await db.query(sql)\n          }\n\n          db.clearSchemaCache()\n        }\n      } finally {\n        await db.releaseAdvisoryLock(lockName)\n      }\n    }\n\n    await this._backfillExecutionModesOnce(db)\n    await this._dropForkedColumnOnce(db)\n\n    const lockName = `${MIGRATION_SCOPE}:concurrency_columns`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs concurrency schema lock\")\n\n    try {\n      // SQL Server schema reads can deadlock with a concurrent ALTER TABLE, so\n      // acquire the lock before inspecting either column rather than only\n      // protecting the mutation.\n      db.clearSchemaCache()\n      const lockedTable = await db.getTableByNameOrFail(JOBS_TABLE)\n      const concurrencyColumnNames = [\"concurrency_key\", \"max_concurrency\"]\n\n      for (const concurrencyColumnName of concurrencyColumnNames) {\n        if (await lockedTable.getColumnByName(concurrencyColumnName)) continue\n\n        const tableData = new TableData(JOBS_TABLE)\n        if (concurrencyColumnName == \"concurrency_key\") {\n          tableData.string(\"concurrency_key\", {null: true, index: true})\n        } else {\n          tableData.integer(\"max_concurrency\", {null: true})\n        }\n\n        for (const sql of await db.alterTableSQLs(tableData)) await db.query(sql)\n      }\n\n      db.clearSchemaCache()\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n\n    await this._ensureQueueColumn(db)\n    await this._ensureScheduleKeyColumn(db)\n    await this._ensureScheduleOrderColumn(db)\n    await this._ensureScheduleOrderWatermarksTable(db)\n    await this._ensureJobTimeoutColumn(db)\n    await this._ensureChildAcceptanceColumns(db)\n    await this._ensureJobsTableIndexesOnce(db)\n  }\n\n  /**\n   * Idempotently adds the pooled-child acceptance evidence columns to existing\n   * job tables. They record when the executing runner child received and\n   * started a job plus that child's identity, so a handed-off job can be told\n   * apart from one whose runner never picked it up.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ensured.\n   */\n  async _ensureChildAcceptanceColumns(db) {\n    const lockName = `${MIGRATION_SCOPE}:child_acceptance_columns`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs child-acceptance schema lock\")\n\n    try {\n      db.clearSchemaCache()\n      const table = await db.getTableByNameOrFail(JOBS_TABLE)\n      const tableData = new TableData(JOBS_TABLE)\n      let added = false\n\n      if (!(await table.getColumnByName(\"child_received_at_ms\"))) {\n        tableData.bigint(\"child_received_at_ms\", {null: true})\n        added = true\n      }\n      if (!(await table.getColumnByName(\"child_started_at_ms\"))) {\n        tableData.bigint(\"child_started_at_ms\", {null: true})\n        added = true\n      }\n      if (!(await table.getColumnByName(\"child_instance_id\"))) {\n        tableData.string(\"child_instance_id\", {null: true})\n        added = true\n      }\n      if (!(await table.getColumnByName(\"child_pid\"))) {\n        tableData.integer(\"child_pid\", {null: true})\n        added = true\n      }\n\n      if (added) {\n        for (const sql of await db.alterTableSQLs(tableData)) await db.query(sql)\n        db.clearSchemaCache()\n      }\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Repairs secondary indexes that older add-column upgrades declared but did\n   * not create on every SQL driver. The migration ledger keeps routine store\n   * readiness from repeatedly introspecting the full index set.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when all expected indexes exist.\n   */\n  async _ensureJobsTableIndexesOnce(db) {\n    const migrationVersion = JOBS_INDEX_REPAIR_MIGRATION_VERSION\n    const migrationKey = this._migrationKey(migrationVersion)\n\n    if (await this._hasMigration(db, migrationVersion)) return\n\n    const acquired = await db.acquireAdvisoryLock(migrationKey)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs index repair lock\")\n\n    try {\n      if (await this._hasMigration(db, migrationVersion)) return\n\n      db.clearSchemaCache()\n      const table = await db.getTableByNameOrFail(JOBS_TABLE)\n      const indexedColumnNames = new Set(\n        (await table.getIndexes())\n          .filter((index) => !index.isPrimaryKey() && index.getColumnNames().length === 1)\n          .map((index) => index.getColumnNames()[0])\n      )\n\n      for (const columnName of JOBS_INDEX_COLUMN_NAMES) {\n        if (indexedColumnNames.has(columnName)) continue\n\n        for (const sql of await db.createIndexSQLs({columns: [columnName], ifNotExists: db.getType() === \"sqlite\", tableName: JOBS_TABLE})) {\n          await db.query(sql)\n        }\n      }\n\n      db.clearSchemaCache()\n      await this._recordMigration(db, migrationVersion)\n    } finally {\n      await db.releaseAdvisoryLock(migrationKey)\n    }\n  }\n\n  /**\n   * Idempotently adds the per-job wall-clock timeout to existing job tables.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ensured.\n   */\n  async _ensureJobTimeoutColumn(db) {\n    const lockName = `${MIGRATION_SCOPE}:timeout_ms_column`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs timeout schema lock\")\n\n    try {\n      db.clearSchemaCache()\n      const table = await db.getTableByNameOrFail(JOBS_TABLE)\n\n      if (!(await table.getColumnByName(\"timeout_ms\"))) {\n        const tableData = new TableData(JOBS_TABLE)\n        tableData.bigint(\"timeout_ms\", {null: true})\n\n        for (const sql of await db.alterTableSQLs(tableData)) await db.query(sql)\n\n        db.clearSchemaCache()\n      }\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Idempotently adds the historical stable schedule key to existing jobs.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ensured.\n   */\n  async _ensureScheduleKeyColumn(db) {\n    const lockName = `${MIGRATION_SCOPE}:schedule_key_column`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs schedule-key schema lock\")\n\n    try {\n      db.clearSchemaCache()\n      const lockedTable = await db.getTableByNameOrFail(JOBS_TABLE)\n\n      if (!(await lockedTable.getColumnByName(\"schedule_key\"))) {\n        const tableData = new TableData(JOBS_TABLE)\n\n        tableData.string(\"schedule_key\", {null: true, index: true})\n\n        for (const sql of await db.alterTableSQLs(tableData)) await db.query(sql)\n\n        db.clearSchemaCache()\n      }\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Idempotently adds monotonic schedule ownership history and its lookup index.\n   * Existing rows remain null and use the documented legacy fallback ordering.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ensured.\n   */\n  async _ensureScheduleOrderColumn(db) {\n    const lockName = `${MIGRATION_SCOPE}:schedule_order_column`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs schedule-order schema lock\")\n\n    try {\n      db.clearSchemaCache()\n      let table = await db.getTableByNameOrFail(JOBS_TABLE)\n\n      if (!(await table.getColumnByName(\"schedule_order\"))) {\n        const tableData = new TableData(JOBS_TABLE)\n\n        tableData.bigint(\"schedule_order\", {null: true})\n        for (const sql of await db.alterTableSQLs(tableData)) await db.query(sql)\n        db.clearSchemaCache()\n        table = await db.getTableByNameOrFail(JOBS_TABLE)\n      }\n\n      const indexNames = new Set((await table.getIndexes()).map((index) => index.getName()))\n\n      if (!indexNames.has(SCHEDULE_HISTORY_ORDER_INDEX)) {\n        const sqls = await db.createIndexSQLs({\n          columns: [\"schedule_key\", \"schedule_order\", \"created_at_ms\", \"id\"],\n          ifNotExists: db.getType() === \"sqlite\",\n          name: SCHEDULE_HISTORY_ORDER_INDEX,\n          tableName: JOBS_TABLE\n        })\n\n        for (const sql of sqls) await db.query(sql)\n        db.clearSchemaCache()\n      }\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Creates the retention-independent schedule-order high-water table and\n   * initializes it from the greatest retained ordered row for every key.\n   * Legacy rows whose order is null deliberately do not establish a watermark.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ensured and backfilled.\n   */\n  async _ensureScheduleOrderWatermarksTable(db) {\n    const migrationVersion = SCHEDULE_ORDER_WATERMARK_MIGRATION_VERSION\n    const migrationKey = this._migrationKey(migrationVersion)\n    const tableExists = await db.tableExists(SCHEDULE_ORDER_WATERMARKS_TABLE)\n\n    if (tableExists && await this._hasMigration(db, migrationVersion)) return\n\n    const acquired = await db.acquireAdvisoryLock(migrationKey)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs schedule-order watermark schema lock\")\n\n    try {\n      db.clearSchemaCache()\n      const lockedTableExists = await db.tableExists(SCHEDULE_ORDER_WATERMARKS_TABLE)\n      const alreadyApplied = await this._hasMigration(db, migrationVersion)\n\n      if (!lockedTableExists) {\n        const table = new TableData(SCHEDULE_ORDER_WATERMARKS_TABLE, {ifNotExists: true})\n\n        table.string(\"schedule_key\", {primaryKey: true})\n        table.bigint(\"high_water_mark\", {null: false})\n        await db.createTable(table)\n        db.clearSchemaCache()\n      }\n\n      // Rebuild a missing table even when its migration ledger survived. The\n      // retained job rows are the only compatible source for that recovery;\n      // once rows are pruned, normal schema durability protects the watermark.\n      if (!lockedTableExists || !alreadyApplied) await this._backfillScheduleOrderWatermarks(db)\n      if (!alreadyApplied) await this._recordMigration(db, migrationVersion)\n    } finally {\n      await db.releaseAdvisoryLock(migrationKey)\n    }\n  }\n\n  /**\n   * Backfills each key from its greatest retained non-legacy ownership order.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves after all retained keys are represented.\n   */\n  async _backfillScheduleOrderWatermarks(db) {\n    const keyRows = await db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .select(\"schedule_key\")\n      .whereNot({schedule_key: null})\n      .whereNot({schedule_order: null})\n      .distinct()\n      .results()\n\n    for (const keyRow of keyRows) {\n      const scheduleKey = String(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (keyRow).schedule_key)\n      const retainedOrder = await this._greatestRetainedScheduleOrder(db, scheduleKey)\n      const currentWatermark = await this._scheduleOrderWatermark(db, scheduleKey)\n\n      if (retainedOrder === null) continue\n      if (currentWatermark !== null && currentWatermark >= retainedOrder) continue\n      await this._writeScheduleOrderWatermark(db, {scheduleKey, scheduleOrder: retainedOrder})\n    }\n  }\n\n  /**\n   * Idempotently adds the `queue` column to an existing jobs table. Existing\n   * rows read back as the default queue (see {@link _normalizeJobRow}), so no\n   * data backfill is required.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ensured.\n   */\n  async _ensureQueueColumn(db) {\n    const lockName = `${MIGRATION_SCOPE}:queue_column`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs queue schema lock\")\n\n    try {\n      // SQL Server schema reads can deadlock with a concurrent ALTER TABLE, so\n      // acquire the lock before inspecting the column rather than only\n      // protecting the mutation (mirrors the concurrency-column migration).\n      db.clearSchemaCache()\n      const lockedTable = await db.getTableByNameOrFail(JOBS_TABLE)\n\n      if (!(await lockedTable.getColumnByName(\"queue\"))) {\n        const tableData = new TableData(JOBS_TABLE)\n\n        tableData.string(\"queue\", {null: true, index: true})\n\n        for (const sql of await db.alterTableSQLs(tableData)) await db.query(sql)\n\n        db.clearSchemaCache()\n      }\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Runs backfill execution modes once.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _backfillExecutionModesOnce(db) {\n    const migrationVersion = EXECUTION_MODE_BACKFILL_MIGRATION_VERSION\n    const migrationKey = this._migrationKey(migrationVersion)\n\n    if (await this._hasMigration(db, migrationVersion)) return\n\n    await db.acquireAdvisoryLock(migrationKey)\n\n    try {\n      if (await this._hasMigration(db, migrationVersion)) return\n\n      // A table created after the `forked` column was dropped has nothing to\n      // backfill from; record the migration so it is not re-attempted.\n      db.clearSchemaCache()\n      if (!(await (await db.getTableByNameOrFail(JOBS_TABLE)).getColumnByName(\"forked\"))) {\n        await this._recordMigration(db, migrationVersion)\n        return\n      }\n\n      const tableNameSql = db.quoteTable(JOBS_TABLE)\n      const forkedColumnSql = db.quoteColumn(\"forked\")\n      const executionModeColumnSql = db.quoteColumn(\"execution_mode\")\n\n      await db.query(\n        `UPDATE ${tableNameSql} SET ${executionModeColumnSql} = ${db.quote(\"forked\")} ` +\n        `WHERE ${forkedColumnSql} = ${db.quote(true)} AND ${executionModeColumnSql} IS NULL`\n      )\n      await db.query(\n        `UPDATE ${tableNameSql} SET ${executionModeColumnSql} = ${db.quote(\"inline\")} ` +\n        `WHERE ${forkedColumnSql} = ${db.quote(false)} AND ${executionModeColumnSql} IS NULL`\n      )\n\n      await this._recordMigration(db, migrationVersion)\n    } finally {\n      await db.releaseAdvisoryLock(migrationKey)\n    }\n  }\n\n  /**\n   * Rewrites pre-existing pooled rows (persisted as `execution_mode = \"forked\"`\n   * plus a `velocious-pooled:*` handoff marker) to `execution_mode = \"pooled\"`,\n   * clears the queued marker, then drops the now-redundant `forked` column so\n   * `execution_mode` is the single source of truth. Runs once, guarded by the\n   * migration ledger and a per-key advisory lock; a fresh table (created without\n   * the column) short-circuits.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _dropForkedColumnOnce(db) {\n    const migrationVersion = DROP_FORKED_COLUMN_MIGRATION_VERSION\n    const migrationKey = this._migrationKey(migrationVersion)\n\n    if (await this._hasMigration(db, migrationVersion)) return\n\n    await db.acquireAdvisoryLock(migrationKey)\n\n    try {\n      if (await this._hasMigration(db, migrationVersion)) return\n\n      db.clearSchemaCache()\n\n      if (await (await db.getTableByNameOrFail(JOBS_TABLE)).getColumnByName(\"forked\")) {\n        const tableNameSql = db.quoteTable(JOBS_TABLE)\n        const executionModeColumnSql = db.quoteColumn(\"execution_mode\")\n        const handoffIdColumnSql = db.quoteColumn(\"handoff_id\")\n\n        // Pooled rows used to persist as execution_mode \"forked\" + a pooled handoff\n        // marker; recover their real mode before the marker is cleared.\n        await db.query(\n          `UPDATE ${tableNameSql} SET ${executionModeColumnSql} = ${db.quote(\"pooled\")} ` +\n          `WHERE ${executionModeColumnSql} = ${db.quote(\"forked\")} ` +\n          `AND ${handoffIdColumnSql} LIKE ${db.quote(`${LEGACY_POOLED_HANDOFF_ID_PREFIX}%`)}`\n        )\n        // The queued-pooled marker was a sentinel, not a real lease; clear it.\n        await db.query(\n          `UPDATE ${tableNameSql} SET ${handoffIdColumnSql} = NULL ` +\n          `WHERE ${handoffIdColumnSql} = ${db.quote(LEGACY_POOLED_QUEUED_HANDOFF_ID)}`\n        )\n\n        const dropForked = new TableData(JOBS_TABLE)\n        dropForked.addColumn(\"forked\", {dropColumn: true})\n        for (const sql of await db.alterTableSQLs(dropForked)) await db.query(sql)\n\n        db.clearSchemaCache()\n      }\n\n      await this._recordMigration(db, migrationVersion)\n    } finally {\n      await db.releaseAdvisoryLock(migrationKey)\n    }\n  }\n\n  /**\n   * Runs record migration.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} version - Migration version.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _recordMigration(db, version) {\n    await db.upsert({\n      tableName: MIGRATIONS_TABLE,\n      data: {\n        key: this._migrationKey(version),\n        scope: MIGRATION_SCOPE,\n        version,\n        applied_at_ms: Date.now()\n      },\n      conflictColumns: [\"key\"],\n      updateColumns: [\"scope\", \"version\", \"applied_at_ms\"]\n    })\n  }\n\n  async _initializeModel() {\n    if (BackgroundJobRecord.isInitialized()) return\n\n    BackgroundJobRecord.setDatabaseIdentifier(this.getDatabaseIdentifier())\n    const pool = this.configuration.getDatabasePool(this.getDatabaseIdentifier())\n\n    await pool.withConnection({name: \"Background jobs store initialize model\"}, async () => {\n      await BackgroundJobRecord.initializeRecord({configuration: this.configuration})\n    })\n  }\n\n  /**\n   * Runs get job row by id.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} jobId - Job id.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Job row.\n   */\n  async _getJobRowById(db, jobId) {\n    const query = db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .where({id: jobId})\n      .limit(1)\n\n    const rows = await query.results()\n\n    if (!rows[0]) return null\n\n    return this._normalizeJobRow(rows[0])\n  }\n\n  /**\n   * Reads the job currently named by one stable owner row.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} scheduleKey - Validated stable schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Normalized owner job.\n   */\n  async _scheduledOwnerJob(db, scheduleKey) {\n    const ownerRows = await db\n      .newQuery()\n      .from(SCHEDULE_KEYS_TABLE)\n      .where({schedule_key: scheduleKey})\n      .limit(1)\n      .results()\n    const ownerRow = ownerRows[0]\n\n    if (!ownerRow) return null\n\n    return await this._getJobRowById(db, String(ownerRow.job_id))\n  }\n\n  /**\n   * Assigns the next ownership order while the caller holds the schedule-key\n   * advisory lock and count-revision transaction fence. The independent\n   * watermark survives both ownership release and terminal-history pruning.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} scheduleKey - Validated stable schedule key.\n   * @returns {Promise<number>} - Next monotonic ownership order.\n   */\n  async _nextScheduleOrder(db, scheduleKey) {\n    const durableOrder = await this._scheduleOrderWatermark(db, scheduleKey)\n    const retainedOrder = await this._greatestRetainedScheduleOrder(db, scheduleKey)\n    let currentOrder = durableOrder\n\n    if (retainedOrder !== null && (currentOrder === null || retainedOrder > currentOrder)) currentOrder = retainedOrder\n    const nextOrder = currentOrder === null ? 1 : currentOrder + 1\n\n    if (!Number.isSafeInteger(nextOrder)) {\n      throw new Error(`Background job schedule ownership order exhausted for ${scheduleKey}`)\n    }\n\n    await this._writeScheduleOrderWatermark(db, {scheduleKey, scheduleOrder: nextOrder})\n\n    return nextOrder\n  }\n\n  /**\n   * Finds the greatest retained non-legacy ownership order for migration and\n   * rolling-upgrade compatibility. It is never the sole durability boundary.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} scheduleKey - Validated stable schedule key.\n   * @returns {Promise<number | null>} - Greatest retained order, or null.\n   */\n  async _greatestRetainedScheduleOrder(db, scheduleKey) {\n    const rows = await db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .select(\"schedule_order\")\n      .where({schedule_key: scheduleKey})\n      .whereNot({schedule_order: null})\n      .order(\"schedule_order DESC\")\n      .limit(1)\n      .results()\n    const row = rows[0]\n\n    if (!row) return null\n\n    return this._validatedScheduleOrder(\n      /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (row).schedule_order\n    )\n  }\n\n  /**\n   * Reads and validates one retention-independent schedule-order watermark.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} scheduleKey - Validated stable schedule key.\n   * @returns {Promise<number | null>} - Current watermark, or null before first ownership.\n   */\n  async _scheduleOrderWatermark(db, scheduleKey) {\n    const rows = await db\n      .newQuery()\n      .from(SCHEDULE_ORDER_WATERMARKS_TABLE)\n      .select(\"high_water_mark\")\n      .where({schedule_key: scheduleKey})\n      .limit(1)\n      .results()\n    const row = rows[0]\n\n    if (!row) return null\n\n    return this._validatedScheduleOrder(\n      /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (row).high_water_mark\n    )\n  }\n\n  /**\n   * Persists one schedule-order watermark without exposing it as a job row.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {object} args - Watermark identity and value.\n   * @param {string} args.scheduleKey - Validated stable schedule key.\n   * @param {number} args.scheduleOrder - Validated monotonic order.\n   * @returns {Promise<void>} - Resolves after persistence.\n   */\n  async _writeScheduleOrderWatermark(db, {scheduleKey, scheduleOrder}) {\n    await db.upsert({\n      tableName: SCHEDULE_ORDER_WATERMARKS_TABLE,\n      data: {high_water_mark: scheduleOrder, schedule_key: scheduleKey},\n      conflictColumns: [\"schedule_key\"],\n      updateColumns: [\"high_water_mark\"]\n    })\n  }\n\n  /**\n   * Validates an ownership order loaded from durable storage.\n   * @param {ReturnType<typeof JSON.parse>} value - Stored order.\n   * @returns {number} - Positive safe integer ownership order.\n   */\n  _validatedScheduleOrder(value) {\n    const scheduleOrder = this._normalizeNumber(value)\n\n    if (scheduleOrder === null || !Number.isSafeInteger(scheduleOrder) || scheduleOrder < 1) {\n      throw new Error(`Invalid background job schedule ownership order: ${scheduleOrder}`)\n    }\n\n    return scheduleOrder\n  }\n\n  /**\n   * Builds a stable-schedule lookup exclusively from normalized job rows.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {object} args - Lookup options.\n   * @param {boolean} args.includeLatestTerminal - Whether terminal history is requested.\n   * @param {string} args.scheduleKey - Validated stable schedule key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobScheduledLookupResult>} - Normalized public jobs.\n   */\n  async _scheduledJobLookup(db, {includeLatestTerminal, scheduleKey}) {\n    const ownerJob = await this._scheduledOwnerJob(db, scheduleKey)\n    const currentJob = ownerJob && (ownerJob.status === \"queued\" || ownerJob.status === \"handed_off\") ? ownerJob : null\n\n    if (!includeLatestTerminal) return {currentJob, latestTerminalJob: null}\n\n    const terminalStatuses = BACKGROUND_JOB_TERMINAL_STATUSES.map((status) => db.quote(status)).join(\", \")\n    const terminalRows = await db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .where({schedule_key: scheduleKey})\n      .where(`${db.quoteColumn(\"status\")} IN (${terminalStatuses})`)\n      .order(`CASE WHEN ${db.quoteColumn(\"schedule_order\")} IS NULL THEN 0 ELSE 1 END DESC`)\n      .order(\"schedule_order DESC\")\n      .order(\"created_at_ms DESC\")\n      .order(\"id DESC\")\n      .limit(1)\n      .results()\n    const latestTerminalJob = terminalRows[0] ? this._normalizeJobRow(terminalRows[0]) : null\n\n    return {currentJob, latestTerminalJob}\n  }\n\n  /**\n   * Releases ownership only when the key still points at the expected job.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {object} args - Ownership identity.\n   * @param {string} args.jobId - Expected owner job id.\n   * @param {string} args.scheduleKey - Stable schedule key.\n   * @returns {Promise<void>} - Resolves when deleted or already superseded.\n   */\n  async _releaseScheduleOwnership(db, {jobId, scheduleKey}) {\n    await db.delete({\n      tableName: SCHEDULE_KEYS_TABLE,\n      conditions: {job_id: jobId, schedule_key: scheduleKey}\n    })\n  }\n\n  /**\n   * Releases a job's ownership when it has a historical schedule key.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {import(\"./types.js\").BackgroundJobRow} job - Terminal job.\n   * @returns {Promise<void>} - Resolves when deleted or not applicable.\n   */\n  async _releaseScheduleOwnershipForJob(db, job) {\n    if (!job.scheduleKey) return\n\n    await this._releaseScheduleOwnership(db, {jobId: job.id, scheduleKey: job.scheduleKey})\n  }\n\n  /**\n   * Runs apply failure.\n   * @param {object} args - Options.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Database connection.\n   * @param {import(\"./types.js\").BackgroundJobRow} args.job - Job row.\n   * @param {ReturnType<typeof JSON.parse>} args.error - Error.\n   * @param {boolean} args.markOrphaned - Whether marking orphaned.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} [args.conditions] - Update fencing conditions. Defaults to the active-handoff lease match; the time-based orphan sweep overrides this with an id/status match so it can reclaim rows whose `handoff_id` is null (e.g. handed off by an older velocious before handoff-id fencing existed).\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Updated job row when the lease transition won.\n   */\n  async _applyFailure({db, job, error, markOrphaned, conditions}) {\n    const now = this.clock.now()\n    const nextAttempt = (job.attempts || 0) + 1\n    const maxRetries = this._normalizeMaxRetries(job.maxRetries)\n    const shouldRetry = nextAttempt <= maxRetries\n    const failureMessage = normalizeBackgroundJobError(error)\n    const scheduledAt = shouldRetry ? now + this.getRetryDelayMs(nextAttempt) : job.scheduledAtMs\n    const update = this._failureUpdate({\n      failureMessage,\n      markOrphaned,\n      nextAttempt,\n      now,\n      scheduledAt,\n      shouldRetry\n    })\n\n    await this._lockConcurrencyRow(db, job.concurrencyKey)\n    const affectedRows = await this._updateAffectedRows(db, {\n      tableName: JOBS_TABLE,\n      data: update,\n      conditions: conditions ?? this._activeHandoffConditions(job)\n    })\n\n    if (affectedRows !== 1) return null\n    if (!shouldRetry) await this._releaseScheduleOwnershipForJob(db, job)\n    await this._releaseConcurrency(db, job.concurrencyKey)\n\n    // Return a snapshot of the transition this update just applied rather than re-reading the row.\n    // We won the conditional update (affectedRows === 1), so this state is authoritative; re-reading\n    // could instead observe a newer state if another dispatcher reclaims a requeued job between the\n    // update and the read (overlapping mains / polling dispatch), which would misreport the\n    // status/terminal/willRetry of this transition to failure/orphan event listeners.\n    const status = shouldRetry ? \"queued\" : (markOrphaned ? \"orphaned\" : \"failed\")\n    /** @type {import(\"./types.js\").BackgroundJobRow} */\n    const transitionedJob = {\n      ...job,\n      ...(shouldRetry ? this._clearedChildAcceptanceRow() : {}),\n      attempts: nextAttempt,\n      handedOffAtMs: null,\n      lastError: failureMessage,\n      status,\n      workerId: null\n    }\n\n    if (markOrphaned) transitionedJob.orphanedAtMs = now\n    if (shouldRetry) {\n      transitionedJob.scheduledAtMs = scheduledAt\n    } else if (!markOrphaned) {\n      transitionedJob.failedAtMs = now\n    }\n\n    return transitionedJob\n  }\n\n  /**\n   * Runs failure update.\n   * @param {object} args - Options.\n   * @param {string} args.failureMessage - Last failure message.\n   * @param {boolean} args.markOrphaned - Whether marking orphaned.\n   * @param {number} args.nextAttempt - Next attempt count.\n   * @param {number} args.now - Current timestamp.\n   * @param {number | null} args.scheduledAt - Next scheduled timestamp.\n   * @param {boolean} args.shouldRetry - Whether the job should retry.\n   * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Database update data.\n   */\n  _failureUpdate({failureMessage, markOrphaned, nextAttempt, now, scheduledAt, shouldRetry}) {\n    /**\n     * Update.\n     * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n    const update = {\n      attempts: nextAttempt,\n      handed_off_at_ms: null,\n      worker_id: null,\n      last_error: failureMessage\n    }\n\n    // A retry starts a fresh handoff with a possibly different runner, so the\n    // previous child's acceptance evidence must not leak into the next attempt.\n    // Terminal failures keep it as historical evidence for the lost attempt.\n    if (shouldRetry) Object.assign(update, this._clearedChildAcceptanceData())\n\n    this._applyOrphanedFailureUpdate({markOrphaned, now, update})\n    this._applyFailureStatusUpdate({markOrphaned, now, scheduledAt, shouldRetry, update})\n\n    return update\n  }\n\n  /**\n   * Runs apply orphaned failure update.\n   * @param {object} args - Options.\n   * @param {boolean} args.markOrphaned - Whether marking orphaned.\n   * @param {number} args.now - Current timestamp.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.update - Database update data.\n   * @returns {void}\n   */\n  _applyOrphanedFailureUpdate({markOrphaned, now, update}) {\n    if (markOrphaned) update.orphaned_at_ms = now\n  }\n\n  /**\n   * Runs apply failure status update.\n   * @param {object} args - Options.\n   * @param {boolean} args.markOrphaned - Whether marking orphaned.\n   * @param {number} args.now - Current timestamp.\n   * @param {number | null} args.scheduledAt - Next scheduled timestamp.\n   * @param {boolean} args.shouldRetry - Whether the job should retry.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} args.update - Database update data.\n   * @returns {void}\n   */\n  _applyFailureStatusUpdate({markOrphaned, now, scheduledAt, shouldRetry, update}) {\n    if (shouldRetry) {\n      update.status = \"queued\"\n      update.scheduled_at_ms = scheduledAt\n      return\n    }\n\n    if (markOrphaned) {\n      update.status = \"orphaned\"\n      return\n    }\n\n    update.status = \"failed\"\n    update.failed_at_ms = now\n  }\n\n  /**\n   * Runs normalize job row.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} row - Raw database row.\n   * @returns {import(\"./types.js\").BackgroundJobRow} - Normalized job row.\n   */\n  _normalizeJobRow(row) {\n    const handoffId = row.handoff_id ? String(row.handoff_id) : null\n    // `execution_mode` is the single source of truth for a job's runtime and is\n    // written on every enqueue; the drop-forked migration backfills any pre-existing\n    // rows before the legacy `forked` column is removed.\n    const executionMode = row.execution_mode ? this._normalizeExecutionModeName(String(row.execution_mode)) : DEFAULT_BACKGROUND_JOB_EXECUTION_MODE\n\n    return {\n      id: String(row.id),\n      jobName: String(row.job_name),\n      args: this._parseArgs(row.args_json),\n      executionMode,\n      queue: row.queue ? String(row.queue) : DEFAULT_BACKGROUND_JOB_QUEUE,\n      scheduleKey: row.schedule_key ? String(row.schedule_key) : null,\n      scheduleOrder: this._normalizeNumber(row.schedule_order),\n      status: normalizeBackgroundJobStatus(row.status ? String(row.status) : \"queued\"),\n      attempts: this._normalizeNumber(row.attempts),\n      maxRetries: this._normalizeNumber(row.max_retries),\n      scheduledAtMs: this._normalizeNumber(row.scheduled_at_ms),\n      createdAtMs: this._normalizeNumber(row.created_at_ms),\n      handedOffAtMs: this._normalizeNumber(row.handed_off_at_ms),\n      handoffId,\n      completedAtMs: this._normalizeNumber(row.completed_at_ms),\n      failedAtMs: this._normalizeNumber(row.failed_at_ms),\n      orphanedAtMs: this._normalizeNumber(row.orphaned_at_ms),\n      workerId: row.worker_id ? String(row.worker_id) : null,\n      lastError: row.last_error ? String(row.last_error) : null,\n      concurrencyKey: row.concurrency_key ? String(row.concurrency_key) : null,\n      maxConcurrency: this._normalizeNumber(row.max_concurrency),\n      timeoutMs: this._normalizeNumber(row.timeout_ms),\n      childReceivedAtMs: this._normalizeNumber(row.child_received_at_ms),\n      childStartedAtMs: this._normalizeNumber(row.child_started_at_ms),\n      childInstanceId: row.child_instance_id ? String(row.child_instance_id) : null,\n      childPid: this._normalizeNumber(row.child_pid)\n    }\n  }\n\n  /**\n   * Normalizes a job's queue name, defaulting to \"default\".\n   * @param {import(\"./types.js\").BackgroundJobOptions | undefined} options - Job options.\n   * @returns {string} - Queue name.\n   */\n  _normalizeQueue(options) {\n    return normalizeBackgroundJobQueue(options)\n  }\n\n  /**\n   * Resolves a job's durable concurrency. An explicit concurrencyKey/maxConcurrency\n   * pair always wins. Otherwise, when the job's queue has a configured cap\n   * (`backgroundJobs.queues[queue].maxConcurrent`), derive a queue-scoped\n   * concurrency key so the queue cap is enforced cluster-wide through the\n   * existing durable concurrency mechanism.\n   * @param {import(\"./types.js\").BackgroundJobOptions | undefined} options - Job options.\n   * @param {string} queue - Normalized queue name.\n   * @returns {{concurrencyKey: string, maxConcurrency: number, queueDerived: boolean} | null} - Resolved concurrency.\n   */\n  _resolveConcurrency(options, queue) {\n    return normalizeBackgroundJobConcurrency({\n      options: options || {},\n      queue,\n      queues: this.configuration.getBackgroundJobsConfig().queues\n    })\n  }\n\n  /**\n   * Applies the active generation's queue policy immediately before handoff.\n   * Explicit concurrency remains owned by the enqueue request.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {import(\"./types.js\").BackgroundJobRow} job - Queued job snapshot.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Reconciled job, or null when its queued-state fence lost.\n   */\n  async _reconcileQueuedJobConcurrency(db, job) {\n    if (job.concurrencyKey && !job.concurrencyKey.startsWith(QUEUE_CONCURRENCY_KEY_PREFIX)) {\n      return job\n    }\n\n    const concurrency = this._resolveConcurrency({}, job.queue)\n    /** @type {BackgroundJobQueuedConcurrency} */\n    const current = concurrency\n      ? {concurrencyKey: concurrency.concurrencyKey, maxConcurrency: concurrency.maxConcurrency}\n      : {concurrencyKey: null, maxConcurrency: null}\n\n    if (concurrency) await this._ensureQueueConcurrencyKey(db, concurrency)\n    if (job.concurrencyKey === current.concurrencyKey && job.maxConcurrency === current.maxConcurrency) return job\n\n    const affectedRows = await this._updateAffectedRows(db, {\n      tableName: JOBS_TABLE,\n      data: {\n        concurrency_key: current.concurrencyKey,\n        max_concurrency: current.maxConcurrency\n      },\n      conditions: {concurrency_key: job.concurrencyKey, id: job.id, status: \"queued\"}\n    })\n\n    if (affectedRows !== 1) return null\n\n    return {...job, concurrencyKey: current.concurrencyKey, maxConcurrency: current.maxConcurrency}\n  }\n\n  /**\n   * Reads the configured max concurrency for a queue from the background-jobs config.\n   * @param {string} queue - Queue name.\n   * @returns {number | null} - Positive integer cap, or null when the queue has no configured cap.\n   */\n  _queueMaxConcurrency(queue) {\n    const queues = this.configuration.getBackgroundJobsConfig().queues\n    const cap = queues?.[queue]?.maxConcurrent\n\n    if (Number.isInteger(cap) && Number(cap) > 0) return Number(cap)\n\n    return null\n  }\n\n  /**\n   * Like {@link _ensureConcurrencyKey}, but for queue-derived keys the configured\n   * queue cap is the source of truth: if it changed, update the stored cap\n   * instead of throwing on conflict (config-driven caps must be tunable).\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {{concurrencyKey: string, maxConcurrency: number}} concurrency - Concurrency configuration.\n   * @returns {Promise<void>} - Resolves when ensured.\n   */\n  async _ensureQueueConcurrencyKey(db, {concurrencyKey, maxConcurrency}) {\n    const rows = await db.newQuery().from(CONCURRENCY_TABLE).where({concurrency_key: concurrencyKey}).limit(1).results()\n\n    if (!rows[0]) {\n      try {\n        await db.insert({tableName: CONCURRENCY_TABLE, data: {active_count: 0, concurrency_key: concurrencyKey, max_concurrency: maxConcurrency}})\n\n        return\n      } catch (error) {\n        const racedRows = await db.newQuery().from(CONCURRENCY_TABLE).where({concurrency_key: concurrencyKey}).limit(1).results()\n\n        if (!racedRows[0]) throw error\n\n        rows[0] = racedRows[0]\n      }\n    }\n\n    const configured = /** @type {{max_concurrency?: number | string}} */ (rows[0])\n\n    if (this._normalizeNumber(configured.max_concurrency) !== maxConcurrency) {\n      const table = db.quoteTable(CONCURRENCY_TABLE)\n\n      await db.query(`UPDATE ${table} SET ${db.quoteColumn(\"max_concurrency\")} = ${Number(maxConcurrency)} WHERE ${db.quoteColumn(\"concurrency_key\")} = ${db.quote(concurrencyKey)}`)\n    }\n  }\n\n  /**\n   * Ensures the concurrency state table exists.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ready.\n   */\n  async _ensureConcurrencyTable(db) {\n    if (await db.tableExists(CONCURRENCY_TABLE)) return\n    const table = new TableData(CONCURRENCY_TABLE, {ifNotExists: true})\n    table.string(\"concurrency_key\", {primaryKey: true})\n    table.integer(\"max_concurrency\", {null: false})\n    table.integer(\"active_count\", {null: false})\n    await db.createTable(table)\n  }\n\n  /**\n   * Ensures the stable schedule-key ownership table exists.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ready.\n   */\n  async _ensureScheduleKeysTable(db) {\n    if (await db.tableExists(SCHEDULE_KEYS_TABLE)) return\n\n    const lockName = `${MIGRATION_SCOPE}:schedule_keys_table`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background jobs schedule-key table schema lock\")\n\n    try {\n      db.clearSchemaCache()\n      if (await db.tableExists(SCHEDULE_KEYS_TABLE)) return\n\n      const table = new TableData(SCHEDULE_KEYS_TABLE, {ifNotExists: true})\n\n      table.string(\"schedule_key\", {primaryKey: true})\n      table.string(\"job_id\", {null: false, index: true})\n      await db.createTable(table)\n      db.clearSchemaCache()\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Ensures durable generic enqueue ownership exists independently of job rows.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ready.\n   */\n  async _ensureIdempotencyKeysTable(db) {\n    if (await db.tableExists(IDEMPOTENCY_KEYS_TABLE)) return\n\n    const lockName = `${MIGRATION_SCOPE}:idempotency_keys_table`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire background job idempotency-key table schema lock\")\n\n    try {\n      db.clearSchemaCache()\n      if (await db.tableExists(IDEMPOTENCY_KEYS_TABLE)) return\n\n      const table = new TableData(IDEMPOTENCY_KEYS_TABLE, {ifNotExists: true})\n\n      table.string(\"scope_digest\", {primaryKey: true})\n      table.string(\"job_name\", {null: false})\n      table.string(\"queue\", {null: false})\n      table.text(\"idempotency_key\", {null: false})\n      table.string(\"job_id\", {index: true, null: false})\n      table.string(\"request_digest\", {null: false})\n      table.bigint(\"created_at_ms\", {null: false})\n      await db.createTable(table)\n      db.clearSchemaCache()\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Ensures durable provider-backed mail operation state exists independently of jobs.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when ready.\n   */\n  async _ensureMailDeliveryOperationsTable(db) {\n    if (await db.tableExists(MAIL_DELIVERY_OPERATIONS_TABLE)) return\n\n    const lockName = `${MIGRATION_SCOPE}:mail_delivery_operations_table`\n    const acquired = await db.acquireAdvisoryLock(lockName)\n\n    if (!acquired) throw new Error(\"Failed to acquire mail delivery operation table schema lock\")\n\n    try {\n      db.clearSchemaCache()\n      if (await db.tableExists(MAIL_DELIVERY_OPERATIONS_TABLE)) return\n\n      const table = new TableData(MAIL_DELIVERY_OPERATIONS_TABLE, {ifNotExists: true})\n\n      table.string(\"operation_key\", {primaryKey: true})\n      table.text(\"operation_id\", {null: false})\n      table.string(\"payload_digest\", {null: false})\n      table.string(\"background_job_id\", {index: true, null: false})\n      table.bigint(\"first_attempt_started_at_ms\", {null: true})\n      table.string(\"provider_kind\", {null: false})\n      table.bigint(\"provider_retention_ms\", {null: false})\n      table.bigint(\"created_at_ms\", {null: false})\n      await db.createTable(table)\n      db.clearSchemaCache()\n    } finally {\n      await db.releaseAdvisoryLock(lockName)\n    }\n  }\n\n  /**\n   * Ensures the singleton durable count-revision row exists.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} Resolves when ready.\n   */\n  async _ensureCountRevisionTable(db) {\n    if (!(await db.tableExists(COUNTS_REVISION_TABLE))) {\n      const table = new TableData(COUNTS_REVISION_TABLE, {ifNotExists: true})\n\n      table.string(\"key\", {primaryKey: true})\n      table.bigint(\"revision\", {null: false})\n      await db.createTable(table)\n    }\n\n    const rows = await db.newQuery().from(COUNTS_REVISION_TABLE).where({key: COUNTS_REVISION_KEY}).limit(1).results()\n\n    if (rows.length > 0) return\n\n    try {\n      await db.insert({tableName: COUNTS_REVISION_TABLE, data: {key: COUNTS_REVISION_KEY, revision: 0}})\n    } catch (error) {\n      const racedRows = await db.newQuery().from(COUNTS_REVISION_TABLE).where({key: COUNTS_REVISION_KEY}).limit(1).results()\n\n      if (racedRows.length === 0) throw error\n    }\n  }\n\n  /**\n   * Records one logical count mutation atomically and broadcasts it after commit.\n   * Zero entries are omitted; a wholly zero-net mutation does not consume a revision.\n   * @param {import(\"../database/drivers/base.js\").default} db - Transaction connection.\n   * @param {Record<string, number>} requestedDeltas - Signed bucket changes.\n   * @returns {Promise<void>} Resolves when recorded.\n   */\n  async _recordCountDelta(db, requestedDeltas) {\n    /** @type {Record<string, number>} */\n    const deltas = {}\n\n    for (const bucket of BACKGROUND_JOB_COUNT_BUCKETS) {\n      const amount = requestedDeltas[bucket] || 0\n\n      if (!Number.isInteger(amount)) throw new Error(`Invalid background job count delta for ${bucket}: ${amount}`)\n      if (amount !== 0) deltas[bucket] = amount\n    }\n\n    if (Object.keys(deltas).length === 0) return\n\n    const table = db.quoteTable(COUNTS_REVISION_TABLE)\n    const revisionColumn = db.quoteColumn(\"revision\")\n    const affectedRows = await db.affectedRows(\n      `UPDATE ${table} SET ${revisionColumn} = ${revisionColumn} + 1 WHERE ${db.quoteColumn(\"key\")} = ${db.quote(COUNTS_REVISION_KEY)}`\n    )\n\n    if (affectedRows !== 1) throw new Error(\"Background job count revision row is missing\")\n\n    const revision = await this._countRevision(db)\n    const body = {deltas, revision, type: \"background-job-count-delta\"}\n    const databaseIdentifier = this.getDatabaseIdentifier() || \"default\"\n\n    await db.afterCommit(() => {\n      this.configuration.broadcastToChannel(BACKGROUND_JOB_COUNTS_CHANNEL, {databaseIdentifier}, body)\n    })\n  }\n\n  /**\n   * Records a transition between persisted statuses.\n   * @param {import(\"../database/drivers/base.js\").default} db - Transaction connection.\n   * @param {string} oldStatus - Previous status.\n   * @param {string} newStatus - New status.\n   * @returns {Promise<void>} Resolves when recorded.\n   */\n  async _recordStatusTransition(db, oldStatus, newStatus) {\n    const oldCounted = COUNTED_JOB_STATUSES.includes(oldStatus)\n    const newCounted = COUNTED_JOB_STATUSES.includes(newStatus)\n\n    if (!oldCounted && oldStatus !== \"cancelled\") throw new Error(`Unknown previous background job status: ${oldStatus}`)\n    if (!newCounted && newStatus !== \"cancelled\") throw new Error(`Unknown next background job status: ${newStatus}`)\n    if (oldStatus === newStatus) return\n\n    /** @type {Record<string, number>} */\n    const deltas = {}\n\n    if (oldCounted) deltas[oldStatus] = -1\n    if (newCounted) deltas[newStatus] = 1\n    if (oldCounted !== newCounted) deltas.all = newCounted ? 1 : -1\n    await this._recordCountDelta(db, deltas)\n  }\n\n  /**\n   * Reads the locked revision.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<number>} Revision.\n   */\n  async _countRevision(db) {\n    const rows = await db.newQuery().from(COUNTS_REVISION_TABLE).select(\"revision\").where({key: COUNTS_REVISION_KEY}).limit(1).results()\n    const revision = this._normalizeNumber(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (rows[0] || {}).revision)\n\n    if (revision === null || !Number.isSafeInteger(revision) || revision < 0) {\n      throw new Error(`Invalid background job count revision: ${revision}`)\n    }\n\n    return revision\n  }\n\n  /**\n   * Takes a portable write lock on the singleton revision row.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} Resolves when locked.\n   */\n  async _lockCountRevision(db) {\n    const table = db.quoteTable(COUNTS_REVISION_TABLE)\n    const revision = db.quoteColumn(\"revision\")\n\n    await db.query(`UPDATE ${table} SET ${revision} = ${revision} WHERE ${db.quoteColumn(\"key\")} = ${db.quote(COUNTS_REVISION_KEY)}`)\n  }\n\n  /**\n   * Builds zeroed canonical buckets.\n   * @returns {Record<string, number>} Zeroed canonical buckets.\n   */\n  _emptyCountBuckets() {\n    return Object.fromEntries(BACKGROUND_JOB_COUNT_BUCKETS.map((bucket) => [bucket, 0]))\n  }\n\n  /**\n   * Counts normalized rows by canonical status.\n   * @param {import(\"./types.js\").BackgroundJobRow[]} jobs - Jobs.\n   * @returns {Record<string, number>} Counts.\n   */\n  _statusCounts(jobs) {\n    /** @type {Record<string, number>} */\n    const counts = {}\n\n    for (const job of jobs) {\n      if (!COUNTED_JOB_STATUSES.includes(job.status)) throw new Error(`Unknown background job status: ${job.status}`)\n      counts[job.status] = (counts[job.status] || 0) + 1\n    }\n\n    return counts\n  }\n\n  /**\n   * Reads a canonical snapshot after locking the revision row.\n   * @param {import(\"../database/drivers/base.js\").default} db - Transaction connection.\n   * @returns {Promise<{counts: Record<string, number>, revision: number, total: number}>} Snapshot.\n   */\n  async _countSnapshotOnLockedConnection(db) {\n    const rows = await db.newQuery().from(JOBS_TABLE).select(\"status\").select(\"COUNT(*) AS count\").group(\"status\").results()\n    const counts = this._emptyCountBuckets()\n    let total = 0\n\n    for (const row of rows) {\n      const typedRow = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (row)\n      const status = String(typedRow.status)\n      const count = this._normalizeNumber(typedRow.count) || 0\n\n      total += count\n\n      if (!COUNTED_JOB_STATUSES.includes(status)) continue\n      counts[status] = count\n      counts.all += counts[status]\n    }\n\n    return {counts, revision: await this._countRevision(db), total}\n  }\n\n  /**\n   * Registers or verifies a stable key configuration.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {object} concurrency - Concurrency configuration.\n   * @param {string} concurrency.concurrencyKey - Concurrency key.\n   * @param {number} concurrency.maxConcurrency - Stable cap.\n   * @returns {Promise<void>} - Resolves when verified.\n   */\n  async _ensureConcurrencyKey(db, {concurrencyKey, maxConcurrency}) {\n    const rows = await db.newQuery().from(CONCURRENCY_TABLE).where({concurrency_key: concurrencyKey}).limit(1).results()\n    if (!rows[0]) {\n      try {\n        await db.insert({tableName: CONCURRENCY_TABLE, data: {active_count: 0, concurrency_key: concurrencyKey, max_concurrency: maxConcurrency}})\n        return\n      } catch (error) {\n        const racedRows = await db.newQuery().from(CONCURRENCY_TABLE).where({concurrency_key: concurrencyKey}).limit(1).results()\n        if (!racedRows[0]) throw error\n        rows[0] = racedRows[0]\n      }\n    }\n    const configured = /** @type {{max_concurrency?: number | string}} */ (rows[0])\n    if (this._normalizeNumber(configured.max_concurrency) !== maxConcurrency) throw new Error(`Conflicting maxConcurrency for background job concurrencyKey: ${concurrencyKey}`)\n  }\n\n  /**\n   * Locks the concurrency counter row so a job-release transaction acquires it *before* the job\n   * row. {@link markHandedOff} reserves capacity (locking the counter row) before it updates the\n   * job, so it locks concurrency-then-job; the release paths update the job before releasing\n   * capacity, which is job-then-concurrency. Those opposite orders on the same shared counter row\n   * are what deadlock (AB-BA) under a draining worker. Taking this lock first gives every\n   * transaction a single concurrency-then-job order and removes the cycle.\n   *\n   * Uses a value-preserving `UPDATE` rather than `SELECT ... FOR UPDATE` so it stays portable\n   * across drivers without row-level locking reads (e.g. SQLite); on row-locking engines the\n   * matched row is write-locked for the rest of the transaction even though its value is unchanged.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string | null} concurrencyKey - Concurrency key.\n   * @returns {Promise<void>} - Resolves when the counter row is locked.\n   */\n  async _lockConcurrencyRow(db, concurrencyKey) {\n    if (!concurrencyKey) return\n    const table = db.quoteTable(CONCURRENCY_TABLE)\n    const count = db.quoteColumn(\"active_count\")\n    await db.query(`UPDATE ${table} SET ${count} = ${count} WHERE ${db.quoteColumn(\"concurrency_key\")} = ${db.quote(concurrencyKey)}`)\n  }\n\n  /**\n   * Atomically reserves capacity for a key.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} concurrencyKey - Concurrency key.\n   * @returns {Promise<boolean>} - Whether capacity was reserved.\n   */\n  async _reserveConcurrency(db, concurrencyKey) {\n    const table = db.quoteTable(CONCURRENCY_TABLE)\n    const count = db.quoteColumn(\"active_count\")\n    const affectedRows = await db.affectedRows(`UPDATE ${table} SET ${count} = ${count} + 1 WHERE ${db.quoteColumn(\"concurrency_key\")} = ${db.quote(concurrencyKey)} AND ${count} < ${db.quoteColumn(\"max_concurrency\")}`)\n    return affectedRows === 1\n  }\n\n  /**\n   * Runs a portable update and returns its affected-row count.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {import(\"../database/drivers/base.js\").UpdateSqlArgsType} args - Update options.\n   * @returns {Promise<number>} - Affected row count.\n   */\n  async _updateAffectedRows(db, args) {\n    return await db.affectedRows(db.updateSql(args))\n  }\n\n  /**\n   * Releases capacity for a key.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string | null} concurrencyKey - Concurrency key.\n   * @returns {Promise<void>} - Resolves when released.\n   */\n  async _releaseConcurrency(db, concurrencyKey) {\n    if (!concurrencyKey) return\n    const table = db.quoteTable(CONCURRENCY_TABLE)\n    const count = db.quoteColumn(\"active_count\")\n    await db.query(`UPDATE ${table} SET ${count} = ${count} - 1 WHERE ${db.quoteColumn(\"concurrency_key\")} = ${db.quote(concurrencyKey)} AND ${count} > 0`)\n  }\n\n  /**\n   * Rebuilds durable counts from active handoffs.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {{insideTransaction?: boolean}} [options] - Reuse an enclosing transaction.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobConcurrencyReconciliation>} - Repair summary.\n   */\n  async _reconcileConcurrency(db, {insideTransaction = false} = {}) {\n    if (!(await db.tableExists(CONCURRENCY_TABLE))) {\n      return {candidateCount: 0, checkedCount: 0, repairedCount: 0, repairs: [], repairsTruncatedCount: 0}\n    }\n\n    const activeRows = await db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .select(\"concurrency_key\")\n      .select(\"COUNT(*) AS active_count\")\n      .where({status: \"handed_off\"})\n      .where(`${db.quoteColumn(\"concurrency_key\")} IS NOT NULL`)\n      .group(\"concurrency_key\")\n      .results()\n    const staleRows = await db\n      .newQuery()\n      .from(CONCURRENCY_TABLE)\n      .select(\"concurrency_key\")\n      .select(\"active_count\")\n      .where(`${db.quoteColumn(\"active_count\")} != 0`)\n      .results()\n    /** @type {Map<string, number>} */\n    const activeCounts = new Map()\n    /** @type {Map<string, number>} */\n    const persistedCounts = new Map()\n\n    for (const rawRow of activeRows) {\n      const row = /** @type {BackgroundJobConcurrencyCountRow} */ (rawRow)\n      activeCounts.set(row.concurrency_key, this._validatedConcurrencyCount(row.active_count, row.concurrency_key))\n    }\n\n    for (const rawRow of staleRows) {\n      const row = /** @type {BackgroundJobConcurrencyCountRow} */ (rawRow)\n      persistedCounts.set(row.concurrency_key, this._validatedConcurrencyCount(row.active_count, row.concurrency_key))\n    }\n\n    const concurrencyKeys = [...new Set([...activeCounts.keys(), ...persistedCounts.keys()])].sort()\n    const candidateKeys = concurrencyKeys.filter((concurrencyKey) => {\n      return (activeCounts.get(concurrencyKey) || 0) !== (persistedCounts.get(concurrencyKey) || 0)\n    })\n    /** @type {import(\"./types.js\").BackgroundJobConcurrencyRepair[]} */\n    const repairs = []\n    let repairedCount = 0\n\n    for (const concurrencyKey of candidateKeys) {\n      const repair = insideTransaction\n        ? await this._reconcileConcurrencyKey(db, concurrencyKey)\n        : await this._transactionResult(db, async () => await this._reconcileConcurrencyKey(db, concurrencyKey))\n\n      if (!repair) continue\n\n      repairedCount++\n      if (repairs.length < CONCURRENCY_REPAIR_SAMPLE_LIMIT) repairs.push(repair)\n    }\n\n    return {\n      candidateCount: candidateKeys.length,\n      checkedCount: concurrencyKeys.length,\n      repairedCount,\n      repairs,\n      repairsTruncatedCount: repairedCount - repairs.length\n    }\n  }\n\n  /**\n   * Rebuilds one counter after locking it ahead of the job rows, matching the\n   * lock order used by handoff and completion transitions.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {string} concurrencyKey - Counter key.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobConcurrencyRepair | null>} - Applied repair.\n   */\n  async _reconcileConcurrencyKey(db, concurrencyKey) {\n    await this._lockConcurrencyRow(db, concurrencyKey)\n    const persistedRows = await db\n      .newQuery()\n      .from(CONCURRENCY_TABLE)\n      .select(\"active_count\")\n      .select(\"concurrency_key\")\n      .where({concurrency_key: concurrencyKey})\n      .limit(1)\n      .results()\n\n    if (!persistedRows[0]) throw new Error(`Missing background job concurrency counter for ${concurrencyKey}`)\n\n    const persistedRow = /** @type {BackgroundJobConcurrencyCountRow} */ (persistedRows[0])\n    const previousActiveCount = this._validatedConcurrencyCount(persistedRow.active_count, concurrencyKey)\n    const rows = await db\n      .newQuery()\n      .from(JOBS_TABLE)\n      .select(\"COUNT(*) AS active_count\")\n      .where({concurrency_key: concurrencyKey, status: \"handed_off\"})\n      .results()\n    const countRow = /** @type {{active_count: number | string}} */ (rows[0])\n    const activeCount = this._validatedConcurrencyCount(countRow.active_count, concurrencyKey)\n\n    if (activeCount === previousActiveCount) return null\n\n    await db.update({\n      tableName: CONCURRENCY_TABLE,\n      data: {active_count: activeCount},\n      conditions: {concurrency_key: concurrencyKey}\n    })\n\n    return {activeCount, concurrencyKey, previousActiveCount}\n  }\n\n  /**\n   * Validates a database count before it participates in reconciliation.\n   * @param {number | string} value - Raw count.\n   * @param {string} concurrencyKey - Counter key for diagnostics.\n   * @returns {number} - Safe non-negative count.\n   */\n  _validatedConcurrencyCount(value, concurrencyKey) {\n    const count = this._normalizeNumber(value)\n\n    if (count === null || !Number.isSafeInteger(count) || count < 0) {\n      throw new Error(`Invalid reconciled background job concurrency count for ${concurrencyKey}: ${count}`)\n    }\n\n    return count\n  }\n\n  /**\n   * Reconciles queue-derived concurrency with the current configuration. Only\n   * invoked through {@link reconcileQueueConcurrency} — the explicit lifecycle\n   * path run at main-process startup under a cross-process advisory lock —\n   * never from schema/tenant checks or routine connection initialization,\n   * which stay read-only regarding queued job rows. The per-process memo is\n   * latched by {@link reconcileQueueConcurrency} only after the following\n   * count rebuild also succeeds, so a failed rebuild re-enters here on retry\n   * (the adoption UPDATEs below are idempotent). Enqueue only consults config for new jobs, so a cap added, removed, or changed\n   * while a backlog exists otherwise leaves persisted rows stale: pre-cap jobs\n   * keep a null key and bypass the cap, post-removal jobs stay capped under a\n   * now-unconfigured key, and a changed numeric cap stays stale until the next\n   * enqueue. Bring queued durable state in line with config: sync each configured\n   * queue's stored cap, adopt not-yet-keyed queued jobs onto their queue key,\n   * and release queued jobs from queue keys whose queue is no longer capped.\n   * Existing handoffs retain the policy and reservation they started with, so\n   * reconciliation cannot race their completion/retry transitions. Runs before\n   * {@link _reconcileConcurrency} so any pre-existing active counts are exact.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<void>} - Resolves when reconciled.\n   */\n  async _reconcileQueueConcurrency(db) {\n    if (this._queueConcurrencyReconciled) return\n    if (!(await db.tableExists(CONCURRENCY_TABLE))) return\n\n    const queuesConfig = this.configuration.getBackgroundJobsConfig().queues || {}\n    const jobsTable = db.quoteTable(JOBS_TABLE)\n    const keyColumn = db.quoteColumn(\"concurrency_key\")\n    const capColumn = db.quoteColumn(\"max_concurrency\")\n    const queueColumn = db.quoteColumn(\"queue\")\n    const queued = `${db.quoteColumn(\"status\")} = ${db.quote(\"queued\")}`\n    /** @type {Set<string>} */\n    const cappedQueues = new Set()\n\n    for (const queue of Object.keys(queuesConfig)) {\n      const cap = this._queueMaxConcurrency(queue)\n\n      if (cap === null) continue\n\n      cappedQueues.add(queue)\n      const concurrencyKey = `${QUEUE_CONCURRENCY_KEY_PREFIX}${queue}`\n\n      await this._ensureQueueConcurrencyKey(db, {concurrencyKey, maxConcurrency: cap})\n      await db.query(\n        `UPDATE ${jobsTable} SET ${keyColumn} = ${db.quote(concurrencyKey)}, ${capColumn} = ${Number(cap)} ` +\n        `WHERE ${queueColumn} = ${db.quote(queue)} AND ${keyColumn} IS NULL AND ${queued}`\n      )\n    }\n\n    const concurrencyRows = await db\n      .newQuery()\n      .from(CONCURRENCY_TABLE)\n      .select(\"concurrency_key\")\n      .where(`${db.quoteColumn(\"concurrency_key\")} LIKE ${db.quote(`${QUEUE_CONCURRENCY_KEY_PREFIX}%`)}`)\n      .results()\n\n    for (const row of concurrencyRows) {\n      const concurrencyKey = String(/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (row).concurrency_key)\n\n      if (!concurrencyKey.startsWith(QUEUE_CONCURRENCY_KEY_PREFIX)) continue\n      if (cappedQueues.has(concurrencyKey.slice(QUEUE_CONCURRENCY_KEY_PREFIX.length))) continue\n\n      await db.query(\n        `UPDATE ${jobsTable} SET ${keyColumn} = NULL, ${capColumn} = NULL ` +\n        `WHERE ${keyColumn} = ${db.quote(concurrencyKey)} AND ${queued}`\n      )\n    }\n  }\n\n  /**\n   * Runs normalize number.\n   * @param {ReturnType<typeof JSON.parse>} value - Input value.\n   * @returns {number | null} - Normalized number.\n   */\n  _normalizeNumber(value) {\n    if (value === null || value === undefined || value === \"\") return null\n\n    const numeric = Number(value)\n\n    if (Number.isNaN(numeric)) return null\n\n    return numeric\n  }\n\n  /**\n   * Runs normalize execution mode.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [options] - Job options.\n   * @returns {import(\"./types.js\").BackgroundJobExecutionMode} - Normalized execution mode.\n   */\n  _normalizeExecutionMode(options) {\n    return normalizeBackgroundJobExecutionMode(options || {}, DEFAULT_BACKGROUND_JOB_EXECUTION_MODE)\n  }\n\n  /**\n   * Runs normalize execution mode name.\n   * @param {string} executionMode - Execution mode name.\n   * @returns {import(\"./types.js\").BackgroundJobExecutionMode} - Normalized execution mode.\n   */\n  _normalizeExecutionModeName(executionMode) {\n    return normalizeBackgroundJobExecutionMode(\n      {executionMode: /** @type {import(\"./types.js\").BackgroundJobExecutionMode} */ (executionMode)},\n      DEFAULT_BACKGROUND_JOB_EXECUTION_MODE,\n      BACKGROUND_JOB_EXECUTION_MODES\n    )\n  }\n\n  /**\n   * Filters queued jobs by one or more execution modes against the\n   * `execution_mode` column (the single source of truth).\n   * @param {object} args - Options.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Database connection.\n   * @param {import(\"./types.js\").BackgroundJobExecutionMode | import(\"./types.js\").BackgroundJobExecutionMode[]} args.executionMode - Runtime modes.\n   * @param {import(\"../database/query/index.js\").default} args.query - Query to filter.\n   * @returns {import(\"../database/query/index.js\").default} - Filtered query.\n   */\n  _whereExecutionMode({db, executionMode, query}) {\n    const executionModes = Array.isArray(executionMode) ? executionMode : [executionMode]\n    const executionModeColumn = db.quoteColumn(\"execution_mode\")\n    const conditions = executionModes.map((mode) => `${executionModeColumn} = ${db.quote(mode)}`)\n\n    return query.where(`(${conditions.join(\" OR \")})`)\n  }\n\n  /**\n   * Runs parse args.\n   * @param {ReturnType<typeof JSON.parse>} value - Input value.\n   * @returns {Array<ReturnType<typeof JSON.parse>>} - Parsed args.\n   */\n  _parseArgs(value) {\n    if (!value) return []\n\n    try {\n      const parsed = JSON.parse(String(value))\n\n      if (Array.isArray(parsed)) return parsed\n    } catch {\n      // Ignore parse errors.\n    }\n\n    return []\n  }\n\n  /**\n   * Runs with db.\n   * @template T\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<T>} callback - Callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async _withDb(callback) {\n    const databaseIdentifier = this.getDatabaseIdentifier()\n    const pool = this.configuration.getDatabasePool(databaseIdentifier)\n\n    if (!pool.testSharedConnection()) {\n      return await pool.withConnection({name: \"Background jobs store\"}, callback)\n    }\n\n    return await this.configuration.runWithTestSharedConnectionContexts(async () => {\n      return await this.configuration.ensureConnections({databaseIdentifiers: [databaseIdentifier], name: \"Background jobs store\"}, async (dbs) => {\n        const connection = dbs[databaseIdentifier]\n        return await coordinateSharedTransactionConnection(connection, async () => await callback(connection))\n      })\n    })\n  }\n\n  /**\n   * Runs a value-returning callback inside the driver's void-typed transaction API.\n   * @template T\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @param {() => Promise<T>} callback - Transaction callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async _transactionResult(db, callback) {\n    let completed = false\n    /** @type {T | undefined} */\n    let result\n    await db.transaction(async () => {\n      result = await callback()\n      completed = true\n    })\n    if (!completed) throw new Error(\"Background jobs transaction callback was not invoked\")\n    return /** @type {T} */ (result)\n  }\n\n  /**\n   * Serializes count-changing transactions before checking out their connection.\n   * Database row locking still provides cross-process ordering; this guard\n   * prevents concurrent callers on SQLite's shared connection from attempting\n   * overlapping top-level transactions.\n   * @template T\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<T>} callback - Transaction callback.\n   * @param {BackgroundJobTransactionSerializationOptions} [options] - Serialization options.\n   * @returns {Promise<T>} Callback result.\n   */\n  async _serializedCountMutation(callback, options = {}) {\n    return await this._serializedTransactionMutation(async (db) => {\n      await this._lockCountRevision(db)\n\n      return await callback(db)\n    }, options)\n  }\n\n  /**\n   * Runs a serialized callback inside one transaction.\n   * @template T\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<T>} callback - Transaction callback.\n   * @param {BackgroundJobTransactionSerializationOptions} [options] - Serialization options.\n   * @returns {Promise<T>} Callback result.\n   */\n  async _serializedTransactionMutation(callback, options = {}) {\n    return await this._serializedConnectionMutation(\n      async (db) => await this._transactionResult(db, async () => await callback(db)),\n      options\n    )\n  }\n\n  /**\n   * Admits mutation callbacks to the process-local FIFO before they check out a\n   * connection. Cross-process ordering remains the responsibility of durable\n   * row/advisory locks and unique constraints acquired around the callback.\n   * @template T\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<T>} callback - Connection callback.\n   * @param {BackgroundJobTransactionSerializationOptions} [options] - Serialization options.\n   * @returns {Promise<T>} Callback result.\n   */\n  async _serializedConnectionMutation(callback, options = {}) {\n    const identifier = this.getDatabaseIdentifier() || \"default\"\n    const previous = transactionMutationChains.get(identifier) || Promise.resolve()\n    let resolveRun = () => {}\n    /** @type {Promise<void>} */\n    const run = new Promise((resolve) => {\n      resolveRun = () => resolve(undefined)\n    })\n    const chain = previous.then(() => run)\n\n    transactionMutationChains.set(identifier, chain)\n    await previous\n\n    try {\n      return await this._withDb(async (db) => {\n        const {advisoryLock} = options\n\n        if (advisoryLock) {\n          const acquired = await db.acquireAdvisoryLock(advisoryLock.name)\n\n          if (!acquired) throw new Error(advisoryLock.failureMessage)\n        }\n\n        try {\n          return await callback(db)\n        } finally {\n          if (advisoryLock) await db.releaseAdvisoryLock(advisoryLock.name)\n        }\n      })\n    } finally {\n      resolveRun()\n      if (transactionMutationChains.get(identifier) === chain) transactionMutationChains.delete(identifier)\n    }\n  }\n\n  /**\n   * Runs should accept report.\n   * @param {object} args - Options.\n   * @param {import(\"./types.js\").BackgroundJobRow} args.job - Job row.\n   * @param {string | null | undefined} args.handoffId - Handoff lease id from report.\n   * @param {string | null | undefined} args.workerId - Worker id from report.\n   * @param {number | null | undefined} args.handedOffAtMs - Handed off timestamp from report.\n   * @returns {boolean} - Whether to accept the report.\n   */\n  _shouldAcceptReport({job, handoffId, workerId, handedOffAtMs}) {\n    if (job.status !== \"handed_off\") return false\n\n    return this._handoffIdReportMatches({handoffId, job})\n      && this._workerReportMatches({job, workerId})\n      && this._handoffReportMatches({handedOffAtMs, job})\n  }\n\n  /**\n   * Runs active handoff conditions.\n   * @param {import(\"./types.js\").BackgroundJobRow} job - Job row.\n   * @returns {Record<string, string | null>} - Conditional transition fence.\n   */\n  _activeHandoffConditions(job) {\n    return {handoff_id: job.handoffId, id: job.id, status: \"handed_off\"}\n  }\n\n  /**\n   * Runs handoff id report matches.\n   * @param {object} args - Options.\n   * @param {string | null | undefined} args.handoffId - Handoff lease id from report.\n   * @param {import(\"./types.js\").BackgroundJobRow} args.job - Job row.\n   * @returns {boolean} - Whether the handoff lease matches.\n   */\n  _handoffIdReportMatches({handoffId, job}) {\n    if (!job.handoffId) return true\n\n    return handoffId === job.handoffId\n  }\n\n  /**\n   * Runs worker report matches.\n   * @param {object} args - Options.\n   * @param {import(\"./types.js\").BackgroundJobRow} args.job - Job row.\n   * @param {string | null | undefined} args.workerId - Worker id from report.\n   * @returns {boolean} - Whether the worker report matches.\n   */\n  _workerReportMatches({job, workerId}) {\n    if (!workerId) return true\n    if (!job.workerId) return true\n\n    return workerId === job.workerId\n  }\n\n  /**\n   * Runs handoff report matches.\n   * @param {object} args - Options.\n   * @param {number | null | undefined} args.handedOffAtMs - Handed off timestamp from report.\n   * @param {import(\"./types.js\").BackgroundJobRow} args.job - Job row.\n   * @returns {boolean} - Whether the handoff report matches.\n   */\n  _handoffReportMatches({handedOffAtMs, job}) {\n    if (!handedOffAtMs) return true\n    if (!job.handedOffAtMs) return true\n\n    return handedOffAtMs === job.handedOffAtMs\n  }\n\n  /**\n   * Runs migration key.\n   * @param {string} [version] - Migration version.\n   * @returns {string} - Migration key.\n   */\n  _migrationKey(version = MIGRATION_VERSION) {\n    return `${MIGRATION_SCOPE}:${version}`\n  }\n}\n"]}