velocious 1.0.606 → 1.0.607

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

@@ -0,0 +1,1078 @@
+// @ts-check
+import UUID from "pure-uuid";
+import TableData from "../database/table-data/index.js";
+import TableIndex from "../database/table-data/table-index.js";
+import sha256Hex from "../utils/sha256-hex.js";
+import normalizeBackgroundJobError from "./normalize-error.js";
+import { DEFAULT_BACKGROUND_JOB_QUEUE, QUEUE_CONCURRENCY_KEY_PREFIX, normalizeBackgroundJobConcurrency, normalizeBackgroundJobExecutionMode, normalizeBackgroundJobMaxRetries, normalizeBackgroundJobQueue, normalizeBackgroundJobScheduledAtMs, rescheduledBackgroundJobAtMs, retryDelayMs } from "./job-semantics.js";
+export const LOCAL_BACKGROUND_JOBS_TABLE = "velocious_local_background_jobs";
+export const LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE = "velocious_local_background_job_concurrency";
+const MIGRATIONS_TABLE = "velocious_internal_migrations";
+const MIGRATION_SCOPE = "local_background_jobs";
+const MIGRATION_VERSION = "1";
+const LOCAL_EXECUTION_MODES = [/** @type {const} */ ("inline")];
+export const LOCAL_BACKGROUND_JOBS_INDEX_NAMES = [
+    "index_velocious_local_background_jobs_due",
+    "index_velocious_local_background_jobs_queue_status",
+    "index_velocious_local_background_jobs_deduplication",
+    "index_velocious_local_background_jobs_concurrency"
+];
+const EXPECTED_JOB_COLUMNS = [
+    "id",
+    "job_name",
+    "args_json",
+    "args_digest",
+    "execution_mode",
+    "queue",
+    "max_retries",
+    "attempts",
+    "status",
+    "scheduled_at_ms",
+    "created_at_ms",
+    "handed_off_at_ms",
+    "handoff_id",
+    "worker_id",
+    "completed_at_ms",
+    "failed_at_ms",
+    "last_error",
+    "concurrency_key",
+    "max_concurrency"
+];
+const EXPECTED_CONCURRENCY_COLUMNS = ["concurrency_key", "max_concurrency", "active_count"];
+/** @type {WeakMap<import("../configuration.js").default, Map<string, Promise<void>>>} */
+const deduplicatedEnqueueChains = new WeakMap();
+/**
+ * Creates the production clock used by local dispatch.
+ * @returns {import("./types.js").LocalBackgroundJobsClock} - Production clock.
+ */
+export function localBackgroundJobsClock() {
+    return {
+        clearTimeout: (timerId) => globalThis.clearTimeout(timerId),
+        now: () => Date.now(),
+        setTimeout: (callback, delayMs) => globalThis.setTimeout(callback, delayMs)
+    };
+}
+/** Namespaced portable SQLite persistence for local background jobs. */
+export default class LocalBackgroundJobsStore {
+    /**
+     * Creates a store for one configuration and local database.
+     * @param {object} args - Store options.
+     * @param {import("../configuration.js").default} args.configuration - Owning configuration.
+     * @param {import("./types.js").LocalBackgroundJobsClock} [args.clock] - Persistence clock.
+     * @param {string} [args.databaseIdentifier] - Configured local database identifier.
+     * @param {() => void} [args.onCommittedEnqueue] - Commit-aware dispatcher wake.
+     */
+    constructor({ configuration, clock = localBackgroundJobsClock(), databaseIdentifier, onCommittedEnqueue }) {
+        this.clock = clock;
+        this.configuration = configuration;
+        this.databaseIdentifier = databaseIdentifier;
+        this.onCommittedEnqueue = onCommittedEnqueue;
+        this._isReady = false;
+        /** @type {Promise<void> | null} */
+        this._readyPromise = null;
+        /** @type {WeakMap<import("../database/drivers/base.js").default, {completion: Promise<void>, promise: Promise<void>}>} */
+        this._transactionReadyPromises = new WeakMap();
+    }
+    /**
+     * Resolves the configured local database identifier.
+     * @returns {string} - Database identifier.
+     */
+    getDatabaseIdentifier() {
+        return this.databaseIdentifier || this.configuration.getBackgroundJobsConfig().databaseIdentifier;
+    }
+    /**
+     * Ensures the versioned physical schema exists.
+     * @returns {Promise<void>} - Resolves when ready.
+     */
+    async ensureReady() {
+        if (this._isReady)
+            return;
+        await this._withDb(async (db) => await this._ensureReadyWithDb(db));
+    }
+    /**
+     * Clears the per-instance readiness latch for a deliberate adapter reopen.
+     * @returns {void} - No return value.
+     */
+    resetReadiness() {
+        this._isReady = false;
+        this._readyPromise = null;
+        this._transactionReadyPromises = new WeakMap();
+    }
+    /**
+     * Coordinates physical and transaction-local schema readiness.
+     * @param {import("../database/drivers/base.js").default} db - Local SQLite connection.
+     * @returns {Promise<void>} - Resolves when this caller can use the schema.
+     */
+    async _ensureReadyWithDb(db) {
+        if (this._isReady)
+            return;
+        const transactionCompletion = db.insideTransaction() ? db.transactionCompletion() : null;
+        const transactionReady = this._transactionReadyPromises.get(db);
+        if (transactionCompletion && transactionReady?.completion === transactionCompletion) {
+            await transactionReady.promise;
+            return;
+        }
+        if (this._readyPromise) {
+            const readyPromise = this._readyPromise;
+            await readyPromise;
+            if (this._readyPromise === readyPromise)
+                this._readyPromise = null;
+            if (this._isReady)
+                return;
+            await this.ensureReady();
+            return;
+        }
+        if (transactionCompletion) {
+            const schemaReadyPromise = this._applySchema(db);
+            const transactionReadyPromise = schemaReadyPromise.then(() => undefined);
+            const transactionReady = { completion: transactionCompletion, promise: transactionReadyPromise };
+            const durableReadyPromise = schemaReadyPromise.then(async (changed) => {
+                if (!changed) {
+                    this._isReady = true;
+                    return;
+                }
+                await transactionCompletion;
+            }, () => {
+                // The transaction-local caller below owns and rethrows this same schema error.
+                // This branch only settles the shared durability barrier so it cannot become
+                // an independent unhandled rejection while failed ownership is cleared.
+            });
+            this._transactionReadyPromises.set(db, transactionReady);
+            this._readyPromise = durableReadyPromise;
+            try {
+                await transactionReadyPromise;
+            }
+            catch (error) {
+                if (this._transactionReadyPromises.get(db) === transactionReady)
+                    this._transactionReadyPromises.delete(db);
+                if (this._readyPromise === durableReadyPromise)
+                    this._readyPromise = null;
+                throw error;
+            }
+            return;
+        }
+        this._readyPromise = this._transactionResult(db, async () => await this._applySchema(db)).then(() => {
+            this._isReady = true;
+        });
+        try {
+            await this._readyPromise;
+        }
+        finally {
+            if (!this._isReady)
+                this._readyPromise = null;
+        }
+    }
+    /**
+     * Creates or repairs version-one tables and indexes.
+     * @param {import("../database/drivers/base.js").default} db - Local SQLite connection.
+     * @returns {Promise<boolean>} - Whether schema state changed.
+     */
+    async _applySchema(db) {
+        let changed = false;
+        if (!(await db.tableExists(MIGRATIONS_TABLE))) {
+            await db.createTable(this._migrationsTableData());
+            changed = true;
+        }
+        if (!(await db.tableExists(LOCAL_BACKGROUND_JOBS_TABLE))) {
+            await db.createTable(this._jobsTableData());
+            changed = true;
+        }
+        else {
+            await this._assertColumns(db, LOCAL_BACKGROUND_JOBS_TABLE, EXPECTED_JOB_COLUMNS);
+        }
+        if (!(await db.tableExists(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE))) {
+            await db.createTable(this._concurrencyTableData());
+            changed = true;
+        }
+        else {
+            await this._assertColumns(db, LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE, EXPECTED_CONCURRENCY_COLUMNS);
+        }
+        if (await this._ensureIndexes(db))
+            changed = true;
+        if (!(await this._hasMigration(db))) {
+            await db.upsert({
+                tableName: MIGRATIONS_TABLE,
+                data: {
+                    applied_at_ms: this.clock.now(),
+                    key: this._migrationKey(),
+                    scope: MIGRATION_SCOPE,
+                    version: MIGRATION_VERSION
+                },
+                conflictColumns: ["key"],
+                updateColumns: ["scope", "version", "applied_at_ms"]
+            });
+            changed = true;
+        }
+        return changed;
+    }
+    /**
+     * Builds the migration ledger table definition.
+     * @returns {TableData} - Migration ledger table.
+     */
+    _migrationsTableData() {
+        const table = new TableData(MIGRATIONS_TABLE, { ifNotExists: true });
+        table.string("key", { null: false, primaryKey: true });
+        table.string("scope", { null: false });
+        table.string("version", { null: false });
+        table.bigint("applied_at_ms", { null: false });
+        return table;
+    }
+    /**
+     * Builds the local jobs table definition.
+     * @returns {TableData} - Local jobs table definition.
+     */
+    _jobsTableData() {
+        const table = new TableData(LOCAL_BACKGROUND_JOBS_TABLE, { ifNotExists: true });
+        table.string("id", { null: false, primaryKey: true });
+        table.string("job_name", { null: false });
+        table.text("args_json", { null: false });
+        table.string("args_digest", { maxLength: 64, null: false });
+        table.string("execution_mode", { null: false });
+        table.string("queue", { null: false });
+        table.integer("max_retries", { null: false });
+        table.integer("attempts", { null: false });
+        table.string("status", { null: false });
+        table.bigint("scheduled_at_ms", { null: false });
+        table.bigint("created_at_ms", { null: false });
+        table.bigint("handed_off_at_ms", { null: true });
+        table.string("handoff_id", { null: true });
+        table.string("worker_id", { null: true });
+        table.bigint("completed_at_ms", { null: true });
+        table.bigint("failed_at_ms", { null: true });
+        table.text("last_error", { null: true });
+        table.string("concurrency_key", { null: true });
+        table.integer("max_concurrency", { null: true });
+        table.addIndex(new TableIndex(["status", "scheduled_at_ms", "created_at_ms", "id"], { name: LOCAL_BACKGROUND_JOBS_INDEX_NAMES[0] }));
+        table.addIndex(new TableIndex(["queue", "status", "created_at_ms"], { name: LOCAL_BACKGROUND_JOBS_INDEX_NAMES[1] }));
+        table.addIndex(new TableIndex(["args_digest"], { name: LOCAL_BACKGROUND_JOBS_INDEX_NAMES[2] }));
+        table.addIndex(new TableIndex(["status", "concurrency_key", "scheduled_at_ms"], { name: LOCAL_BACKGROUND_JOBS_INDEX_NAMES[3] }));
+        return table;
+    }
+    /**
+     * Builds the local concurrency counter table definition.
+     * @returns {TableData} - Concurrency counter table definition.
+     */
+    _concurrencyTableData() {
+        const table = new TableData(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE, { ifNotExists: true });
+        table.string("concurrency_key", { null: false, primaryKey: true });
+        table.integer("max_concurrency", { null: false });
+        table.integer("active_count", { null: false });
+        return table;
+    }
+    /**
+     * Rejects an incompatible current-version table rather than rebuilding data.
+     * @param {import("../database/drivers/base.js").default} db - Local SQLite connection.
+     * @param {string} tableName - Table name.
+     * @param {string[]} expectedColumns - Required columns.
+     * @returns {Promise<void>} - Resolves when compatible.
+     */
+    async _assertColumns(db, tableName, expectedColumns) {
+        const table = await db.getTableByNameOrFail(tableName);
+        const columns = await table.getColumns();
+        const names = new Set(columns.map((column) => column.getName()));
+        const missing = expectedColumns.filter((columnName) => !names.has(columnName));
+        if (missing.length === 0)
+            return;
+        const error = new Error(`Incompatible local background-jobs schema for ${tableName}; missing columns: ${missing.join(", ")}`);
+        this._reportFrameworkError({ error, stage: "local-background-jobs-schema" });
+        throw error;
+    }
+    /**
+     * Recreates missing indexes declared by the current schema.
+     * @param {import("../database/drivers/base.js").default} db - Local SQLite connection.
+     * @returns {Promise<boolean>} - Whether an index was created.
+     */
+    async _ensureIndexes(db) {
+        db.clearSchemaCache();
+        const jobsTable = await db.getTableByNameOrFail(LOCAL_BACKGROUND_JOBS_TABLE);
+        const existingNames = new Set((await jobsTable.getIndexes()).map((index) => index.getName()));
+        let changed = false;
+        for (const index of this._jobsTableData().getIndexes()) {
+            const indexName = index.getName();
+            if (!indexName || existingNames.has(indexName))
+                continue;
+            const sqls = await db.createIndexSQLs({
+                columns: index.getColumns(),
+                ifNotExists: true,
+                name: indexName,
+                tableName: LOCAL_BACKGROUND_JOBS_TABLE,
+                unique: index.getUnique()
+            });
+            for (const sql of sqls)
+                await db.query(sql);
+            changed = true;
+        }
+        if (changed)
+            db.clearSchemaCache();
+        return changed;
+    }
+    /**
+     * Checks whether the current local schema version is recorded.
+     * @param {import("../database/drivers/base.js").default} db - Connection.
+     * @returns {Promise<boolean>} - Whether version one is recorded.
+     */
+    async _hasMigration(db) {
+        const rows = await db
+            .newQuery()
+            .from(MIGRATIONS_TABLE)
+            .where({ key: this._migrationKey() })
+            .limit(1)
+            .results();
+        return rows.length > 0;
+    }
+    /**
+     * Builds the scoped migration key.
+     * @returns {string} - Scoped migration key.
+     */
+    _migrationKey() { return `${MIGRATION_SCOPE}:${MIGRATION_VERSION}`; }
+    /**
+     * Enqueues a local job in the caller's active transaction when present.
+     * @param {object} args - Enqueue request.
+     * @param {string} args.jobName - Registered job name.
+     * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Serialized job arguments.
+     * @param {import("./types.js").BackgroundJobOptions} [args.options] - Job options.
+     * @returns {Promise<string>} - Durable job id.
+     */
+    async enqueue({ jobName, args, options = {} }) {
+        await this.ensureReady();
+        const preparedJob = this._prepareJob({ args, jobName, options });
+        const mutate = async (holdUntil = (/** @type {Promise<void>} */ _completion) => { }) => await this._withDb(async (connection) => {
+            if (connection.insideTransaction())
+                holdUntil(connection.transactionCompletion());
+            return await this._mutate(connection, async (db) => {
+                let jobId = preparedJob.jobId;
+                if (preparedJob.concurrency)
+                    await this._ensureConcurrency(db, preparedJob.concurrency);
+                if (options.deduplicateWhileQueued) {
+                    const existing = await db
+                        .newQuery()
+                        .from(LOCAL_BACKGROUND_JOBS_TABLE)
+                        .select("id")
+                        .where({
+                        args_digest: preparedJob.argsDigest,
+                        args_json: preparedJob.argsJson,
+                        job_name: preparedJob.jobName,
+                        queue: preparedJob.queue,
+                        status: "queued"
+                    })
+                        .where(`scheduled_at_ms <= ${db.quote(preparedJob.scheduledAtMs)}`)
+                        .order("scheduled_at_ms ASC")
+                        .order("created_at_ms ASC")
+                        .limit(1)
+                        .results();
+                    const existingRow = /** @type {{id: string | number} | undefined} */ (existing[0]);
+                    if (existingRow)
+                        jobId = String(existingRow.id);
+                }
+                if (jobId === preparedJob.jobId)
+                    await this._insertPreparedJob(db, preparedJob);
+                if (this.onCommittedEnqueue)
+                    await db.afterCommit(this.onCommittedEnqueue);
+                return jobId;
+            });
+        });
+        if (options.deduplicateWhileQueued)
+            return await this._serializeDeduplicatedEnqueue(preparedJob, mutate);
+        return await mutate();
+    }
+    /**
+     * Serializes matching in-process deduplication checks through commit while
+     * leaving unrelated job identities independent.
+     * @template T
+     * @param {import("./types.js").PreparedLocalBackgroundJob} preparedJob - Prepared job identity.
+     * @param {(holdUntil: (completion: Promise<void>) => void) => Promise<T>} callback - Deduplication mutation.
+     * @returns {Promise<T>} - Mutation result.
+     */
+    async _serializeDeduplicatedEnqueue(preparedJob, callback) {
+        let chains = deduplicatedEnqueueChains.get(this.configuration);
+        if (!chains) {
+            chains = new Map();
+            deduplicatedEnqueueChains.set(this.configuration, chains);
+        }
+        const key = sha256Hex(JSON.stringify([
+            this.getDatabaseIdentifier(),
+            preparedJob.jobName,
+            preparedJob.argsDigest,
+            preparedJob.queue
+        ]));
+        const previous = chains.get(key) || Promise.resolve();
+        let release = () => { };
+        const running = new Promise((resolve) => { release = () => resolve(undefined); });
+        const chain = previous.then(() => running);
+        /** @type {Promise<void> | undefined} */
+        let completion;
+        const finish = () => {
+            release();
+            if (chains.get(key) === chain)
+                chains.delete(key);
+            if (chains.size === 0)
+                deduplicatedEnqueueChains.delete(this.configuration);
+        };
+        chains.set(key, chain);
+        await previous;
+        try {
+            const result = await callback((transactionCompletion) => { completion = transactionCompletion; });
+            if (completion) {
+                completion.then(finish, finish);
+            }
+            else {
+                finish();
+            }
+            return result;
+        }
+        catch (error) {
+            finish();
+            throw error;
+        }
+    }
+    /**
+     * Prepares validated local job data for insertion.
+     * @param {{args: Array<ReturnType<typeof JSON.parse>>, jobName: string, options: import("./types.js").BackgroundJobOptions}} args - Job request.
+     * @returns {import("./types.js").PreparedLocalBackgroundJob} - Prepared row data.
+     */
+    _prepareJob({ args, jobName, options }) {
+        if (options.idempotencyKey !== undefined) {
+            throw new Error("idempotencyKey is not supported by the local background-jobs adapter");
+        }
+        const createdAtMs = this.clock.now();
+        const queue = normalizeBackgroundJobQueue(options);
+        const queues = this.configuration.getBackgroundJobsConfig().queues;
+        const argsJson = JSON.stringify(args || []);
+        const executionMode = normalizeBackgroundJobExecutionMode(options, "inline", LOCAL_EXECUTION_MODES);
+        if (typeof argsJson !== "string")
+            throw new TypeError("Local background job arguments must be JSON serializable");
+        if (executionMode !== "inline")
+            throw new Error("Local background job execution mode invariant was violated");
+        return {
+            argsDigest: sha256Hex(argsJson),
+            argsJson,
+            concurrency: normalizeBackgroundJobConcurrency({ options, queue, queues }),
+            createdAtMs,
+            executionMode,
+            jobId: new UUID(4).format(),
+            jobName,
+            maxRetries: normalizeBackgroundJobMaxRetries(options.maxRetries),
+            queue,
+            scheduledAtMs: normalizeBackgroundJobScheduledAtMs(options.scheduledAtMs, createdAtMs)
+        };
+    }
+    /**
+     * Inserts one prepared local job row and its concurrency metadata.
+     * @param {import("../database/drivers/base.js").default} db - Local SQLite connection.
+     * @param {import("./types.js").PreparedLocalBackgroundJob} preparedJob - Prepared row data.
+     * @returns {Promise<void>} - Resolves after insertion.
+     */
+    async _insertPreparedJob(db, preparedJob) {
+        await db.insert({
+            tableName: LOCAL_BACKGROUND_JOBS_TABLE,
+            data: {
+                args_digest: preparedJob.argsDigest,
+                args_json: preparedJob.argsJson,
+                attempts: 0,
+                completed_at_ms: null,
+                concurrency_key: preparedJob.concurrency?.concurrencyKey || null,
+                created_at_ms: preparedJob.createdAtMs,
+                execution_mode: preparedJob.executionMode,
+                failed_at_ms: null,
+                handed_off_at_ms: null,
+                handoff_id: null,
+                id: preparedJob.jobId,
+                job_name: preparedJob.jobName,
+                last_error: null,
+                max_concurrency: preparedJob.concurrency?.maxConcurrency || null,
+                max_retries: preparedJob.maxRetries,
+                queue: preparedJob.queue,
+                scheduled_at_ms: preparedJob.scheduledAtMs,
+                status: "queued",
+                worker_id: null
+            }
+        });
+    }
+    /**
+     * Reconciles configured queue-derived caps and durable counters.
+     * @returns {Promise<void>} - Resolves after reconciliation.
+     */
+    async reconcileQueueConcurrency() {
+        await this.ensureReady();
+        await this._withDb(async (connection) => await this._mutate(connection, async (db) => {
+            const queues = this.configuration.getBackgroundJobsConfig().queues;
+            const rows = await db.newQuery().from(LOCAL_BACKGROUND_JOBS_TABLE).where({ status: "queued" }).results();
+            for (const rawRow of rows) {
+                await this._reconcileQueuedJobConcurrency(db, this._normalizeRow(rawRow), queues);
+            }
+            await this._rebuildConcurrencyCounts(db);
+        }));
+    }
+    /**
+     * Applies current queue-derived concurrency policy to one queued row.
+     * Explicit concurrency keys remain owned by the enqueue contract.
+     * @param {import("../database/drivers/base.js").default} db - Local SQLite connection.
+     * @param {import("./types.js").BackgroundJobRow} job - Queued job snapshot.
+     * @param {Record<string, {maxConcurrent?: number, priority?: number}>} queues - Current queue policy snapshot.
+     * @returns {Promise<import("./types.js").BackgroundJobRow>} - Reconciled snapshot.
+     */
+    async _reconcileQueuedJobConcurrency(db, job, queues) {
+        const currentIsQueueDerived = Boolean(job.concurrencyKey?.startsWith(QUEUE_CONCURRENCY_KEY_PREFIX));
+        if (job.concurrencyKey && !currentIsQueueDerived)
+            return job;
+        const concurrency = normalizeBackgroundJobConcurrency({
+            options: {},
+            queue: job.queue,
+            queues
+        });
+        if (!concurrency) {
+            if (currentIsQueueDerived) {
+                await db.update({
+                    conditions: { id: job.id, status: "queued" },
+                    data: { concurrency_key: null, max_concurrency: null },
+                    tableName: LOCAL_BACKGROUND_JOBS_TABLE
+                });
+            }
+            return { ...job, concurrencyKey: null, maxConcurrency: null };
+        }
+        await this._ensureConcurrency(db, concurrency);
+        if (job.concurrencyKey !== concurrency.concurrencyKey || job.maxConcurrency !== concurrency.maxConcurrency) {
+            await db.update({
+                conditions: { id: job.id, status: "queued" },
+                data: { concurrency_key: concurrency.concurrencyKey, max_concurrency: concurrency.maxConcurrency },
+                tableName: LOCAL_BACKGROUND_JOBS_TABLE
+            });
+        }
+        return { ...job, concurrencyKey: concurrency.concurrencyKey, maxConcurrency: concurrency.maxConcurrency };
+    }
+    /**
+     * Finds the next eligible local job.
+     * @returns {Promise<import("./types.js").BackgroundJobRow | null>} - Next eligible local job.
+     */
+    async nextAvailableJob() {
+        await this.ensureReady();
+        return await this._withDb(async (db) => {
+            const jobsTable = db.quoteTable(LOCAL_BACKGROUND_JOBS_TABLE);
+            const concurrencyTable = db.quoteTable(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE);
+            const priorityOrder = this._queuePriorityOrderSql(db);
+            let query = db
+                .newQuery()
+                .from(LOCAL_BACKGROUND_JOBS_TABLE)
+                .where({ status: "queued" })
+                .where(`scheduled_at_ms <= ${db.quote(this.clock.now())}`)
+                .where(`(${jobsTable}.${db.quoteColumn("concurrency_key")} IS NULL OR EXISTS (` +
+                `SELECT 1 FROM ${concurrencyTable} WHERE ` +
+                `${concurrencyTable}.${db.quoteColumn("concurrency_key")} = ${jobsTable}.${db.quoteColumn("concurrency_key")} AND ` +
+                `${concurrencyTable}.${db.quoteColumn("active_count")} < ${concurrencyTable}.${db.quoteColumn("max_concurrency")}))`);
+            if (priorityOrder)
+                query = query.order(`${priorityOrder} DESC`);
+            const rows = await query
+                .order("scheduled_at_ms ASC")
+                .order("created_at_ms ASC")
+                .order("id ASC")
+                .limit(1)
+                .results();
+            return rows[0] ? this._normalizeRow(rows[0]) : null;
+        });
+    }
+    /**
+     * Finds the soonest future queued job.
+     * @returns {Promise<import("./types.js").BackgroundJobRow | null>} - Soonest future queued job.
+     */
+    async nextScheduledJob() {
+        await this.ensureReady();
+        return await this._withDb(async (db) => {
+            const rows = await db
+                .newQuery()
+                .from(LOCAL_BACKGROUND_JOBS_TABLE)
+                .where({ status: "queued" })
+                .where(`scheduled_at_ms > ${db.quote(this.clock.now())}`)
+                .order("scheduled_at_ms ASC")
+                .order("created_at_ms ASC")
+                .order("id ASC")
+                .limit(1)
+                .results();
+            return rows[0] ? this._normalizeRow(rows[0]) : null;
+        });
+    }
+    /**
+     * Finds a persisted local job by id.
+     * @param {string} jobId - Job id.
+     * @returns {Promise<import("./types.js").BackgroundJobRow | null>} - Persisted job.
+     */
+    async getJob(jobId) {
+        await this.ensureReady();
+        return await this._withDb(async (db) => await this._getJob(db, jobId));
+    }
+    /**
+     * Lists local jobs in creation order.
+     * @returns {Promise<import("./types.js").BackgroundJobRow[]>} - All local jobs in creation order.
+     */
+    async listJobs() {
+        await this.ensureReady();
+        return await this._withDb(async (db) => {
+            const rows = await db
+                .newQuery()
+                .from(LOCAL_BACKGROUND_JOBS_TABLE)
+                .order("created_at_ms ASC")
+                .order("id ASC")
+                .results();
+            return rows.map((row) => this._normalizeRow(row));
+        });
+    }
+    /**
+     * Atomically reserves concurrency and claims one queued job.
+     * @param {{jobId: string, workerId?: string}} args - Claim request.
+     * @returns {Promise<import("./types.js").BackgroundJobHandoff | null>} - Fenced claim.
+     */
+    async markHandedOff({ jobId, workerId }) {
+        await this.ensureReady();
+        return await this._withDb(async (connection) => await this._mutate(connection, async (db) => {
+            const job = await this._getJob(db, jobId);
+            if (!job || job.status !== "queued" || Number(job.scheduledAtMs) > this.clock.now())
+                return null;
+            if (job.concurrencyKey && !(await this._reserveConcurrency(db, job.concurrencyKey)))
+                return null;
+            const handedOffAtMs = this.clock.now();
+            const handoffId = new UUID(4).format();
+            const affectedRows = await this._updateAffectedRows(db, {
+                conditions: { id: jobId, status: "queued" },
+                data: { handed_off_at_ms: handedOffAtMs, handoff_id: handoffId, status: "handed_off", worker_id: workerId || "local" },
+                tableName: LOCAL_BACKGROUND_JOBS_TABLE
+            });
+            if (affectedRows !== 1) {
+                await this._releaseConcurrency(db, job.concurrencyKey);
+                return null;
+            }
+            return { handedOffAtMs, handoffId };
+        }));
+    }
+    /**
+     * Finds active local handoffs owned by one worker.
+     * @param {{workerId: string}} args - Worker identity.
+     * @returns {Promise<Array<{jobId: string, handoffId: string}>>} - Active worker handoffs.
+     */
+    async handedOffJobsForWorker({ workerId }) {
+        await this.ensureReady();
+        const rows = await this._withDb(async (db) => await db
+            .newQuery()
+            .from(LOCAL_BACKGROUND_JOBS_TABLE)
+            .where({ status: "handed_off", worker_id: workerId })
+            .results());
+        /** @type {Array<{jobId: string, handoffId: string}>} */
+        const handoffs = [];
+        for (const rawRow of rows) {
+            const job = this._normalizeRow(rawRow);
+            if (job.handoffId)
+                handoffs.push({ jobId: job.id, handoffId: job.handoffId });
+        }
+        return handoffs;
+    }
+    /**
+     * Returns an exact active handoff to the queue.
+     * @param {{jobId: string, handoffId: string}} args - Handoff release.
+     * @returns {Promise<void>} - Resolves after the fenced release.
+     */
+    async markReturnedToQueue({ jobId, handoffId }) {
+        await this.ensureReady();
+        await this._withDb(async (connection) => await this._mutate(connection, async (db) => {
+            const job = await this._getJob(db, jobId);
+            if (!this._acceptsHandoff(job, handoffId))
+                return;
+            await this._lockConcurrencyRow(db, job.concurrencyKey);
+            const affectedRows = await this._updateAffectedRows(db, {
+                conditions: { handoff_id: handoffId, id: jobId, status: "handed_off" },
+                data: {
+                    handed_off_at_ms: null,
+                    handoff_id: null,
+                    scheduled_at_ms: this.clock.now(),
+                    status: "queued",
+                    worker_id: null
+                },
+                tableName: LOCAL_BACKGROUND_JOBS_TABLE
+            });
+            if (affectedRows === 1)
+                await this._releaseConcurrency(db, job.concurrencyKey);
+        }));
+    }
+    /**
+     * Applies a fenced successful acknowledgement.
+     * @param {{jobId: string, handoffId?: string}} args - Completion report.
+     * @returns {Promise<boolean>} - Whether the lease won.
+     */
+    async markCompleted({ jobId, handoffId }) {
+        await this.ensureReady();
+        return await this._withDb(async (connection) => await this._mutate(connection, async (db) => {
+            const job = await this._getJob(db, jobId);
+            if (!this._acceptsHandoff(job, handoffId))
+                return false;
+            await this._lockConcurrencyRow(db, job.concurrencyKey);
+            const affectedRows = await this._updateAffectedRows(db, {
+                conditions: { handoff_id: handoffId, id: jobId, status: "handed_off" },
+                data: { completed_at_ms: this.clock.now(), status: "completed" },
+                tableName: LOCAL_BACKGROUND_JOBS_TABLE
+            });
+            if (affectedRows !== 1)
+                return false;
+            await this._releaseConcurrency(db, job.concurrencyKey);
+            return true;
+        }));
+    }
+    /**
+     * Applies a fenced reschedule without consuming an attempt.
+     * @param {{jobId: string, handoffId?: string, delayMs: number}} args - Reschedule report.
+     * @returns {Promise<boolean>} - Whether the lease won.
+     */
+    async markRescheduled({ jobId, handoffId, delayMs }) {
+        await this.ensureReady();
+        return await this._withDb(async (connection) => await this._mutate(connection, async (db) => {
+            const job = await this._getJob(db, jobId);
+            if (!this._acceptsHandoff(job, handoffId))
+                return false;
+            await this._lockConcurrencyRow(db, job.concurrencyKey);
+            const affectedRows = await this._updateAffectedRows(db, {
+                conditions: { handoff_id: handoffId, id: jobId, status: "handed_off" },
+                data: {
+                    handed_off_at_ms: null,
+                    handoff_id: null,
+                    scheduled_at_ms: rescheduledBackgroundJobAtMs(delayMs, this.clock.now()),
+                    status: "queued",
+                    worker_id: null
+                },
+                tableName: LOCAL_BACKGROUND_JOBS_TABLE
+            });
+            if (affectedRows !== 1)
+                return false;
+            await this._releaseConcurrency(db, job.concurrencyKey);
+            return true;
+        }));
+    }
+    /**
+     * Applies a fenced failure, retry, or terminal transition.
+     * @param {{jobId: string, handoffId?: string, error: ReturnType<typeof JSON.parse>}} args - Failure report.
+     * @returns {Promise<import("./types.js").BackgroundJobRow | null>} - Accepted transition snapshot.
+     */
+    async markFailed({ jobId, handoffId, error }) {
+        await this.ensureReady();
+        return await this._withDb(async (connection) => await this._mutate(connection, async (db) => {
+            const job = await this._getJob(db, jobId);
+            if (!this._acceptsHandoff(job, handoffId))
+                return null;
+            return await this._applyFailure(db, job, error);
+        }));
+    }
+    /**
+     * Turns every abandoned local handoff into the normal failure/retry path.
+     * @returns {Promise<import("./types.js").BackgroundJobRow[]>} - Recovered transitions.
+     */
+    async recoverHandedOffJobs() {
+        await this.ensureReady();
+        return await this._withDb(async (connection) => await this._mutate(connection, async (db) => {
+            const queues = this.configuration.getBackgroundJobsConfig().queues;
+            const rows = await db.newQuery().from(LOCAL_BACKGROUND_JOBS_TABLE).where({ status: "handed_off" }).results();
+            /** @type {import("./types.js").BackgroundJobRow[]} */
+            const recovered = [];
+            for (const rawRow of rows) {
+                const job = this._normalizeRow(rawRow);
+                const updated = await this._applyFailure(db, job, new Error("Local background job recovered after an interrupted dispatcher"));
+                if (!updated)
+                    continue;
+                const reconciled = updated.status === "queued"
+                    ? await this._reconcileQueuedJobConcurrency(db, updated, queues)
+                    : updated;
+                recovered.push(reconciled);
+            }
+            await this._rebuildConcurrencyCounts(db);
+            return recovered;
+        }));
+    }
+    /**
+     * Deletes local queue state for focused tests.
+     * @returns {Promise<void>} - Resolves after deletion.
+     */
+    async clearAll() {
+        await this.ensureReady();
+        await this._withDb(async (connection) => await this._mutate(connection, async (db) => {
+            await db.query(`DELETE FROM ${db.quoteTable(LOCAL_BACKGROUND_JOBS_TABLE)}`);
+            await db.query(`DELETE FROM ${db.quoteTable(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE)}`);
+        }));
+    }
+    /**
+     * Applies the common retry or exhausted failure transition.
+     * @param {import("../database/drivers/base.js").default} db - Local SQLite connection.
+     * @param {import("./types.js").BackgroundJobRow} job - Active handoff.
+     * @param {ReturnType<typeof JSON.parse>} error - Performance error.
+     * @returns {Promise<import("./types.js").BackgroundJobRow | null>} - Transition snapshot.
+     */
+    async _applyFailure(db, job, error) {
+        const attempts = (job.attempts || 0) + 1;
+        const maxRetries = normalizeBackgroundJobMaxRetries(job.maxRetries);
+        const willRetry = attempts <= maxRetries;
+        const nowMs = this.clock.now();
+        /** @type {Record<string, ReturnType<typeof JSON.parse>>} */
+        const data = {
+            attempts,
+            handed_off_at_ms: null,
+            handoff_id: null,
+            last_error: normalizeBackgroundJobError(error),
+            status: willRetry ? "queued" : "failed",
+            worker_id: null
+        };
+        if (willRetry) {
+            Object.assign(data, { scheduled_at_ms: nowMs + retryDelayMs(attempts) });
+        }
+        else {
+            Object.assign(data, { failed_at_ms: nowMs });
+        }
+        await this._lockConcurrencyRow(db, job.concurrencyKey);
+        const affectedRows = await this._updateAffectedRows(db, {
+            conditions: { handoff_id: job.handoffId, id: job.id, status: "handed_off" },
+            data,
+            tableName: LOCAL_BACKGROUND_JOBS_TABLE
+        });
+        if (affectedRows !== 1)
+            return null;
+        await this._releaseConcurrency(db, job.concurrencyKey);
+        return {
+            ...job,
+            attempts,
+            failedAtMs: willRetry ? job.failedAtMs : nowMs,
+            handedOffAtMs: null,
+            handoffId: null,
+            lastError: data.last_error,
+            scheduledAtMs: willRetry ? Number(data.scheduled_at_ms) : job.scheduledAtMs,
+            status: data.status,
+            workerId: null
+        };
+    }
+    /**
+     * Ensures that a durable concurrency counter exists with the required cap.
+     * @param {import("../database/drivers/base.js").default} db - Local SQLite connection.
+     * @param {import("./types.js").ResolvedBackgroundJobConcurrency} concurrency - Desired counter.
+     * @returns {Promise<void>} - Resolves when ensured.
+     */
+    async _ensureConcurrency(db, concurrency) {
+        await db.upsert({
+            conflictColumns: ["concurrency_key"],
+            data: { active_count: 0, concurrency_key: concurrency.concurrencyKey, max_concurrency: concurrency.maxConcurrency },
+            tableName: LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE,
+            updateColumns: ["concurrency_key"]
+        });
+        const rows = await db
+            .newQuery()
+            .from(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE)
+            .where({ concurrency_key: concurrency.concurrencyKey })
+            .limit(1)
+            .results();
+        const existingRow = /** @type {{max_concurrency: number | string}} */ (rows[0]);
+        const existingCap = Number(existingRow.max_concurrency);
+        if (existingCap === concurrency.maxConcurrency)
+            return;
+        if (!concurrency.queueDerived)
+            throw new Error(`Conflicting maxConcurrency for background job concurrencyKey: ${concurrency.concurrencyKey}`);
+        await db.update({
+            conditions: { concurrency_key: concurrency.concurrencyKey },
+            data: { max_concurrency: concurrency.maxConcurrency },
+            tableName: LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE
+        });
+    }
+    /**
+     * Atomically reserves one slot for a concurrency key.
+     * @param {import("../database/drivers/base.js").default} db - Connection.
+     * @param {string} concurrencyKey - Concurrency key.
+     * @returns {Promise<boolean>} - Whether a slot was reserved.
+     */
+    async _reserveConcurrency(db, concurrencyKey) {
+        const table = db.quoteTable(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE);
+        const count = db.quoteColumn("active_count");
+        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")}`);
+        return affectedRows === 1;
+    }
+    /**
+     * Releases one slot for a concurrency key.
+     * @param {import("../database/drivers/base.js").default} db - Connection.
+     * @param {string | null} concurrencyKey - Concurrency key.
+     * @returns {Promise<void>} - Resolves after release.
+     */
+    async _releaseConcurrency(db, concurrencyKey) {
+        if (!concurrencyKey)
+            return;
+        const table = db.quoteTable(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE);
+        const count = db.quoteColumn("active_count");
+        await db.affectedRows(`UPDATE ${table} SET ${count} = ${count} - 1 ` +
+            `WHERE ${db.quoteColumn("concurrency_key")} = ${db.quote(concurrencyKey)} AND ${count} > 0`);
+    }
+    /**
+     * Acquires the transaction's write lock for a concurrency counter row.
+     * @param {import("../database/drivers/base.js").default} db - Connection.
+     * @param {string | null} concurrencyKey - Concurrency key.
+     * @returns {Promise<void>} - Resolves after locking.
+     */
+    async _lockConcurrencyRow(db, concurrencyKey) {
+        if (!concurrencyKey)
+            return;
+        const table = db.quoteTable(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE);
+        const count = db.quoteColumn("active_count");
+        await db.query(`UPDATE ${table} SET ${count} = ${count} ` +
+            `WHERE ${db.quoteColumn("concurrency_key")} = ${db.quote(concurrencyKey)}`);
+    }
+    /**
+     * Rebuilds active counters from durable handed-off jobs.
+     * @param {import("../database/drivers/base.js").default} db - Connection.
+     * @returns {Promise<void>} - Resolves after counter rebuild.
+     */
+    async _rebuildConcurrencyCounts(db) {
+        const concurrencyTable = db.quoteTable(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE);
+        const jobsTable = db.quoteTable(LOCAL_BACKGROUND_JOBS_TABLE);
+        await db.query(`UPDATE ${concurrencyTable} SET ${db.quoteColumn("active_count")} = (` +
+            `SELECT COUNT(*) FROM ${jobsTable} WHERE ${jobsTable}.${db.quoteColumn("status")} = ${db.quote("handed_off")} AND ` +
+            `${jobsTable}.${db.quoteColumn("concurrency_key")} = ${concurrencyTable}.${db.quoteColumn("concurrency_key")})`);
+    }
+    /**
+     * Builds the configured queue-priority ordering expression.
+     * @param {import("../database/drivers/base.js").default} db - Connection.
+     * @returns {string | null} - Queue priority expression.
+     */
+    _queuePriorityOrderSql(db) {
+        const queues = this.configuration.getBackgroundJobsConfig().queues;
+        const prioritized = Object.entries(queues)
+            .filter(([, queue]) => Number.isFinite(queue?.priority) && Number(queue.priority) !== 0)
+            .map(([queueName, queue]) => [queueName, Number(queue.priority)]);
+        if (prioritized.length === 0)
+            return null;
+        const whens = prioritized
+            .map(([queue, priority]) => `WHEN ${db.quote(queue)} THEN ${priority}`)
+            .join(" ");
+        return `CASE COALESCE(${db.quoteColumn("queue")}, ${db.quote(DEFAULT_BACKGROUND_JOB_QUEUE)}) ${whens} ELSE 0 END`;
+    }
+    /**
+     * Checks whether a persisted handoff owns the supplied acknowledgement fence.
+     * @param {import("./types.js").BackgroundJobRow | null} job - Persisted job.
+     * @param {string | undefined} handoffId - Handoff fence.
+     * @returns {job is import("./types.js").BackgroundJobRow} - Whether accepted.
+     */
+    _acceptsHandoff(job, handoffId) {
+        return Boolean(job && job.status === "handed_off" && job.handoffId && job.handoffId === handoffId);
+    }
+    /**
+     * Finds a persisted local job using the current connection.
+     * @param {import("../database/drivers/base.js").default} db - Connection.
+     * @param {string} jobId - Job id.
+     * @returns {Promise<import("./types.js").BackgroundJobRow | null>} - Persisted row.
+     */
+    async _getJob(db, jobId) {
+        const rows = await db.newQuery().from(LOCAL_BACKGROUND_JOBS_TABLE).where({ id: jobId }).limit(1).results();
+        return rows[0] ? this._normalizeRow(rows[0]) : null;
+    }
+    /**
+     * Normalizes one raw local database row.
+     * @param {Record<string, ReturnType<typeof JSON.parse>>} row - Raw row.
+     * @returns {import("./types.js").BackgroundJobRow} - Normalized row.
+     */
+    _normalizeRow(row) {
+        const parsedArgs = JSON.parse(String(row.args_json));
+        const executionMode = normalizeBackgroundJobExecutionMode({ executionMode: String(row.execution_mode) }, "inline", LOCAL_EXECUTION_MODES);
+        if (!Array.isArray(parsedArgs))
+            throw new Error(`Invalid local background job args_json for job: ${String(row.id)}`);
+        if (executionMode !== "inline")
+            throw new Error("Local background job execution mode invariant was violated");
+        return {
+            args: parsedArgs,
+            attempts: this._numberOrNull(row.attempts),
+            completedAtMs: this._numberOrNull(row.completed_at_ms),
+            concurrencyKey: row.concurrency_key === null || row.concurrency_key === undefined ? null : String(row.concurrency_key),
+            createdAtMs: this._numberOrNull(row.created_at_ms),
+            executionMode,
+            failedAtMs: this._numberOrNull(row.failed_at_ms),
+            handedOffAtMs: this._numberOrNull(row.handed_off_at_ms),
+            handoffId: row.handoff_id === null || row.handoff_id === undefined ? null : String(row.handoff_id),
+            id: String(row.id),
+            jobName: String(row.job_name),
+            lastError: row.last_error === null || row.last_error === undefined ? null : String(row.last_error),
+            maxConcurrency: this._numberOrNull(row.max_concurrency),
+            maxRetries: this._numberOrNull(row.max_retries),
+            orphanedAtMs: null,
+            queue: row.queue ? String(row.queue) : DEFAULT_BACKGROUND_JOB_QUEUE,
+            scheduleKey: null,
+            scheduledAtMs: this._numberOrNull(row.scheduled_at_ms),
+            status: row.status ? String(row.status) : "queued",
+            workerId: row.worker_id === null || row.worker_id === undefined ? null : String(row.worker_id)
+        };
+    }
+    /**
+     * Normalizes one nullable database number.
+     * @param {ReturnType<typeof JSON.parse>} value - Database number.
+     * @returns {number | null} - Normalized number.
+     */
+    _numberOrNull(value) {
+        if (value === null || value === undefined || value === "")
+            return null;
+        const number = Number(value);
+        return Number.isNaN(number) ? null : number;
+    }
+    /**
+     * Executes a structured update and reports its affected-row count.
+     * @param {import("../database/drivers/base.js").default} db - Connection.
+     * @param {import("../database/drivers/base.js").UpdateSqlArgsType} args - Update arguments.
+     * @returns {Promise<number>} - Affected rows.
+     */
+    async _updateAffectedRows(db, args) { return await db.affectedRows(db.updateSql(args)); }
+    /**
+     * Joins an ambient app transaction or uses the database's scoped operation lease.
+     * @template T
+     * @param {import("../database/drivers/base.js").default} db - Connection.
+     * @param {(db: import("../database/drivers/base.js").default) => Promise<T>} callback - Mutation.
+     * @returns {Promise<T>} - Mutation result.
+     */
+    async _mutate(db, callback) {
+        if (db.insideTransaction())
+            return await this._transactionResult(db, async () => await callback(db));
+        return await this.configuration.withTransaction({
+            databaseIdentifier: this.getDatabaseIdentifier(),
+            name: "Local background jobs mutation"
+        }, async (operation) => await callback(operation.connection()));
+    }
+    /**
+     * Runs a callback in a transaction and returns its captured result.
+     * @template T
+     * @param {import("../database/drivers/base.js").default} db - Connection.
+     * @param {() => Promise<T>} callback - Transaction callback.
+     * @returns {Promise<T>} - Callback result.
+     */
+    async _transactionResult(db, callback) {
+        let completed = false;
+        /** @type {T | undefined} */
+        let result;
+        await db.transaction(async () => {
+            result = await callback();
+            completed = true;
+        });
+        if (!completed)
+            throw new Error("Local background jobs transaction callback was not invoked");
+        return /** @type {T} */ (result);
+    }
+    /**
+     * Runs a callback with the configured local database connection.
+     * @template T
+     * @param {(db: import("../database/drivers/base.js").default) => Promise<T>} callback - Connection callback.
+     * @returns {Promise<T>} - Callback result.
+     */
+    async _withDb(callback) {
+        const databaseIdentifier = this.getDatabaseIdentifier();
+        return await this.configuration.ensureConnections({ databaseIdentifiers: [databaseIdentifier], name: "Local background jobs store" }, async (dbs) => {
+            const db = dbs[databaseIdentifier];
+            if (!db)
+                throw new Error(`No local background-jobs database connection available for identifier: ${databaseIdentifier}`);
+            return await callback(db);
+        });
+    }
+    /**
+     * Reports an unexpected local-store failure through framework channels.
+     * @param {{error: Error, stage: string}} args - Error report.
+     * @returns {void} - No return value.
+     */
+    _reportFrameworkError({ error, stage }) {
+        const payload = { context: { stage }, error };
+        const errorEvents = this.configuration.getErrorEvents();
+        errorEvents.emit("framework-error", payload);
+        errorEvents.emit("all-error", { ...payload, errorType: "framework-error" });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"local-store.js","sourceRoot":"","sources":["../../../src/background-jobs/local-store.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport UUID from \"pure-uuid\"\n\nimport TableData from \"../database/table-data/index.js\"\nimport TableIndex from \"../database/table-data/table-index.js\"\nimport sha256Hex from \"../utils/sha256-hex.js\"\nimport normalizeBackgroundJobError from \"./normalize-error.js\"\nimport {\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\"\n\nexport const LOCAL_BACKGROUND_JOBS_TABLE = \"velocious_local_background_jobs\"\nexport const LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE = \"velocious_local_background_job_concurrency\"\nconst MIGRATIONS_TABLE = \"velocious_internal_migrations\"\nconst MIGRATION_SCOPE = \"local_background_jobs\"\nconst MIGRATION_VERSION = \"1\"\nconst LOCAL_EXECUTION_MODES = [/** @type {const} */ (\"inline\")]\nexport const LOCAL_BACKGROUND_JOBS_INDEX_NAMES = [\n  \"index_velocious_local_background_jobs_due\",\n  \"index_velocious_local_background_jobs_queue_status\",\n  \"index_velocious_local_background_jobs_deduplication\",\n  \"index_velocious_local_background_jobs_concurrency\"\n]\nconst EXPECTED_JOB_COLUMNS = [\n  \"id\",\n  \"job_name\",\n  \"args_json\",\n  \"args_digest\",\n  \"execution_mode\",\n  \"queue\",\n  \"max_retries\",\n  \"attempts\",\n  \"status\",\n  \"scheduled_at_ms\",\n  \"created_at_ms\",\n  \"handed_off_at_ms\",\n  \"handoff_id\",\n  \"worker_id\",\n  \"completed_at_ms\",\n  \"failed_at_ms\",\n  \"last_error\",\n  \"concurrency_key\",\n  \"max_concurrency\"\n]\nconst EXPECTED_CONCURRENCY_COLUMNS = [\"concurrency_key\", \"max_concurrency\", \"active_count\"]\n/** @type {WeakMap<import(\"../configuration.js\").default, Map<string, Promise<void>>>} */\nconst deduplicatedEnqueueChains = new WeakMap()\n\n/**\n * Creates the production clock used by local dispatch.\n * @returns {import(\"./types.js\").LocalBackgroundJobsClock} - Production clock.\n */\nexport function localBackgroundJobsClock() {\n  return {\n    clearTimeout: (timerId) => globalThis.clearTimeout(timerId),\n    now: () => Date.now(),\n    setTimeout: (callback, delayMs) => globalThis.setTimeout(callback, delayMs)\n  }\n}\n\n/** Namespaced portable SQLite persistence for local background jobs. */\nexport default class LocalBackgroundJobsStore {\n  /**\n   * Creates a store for one configuration and local database.\n   * @param {object} args - Store options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Owning configuration.\n   * @param {import(\"./types.js\").LocalBackgroundJobsClock} [args.clock] - Persistence clock.\n   * @param {string} [args.databaseIdentifier] - Configured local database identifier.\n   * @param {() => void} [args.onCommittedEnqueue] - Commit-aware dispatcher wake.\n   */\n  constructor({configuration, clock = localBackgroundJobsClock(), databaseIdentifier, onCommittedEnqueue}) {\n    this.clock = clock\n    this.configuration = configuration\n    this.databaseIdentifier = databaseIdentifier\n    this.onCommittedEnqueue = onCommittedEnqueue\n    this._isReady = false\n    /** @type {Promise<void> | null} */\n    this._readyPromise = null\n    /** @type {WeakMap<import(\"../database/drivers/base.js\").default, {completion: Promise<void>, promise: Promise<void>}>} */\n    this._transactionReadyPromises = new WeakMap()\n  }\n\n  /**\n   * Resolves the configured local database identifier.\n   * @returns {string} - Database identifier.\n   */\n  getDatabaseIdentifier() {\n    return this.databaseIdentifier || this.configuration.getBackgroundJobsConfig().databaseIdentifier\n  }\n\n  /**\n   * Ensures the versioned physical schema exists.\n   * @returns {Promise<void>} - Resolves when ready.\n   */\n  async ensureReady() {\n    if (this._isReady) return\n\n    await this._withDb(async (db) => await this._ensureReadyWithDb(db))\n  }\n\n  /**\n   * Clears the per-instance readiness latch for a deliberate adapter reopen.\n   * @returns {void} - No return value.\n   */\n  resetReadiness() {\n    this._isReady = false\n    this._readyPromise = null\n    this._transactionReadyPromises = new WeakMap()\n  }\n\n  /**\n   * Coordinates physical and transaction-local schema readiness.\n   * @param {import(\"../database/drivers/base.js\").default} db - Local SQLite connection.\n   * @returns {Promise<void>} - Resolves when this caller can use the schema.\n   */\n  async _ensureReadyWithDb(db) {\n    if (this._isReady) return\n\n    const transactionCompletion = db.insideTransaction() ? db.transactionCompletion() : null\n    const transactionReady = this._transactionReadyPromises.get(db)\n\n    if (transactionCompletion && transactionReady?.completion === transactionCompletion) {\n      await transactionReady.promise\n      return\n    }\n\n    if (this._readyPromise) {\n      const readyPromise = this._readyPromise\n\n      await readyPromise\n      if (this._readyPromise === readyPromise) this._readyPromise = null\n      if (this._isReady) return\n\n      await this.ensureReady()\n      return\n    }\n\n    if (transactionCompletion) {\n      const schemaReadyPromise = this._applySchema(db)\n      const transactionReadyPromise = schemaReadyPromise.then(() => undefined)\n      const transactionReady = {completion: transactionCompletion, promise: transactionReadyPromise}\n      const durableReadyPromise = schemaReadyPromise.then(async (changed) => {\n        if (!changed) {\n          this._isReady = true\n          return\n        }\n\n        await transactionCompletion\n      }, () => {\n        // The transaction-local caller below owns and rethrows this same schema error.\n        // This branch only settles the shared durability barrier so it cannot become\n        // an independent unhandled rejection while failed ownership is cleared.\n      })\n\n      this._transactionReadyPromises.set(db, transactionReady)\n      this._readyPromise = durableReadyPromise\n\n      try {\n        await transactionReadyPromise\n      } catch (error) {\n        if (this._transactionReadyPromises.get(db) === transactionReady) this._transactionReadyPromises.delete(db)\n        if (this._readyPromise === durableReadyPromise) this._readyPromise = null\n        throw error\n      }\n      return\n    }\n\n    this._readyPromise = this._transactionResult(db, async () => await this._applySchema(db)).then(() => {\n      this._isReady = true\n    })\n\n    try {\n      await this._readyPromise\n    } finally {\n      if (!this._isReady) this._readyPromise = null\n    }\n  }\n\n  /**\n   * Creates or repairs version-one tables and indexes.\n   * @param {import(\"../database/drivers/base.js\").default} db - Local SQLite connection.\n   * @returns {Promise<boolean>} - Whether schema state changed.\n   */\n  async _applySchema(db) {\n    let changed = false\n\n    if (!(await db.tableExists(MIGRATIONS_TABLE))) {\n      await db.createTable(this._migrationsTableData())\n      changed = true\n    }\n\n    if (!(await db.tableExists(LOCAL_BACKGROUND_JOBS_TABLE))) {\n      await db.createTable(this._jobsTableData())\n      changed = true\n    } else {\n      await this._assertColumns(db, LOCAL_BACKGROUND_JOBS_TABLE, EXPECTED_JOB_COLUMNS)\n    }\n\n    if (!(await db.tableExists(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE))) {\n      await db.createTable(this._concurrencyTableData())\n      changed = true\n    } else {\n      await this._assertColumns(db, LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE, EXPECTED_CONCURRENCY_COLUMNS)\n    }\n\n    if (await this._ensureIndexes(db)) changed = true\n\n    if (!(await this._hasMigration(db))) {\n      await db.upsert({\n        tableName: MIGRATIONS_TABLE,\n        data: {\n          applied_at_ms: this.clock.now(),\n          key: this._migrationKey(),\n          scope: MIGRATION_SCOPE,\n          version: MIGRATION_VERSION\n        },\n        conflictColumns: [\"key\"],\n        updateColumns: [\"scope\", \"version\", \"applied_at_ms\"]\n      })\n      changed = true\n    }\n\n    return changed\n  }\n\n  /**\n   * Builds the migration ledger table definition.\n   * @returns {TableData} - Migration ledger table.\n   */\n  _migrationsTableData() {\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    return table\n  }\n\n  /**\n   * Builds the local jobs table definition.\n   * @returns {TableData} - Local jobs table definition.\n   */\n  _jobsTableData() {\n    const table = new TableData(LOCAL_BACKGROUND_JOBS_TABLE, {ifNotExists: true})\n\n    table.string(\"id\", {null: false, primaryKey: true})\n    table.string(\"job_name\", {null: false})\n    table.text(\"args_json\", {null: false})\n    table.string(\"args_digest\", {maxLength: 64, null: false})\n    table.string(\"execution_mode\", {null: false})\n    table.string(\"queue\", {null: false})\n    table.integer(\"max_retries\", {null: false})\n    table.integer(\"attempts\", {null: false})\n    table.string(\"status\", {null: false})\n    table.bigint(\"scheduled_at_ms\", {null: false})\n    table.bigint(\"created_at_ms\", {null: false})\n    table.bigint(\"handed_off_at_ms\", {null: true})\n    table.string(\"handoff_id\", {null: true})\n    table.string(\"worker_id\", {null: true})\n    table.bigint(\"completed_at_ms\", {null: true})\n    table.bigint(\"failed_at_ms\", {null: true})\n    table.text(\"last_error\", {null: true})\n    table.string(\"concurrency_key\", {null: true})\n    table.integer(\"max_concurrency\", {null: true})\n    table.addIndex(new TableIndex([\"status\", \"scheduled_at_ms\", \"created_at_ms\", \"id\"], {name: LOCAL_BACKGROUND_JOBS_INDEX_NAMES[0]}))\n    table.addIndex(new TableIndex([\"queue\", \"status\", \"created_at_ms\"], {name: LOCAL_BACKGROUND_JOBS_INDEX_NAMES[1]}))\n    table.addIndex(new TableIndex([\"args_digest\"], {name: LOCAL_BACKGROUND_JOBS_INDEX_NAMES[2]}))\n    table.addIndex(new TableIndex([\"status\", \"concurrency_key\", \"scheduled_at_ms\"], {name: LOCAL_BACKGROUND_JOBS_INDEX_NAMES[3]}))\n    return table\n  }\n\n  /**\n   * Builds the local concurrency counter table definition.\n   * @returns {TableData} - Concurrency counter table definition.\n   */\n  _concurrencyTableData() {\n    const table = new TableData(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE, {ifNotExists: true})\n\n    table.string(\"concurrency_key\", {null: false, primaryKey: true})\n    table.integer(\"max_concurrency\", {null: false})\n    table.integer(\"active_count\", {null: false})\n    return table\n  }\n\n  /**\n   * Rejects an incompatible current-version table rather than rebuilding data.\n   * @param {import(\"../database/drivers/base.js\").default} db - Local SQLite connection.\n   * @param {string} tableName - Table name.\n   * @param {string[]} expectedColumns - Required columns.\n   * @returns {Promise<void>} - Resolves when compatible.\n   */\n  async _assertColumns(db, tableName, expectedColumns) {\n    const table = await db.getTableByNameOrFail(tableName)\n    const columns = await table.getColumns()\n    const names = new Set(columns.map((column) => column.getName()))\n    const missing = expectedColumns.filter((columnName) => !names.has(columnName))\n\n    if (missing.length === 0) return\n\n    const error = new Error(`Incompatible local background-jobs schema for ${tableName}; missing columns: ${missing.join(\", \")}`)\n\n    this._reportFrameworkError({error, stage: \"local-background-jobs-schema\"})\n    throw error\n  }\n\n  /**\n   * Recreates missing indexes declared by the current schema.\n   * @param {import(\"../database/drivers/base.js\").default} db - Local SQLite connection.\n   * @returns {Promise<boolean>} - Whether an index was created.\n   */\n  async _ensureIndexes(db) {\n    db.clearSchemaCache()\n    const jobsTable = await db.getTableByNameOrFail(LOCAL_BACKGROUND_JOBS_TABLE)\n    const existingNames = new Set((await jobsTable.getIndexes()).map((index) => index.getName()))\n    let changed = false\n\n    for (const index of this._jobsTableData().getIndexes()) {\n      const indexName = index.getName()\n\n      if (!indexName || existingNames.has(indexName)) continue\n\n      const sqls = await db.createIndexSQLs({\n        columns: index.getColumns(),\n        ifNotExists: true,\n        name: indexName,\n        tableName: LOCAL_BACKGROUND_JOBS_TABLE,\n        unique: index.getUnique()\n      })\n\n      for (const sql of sqls) await db.query(sql)\n      changed = true\n    }\n\n    if (changed) db.clearSchemaCache()\n    return changed\n  }\n\n  /**\n   * Checks whether the current local schema version is recorded.\n   * @param {import(\"../database/drivers/base.js\").default} db - Connection.\n   * @returns {Promise<boolean>} - Whether version one is recorded.\n   */\n  async _hasMigration(db) {\n    const rows = await db\n      .newQuery()\n      .from(MIGRATIONS_TABLE)\n      .where({key: this._migrationKey()})\n      .limit(1)\n      .results()\n\n    return rows.length > 0\n  }\n\n  /**\n   * Builds the scoped migration key.\n   * @returns {string} - Scoped migration key.\n   */\n  _migrationKey() { return `${MIGRATION_SCOPE}:${MIGRATION_VERSION}` }\n\n  /**\n   * Enqueues a local job in the caller's active transaction when present.\n   * @param {object} args - Enqueue request.\n   * @param {string} args.jobName - Registered job name.\n   * @param {Array<ReturnType<typeof JSON.parse>>} args.args - Serialized job arguments.\n   * @param {import(\"./types.js\").BackgroundJobOptions} [args.options] - Job options.\n   * @returns {Promise<string>} - Durable job id.\n   */\n  async enqueue({jobName, args, options = {}}) {\n    await this.ensureReady()\n\n    const preparedJob = this._prepareJob({args, jobName, options})\n    const mutate = async (holdUntil = (/** @type {Promise<void>} */ _completion) => {}) => await this._withDb(async (connection) => {\n      if (connection.insideTransaction()) holdUntil(connection.transactionCompletion())\n\n      return await this._mutate(connection, async (db) => {\n        let jobId = preparedJob.jobId\n\n        if (preparedJob.concurrency) await this._ensureConcurrency(db, preparedJob.concurrency)\n\n        if (options.deduplicateWhileQueued) {\n          const existing = await db\n            .newQuery()\n            .from(LOCAL_BACKGROUND_JOBS_TABLE)\n            .select(\"id\")\n            .where({\n              args_digest: preparedJob.argsDigest,\n              args_json: preparedJob.argsJson,\n              job_name: preparedJob.jobName,\n              queue: preparedJob.queue,\n              status: \"queued\"\n            })\n            .where(`scheduled_at_ms <= ${db.quote(preparedJob.scheduledAtMs)}`)\n            .order(\"scheduled_at_ms ASC\")\n            .order(\"created_at_ms ASC\")\n            .limit(1)\n            .results()\n\n          const existingRow = /** @type {{id: string | number} | undefined} */ (existing[0])\n\n          if (existingRow) jobId = String(existingRow.id)\n        }\n\n        if (jobId === preparedJob.jobId) await this._insertPreparedJob(db, preparedJob)\n        if (this.onCommittedEnqueue) await db.afterCommit(this.onCommittedEnqueue)\n\n        return jobId\n      })\n    })\n\n    if (options.deduplicateWhileQueued) return await this._serializeDeduplicatedEnqueue(preparedJob, mutate)\n    return await mutate()\n  }\n\n  /**\n   * Serializes matching in-process deduplication checks through commit while\n   * leaving unrelated job identities independent.\n   * @template T\n   * @param {import(\"./types.js\").PreparedLocalBackgroundJob} preparedJob - Prepared job identity.\n   * @param {(holdUntil: (completion: Promise<void>) => void) => Promise<T>} callback - Deduplication mutation.\n   * @returns {Promise<T>} - Mutation result.\n   */\n  async _serializeDeduplicatedEnqueue(preparedJob, callback) {\n    let chains = deduplicatedEnqueueChains.get(this.configuration)\n\n    if (!chains) {\n      chains = new Map()\n      deduplicatedEnqueueChains.set(this.configuration, chains)\n    }\n\n    const key = sha256Hex(JSON.stringify([\n      this.getDatabaseIdentifier(),\n      preparedJob.jobName,\n      preparedJob.argsDigest,\n      preparedJob.queue\n    ]))\n    const previous = chains.get(key) || Promise.resolve()\n    let release = () => {}\n    const running = new Promise((resolve) => { release = () => resolve(undefined) })\n    const chain = previous.then(() => running)\n    /** @type {Promise<void> | undefined} */\n    let completion\n    const finish = () => {\n      release()\n      if (chains.get(key) === chain) chains.delete(key)\n      if (chains.size === 0) deduplicatedEnqueueChains.delete(this.configuration)\n    }\n\n    chains.set(key, chain)\n    await previous\n\n    try {\n      const result = await callback((transactionCompletion) => { completion = transactionCompletion })\n\n      if (completion) {\n        completion.then(finish, finish)\n      } else {\n        finish()\n      }\n\n      return result\n    } catch (error) {\n      finish()\n      throw error\n    }\n  }\n\n  /**\n   * Prepares validated local job data for insertion.\n   * @param {{args: Array<ReturnType<typeof JSON.parse>>, jobName: string, options: import(\"./types.js\").BackgroundJobOptions}} args - Job request.\n   * @returns {import(\"./types.js\").PreparedLocalBackgroundJob} - Prepared row data.\n   */\n  _prepareJob({args, jobName, options}) {\n    if (options.idempotencyKey !== undefined) {\n      throw new Error(\"idempotencyKey is not supported by the local background-jobs adapter\")\n    }\n\n    const createdAtMs = this.clock.now()\n    const queue = normalizeBackgroundJobQueue(options)\n    const queues = this.configuration.getBackgroundJobsConfig().queues\n    const argsJson = JSON.stringify(args || [])\n    const executionMode = normalizeBackgroundJobExecutionMode(options, \"inline\", LOCAL_EXECUTION_MODES)\n\n    if (typeof argsJson !== \"string\") throw new TypeError(\"Local background job arguments must be JSON serializable\")\n    if (executionMode !== \"inline\") throw new Error(\"Local background job execution mode invariant was violated\")\n\n    return {\n      argsDigest: sha256Hex(argsJson),\n      argsJson,\n      concurrency: normalizeBackgroundJobConcurrency({options, queue, queues}),\n      createdAtMs,\n      executionMode,\n      jobId: new UUID(4).format(),\n      jobName,\n      maxRetries: normalizeBackgroundJobMaxRetries(options.maxRetries),\n      queue,\n      scheduledAtMs: normalizeBackgroundJobScheduledAtMs(options.scheduledAtMs, createdAtMs)\n    }\n  }\n\n  /**\n   * Inserts one prepared local job row and its concurrency metadata.\n   * @param {import(\"../database/drivers/base.js\").default} db - Local SQLite connection.\n   * @param {import(\"./types.js\").PreparedLocalBackgroundJob} preparedJob - Prepared row data.\n   * @returns {Promise<void>} - Resolves after insertion.\n   */\n  async _insertPreparedJob(db, preparedJob) {\n    await db.insert({\n      tableName: LOCAL_BACKGROUND_JOBS_TABLE,\n      data: {\n        args_digest: preparedJob.argsDigest,\n        args_json: preparedJob.argsJson,\n        attempts: 0,\n        completed_at_ms: null,\n        concurrency_key: preparedJob.concurrency?.concurrencyKey || null,\n        created_at_ms: preparedJob.createdAtMs,\n        execution_mode: preparedJob.executionMode,\n        failed_at_ms: null,\n        handed_off_at_ms: null,\n        handoff_id: null,\n        id: preparedJob.jobId,\n        job_name: preparedJob.jobName,\n        last_error: null,\n        max_concurrency: preparedJob.concurrency?.maxConcurrency || null,\n        max_retries: preparedJob.maxRetries,\n        queue: preparedJob.queue,\n        scheduled_at_ms: preparedJob.scheduledAtMs,\n        status: \"queued\",\n        worker_id: null\n      }\n    })\n  }\n\n  /**\n   * Reconciles configured queue-derived caps and durable counters.\n   * @returns {Promise<void>} - Resolves after reconciliation.\n   */\n  async reconcileQueueConcurrency() {\n    await this.ensureReady()\n\n    await this._withDb(async (connection) => await this._mutate(connection, async (db) => {\n      const queues = this.configuration.getBackgroundJobsConfig().queues\n      const rows = await db.newQuery().from(LOCAL_BACKGROUND_JOBS_TABLE).where({status: \"queued\"}).results()\n\n      for (const rawRow of rows) {\n        await this._reconcileQueuedJobConcurrency(db, this._normalizeRow(rawRow), queues)\n      }\n\n      await this._rebuildConcurrencyCounts(db)\n    }))\n  }\n\n  /**\n   * Applies current queue-derived concurrency policy to one queued row.\n   * Explicit concurrency keys remain owned by the enqueue contract.\n   * @param {import(\"../database/drivers/base.js\").default} db - Local SQLite connection.\n   * @param {import(\"./types.js\").BackgroundJobRow} job - Queued job snapshot.\n   * @param {Record<string, {maxConcurrent?: number, priority?: number}>} queues - Current queue policy snapshot.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow>} - Reconciled snapshot.\n   */\n  async _reconcileQueuedJobConcurrency(db, job, queues) {\n    const currentIsQueueDerived = Boolean(job.concurrencyKey?.startsWith(QUEUE_CONCURRENCY_KEY_PREFIX))\n\n    if (job.concurrencyKey && !currentIsQueueDerived) return job\n\n    const concurrency = normalizeBackgroundJobConcurrency({\n      options: {},\n      queue: job.queue,\n      queues\n    })\n\n    if (!concurrency) {\n      if (currentIsQueueDerived) {\n        await db.update({\n          conditions: {id: job.id, status: \"queued\"},\n          data: {concurrency_key: null, max_concurrency: null},\n          tableName: LOCAL_BACKGROUND_JOBS_TABLE\n        })\n      }\n\n      return {...job, concurrencyKey: null, maxConcurrency: null}\n    }\n\n    await this._ensureConcurrency(db, concurrency)\n    if (job.concurrencyKey !== concurrency.concurrencyKey || job.maxConcurrency !== concurrency.maxConcurrency) {\n      await db.update({\n        conditions: {id: job.id, status: \"queued\"},\n        data: {concurrency_key: concurrency.concurrencyKey, max_concurrency: concurrency.maxConcurrency},\n        tableName: LOCAL_BACKGROUND_JOBS_TABLE\n      })\n    }\n\n    return {...job, concurrencyKey: concurrency.concurrencyKey, maxConcurrency: concurrency.maxConcurrency}\n  }\n\n  /**\n   * Finds the next eligible local job.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Next eligible local job.\n   */\n  async nextAvailableJob() {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      const jobsTable = db.quoteTable(LOCAL_BACKGROUND_JOBS_TABLE)\n      const concurrencyTable = db.quoteTable(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE)\n      const priorityOrder = this._queuePriorityOrderSql(db)\n      let query = db\n        .newQuery()\n        .from(LOCAL_BACKGROUND_JOBS_TABLE)\n        .where({status: \"queued\"})\n        .where(`scheduled_at_ms <= ${db.quote(this.clock.now())}`)\n        .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      if (priorityOrder) query = query.order(`${priorityOrder} DESC`)\n\n      const rows = await query\n        .order(\"scheduled_at_ms ASC\")\n        .order(\"created_at_ms ASC\")\n        .order(\"id ASC\")\n        .limit(1)\n        .results()\n\n      return rows[0] ? this._normalizeRow(rows[0]) : null\n    })\n  }\n\n  /**\n   * Finds the soonest future queued job.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Soonest future queued job.\n   */\n  async nextScheduledJob() {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      const rows = await db\n        .newQuery()\n        .from(LOCAL_BACKGROUND_JOBS_TABLE)\n        .where({status: \"queued\"})\n        .where(`scheduled_at_ms > ${db.quote(this.clock.now())}`)\n        .order(\"scheduled_at_ms ASC\")\n        .order(\"created_at_ms ASC\")\n        .order(\"id ASC\")\n        .limit(1)\n        .results()\n\n      return rows[0] ? this._normalizeRow(rows[0]) : null\n    })\n  }\n\n  /**\n   * Finds a persisted local job by id.\n   * @param {string} jobId - Job id.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Persisted job.\n   */\n  async getJob(jobId) {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => await this._getJob(db, jobId))\n  }\n\n  /**\n   * Lists local jobs in creation order.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow[]>} - All local jobs in creation order.\n   */\n  async listJobs() {\n    await this.ensureReady()\n\n    return await this._withDb(async (db) => {\n      const rows = await db\n        .newQuery()\n        .from(LOCAL_BACKGROUND_JOBS_TABLE)\n        .order(\"created_at_ms ASC\")\n        .order(\"id ASC\")\n        .results()\n\n      return rows.map((row) => this._normalizeRow(row))\n    })\n  }\n\n  /**\n   * Atomically reserves concurrency and claims one queued job.\n   * @param {{jobId: string, workerId?: string}} args - Claim request.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobHandoff | null>} - Fenced claim.\n   */\n  async markHandedOff({jobId, workerId}) {\n    await this.ensureReady()\n\n    return await this._withDb(async (connection) => await this._mutate(connection, async (db) => {\n      const job = await this._getJob(db, jobId)\n\n      if (!job || job.status !== \"queued\" || Number(job.scheduledAtMs) > this.clock.now()) return null\n      if (job.concurrencyKey && !(await this._reserveConcurrency(db, job.concurrencyKey))) return null\n\n      const handedOffAtMs = this.clock.now()\n      const handoffId = new UUID(4).format()\n      const affectedRows = await this._updateAffectedRows(db, {\n        conditions: {id: jobId, status: \"queued\"},\n        data: {handed_off_at_ms: handedOffAtMs, handoff_id: handoffId, status: \"handed_off\", worker_id: workerId || \"local\"},\n        tableName: LOCAL_BACKGROUND_JOBS_TABLE\n      })\n\n      if (affectedRows !== 1) {\n        await this._releaseConcurrency(db, job.concurrencyKey)\n        return null\n      }\n\n      return {handedOffAtMs, handoffId}\n    }))\n  }\n\n  /**\n   * Finds active local handoffs owned by one worker.\n   * @param {{workerId: string}} args - Worker identity.\n   * @returns {Promise<Array<{jobId: string, handoffId: string}>>} - Active worker handoffs.\n   */\n  async handedOffJobsForWorker({workerId}) {\n    await this.ensureReady()\n\n    const rows = await this._withDb(async (db) => await db\n      .newQuery()\n      .from(LOCAL_BACKGROUND_JOBS_TABLE)\n      .where({status: \"handed_off\", worker_id: workerId})\n      .results())\n    /** @type {Array<{jobId: string, handoffId: string}>} */\n    const handoffs = []\n\n    for (const rawRow of rows) {\n      const job = this._normalizeRow(rawRow)\n\n      if (job.handoffId) handoffs.push({jobId: job.id, handoffId: job.handoffId})\n    }\n\n    return handoffs\n  }\n\n  /**\n   * Returns an exact active handoff to the queue.\n   * @param {{jobId: string, handoffId: string}} args - Handoff release.\n   * @returns {Promise<void>} - Resolves after the fenced release.\n   */\n  async markReturnedToQueue({jobId, handoffId}) {\n    await this.ensureReady()\n\n    await this._withDb(async (connection) => await this._mutate(connection, async (db) => {\n      const job = await this._getJob(db, jobId)\n\n      if (!this._acceptsHandoff(job, handoffId)) return\n      await this._lockConcurrencyRow(db, job.concurrencyKey)\n\n      const affectedRows = await this._updateAffectedRows(db, {\n        conditions: {handoff_id: handoffId, id: jobId, status: \"handed_off\"},\n        data: {\n          handed_off_at_ms: null,\n          handoff_id: null,\n          scheduled_at_ms: this.clock.now(),\n          status: \"queued\",\n          worker_id: null\n        },\n        tableName: LOCAL_BACKGROUND_JOBS_TABLE\n      })\n\n      if (affectedRows === 1) await this._releaseConcurrency(db, job.concurrencyKey)\n    }))\n  }\n\n  /**\n   * Applies a fenced successful acknowledgement.\n   * @param {{jobId: string, handoffId?: string}} args - Completion report.\n   * @returns {Promise<boolean>} - Whether the lease won.\n   */\n  async markCompleted({jobId, handoffId}) {\n    await this.ensureReady()\n\n    return await this._withDb(async (connection) => await this._mutate(connection, async (db) => {\n      const job = await this._getJob(db, jobId)\n\n      if (!this._acceptsHandoff(job, handoffId)) return false\n      await this._lockConcurrencyRow(db, job.concurrencyKey)\n\n      const affectedRows = await this._updateAffectedRows(db, {\n        conditions: {handoff_id: handoffId, id: jobId, status: \"handed_off\"},\n        data: {completed_at_ms: this.clock.now(), status: \"completed\"},\n        tableName: LOCAL_BACKGROUND_JOBS_TABLE\n      })\n\n      if (affectedRows !== 1) return false\n      await this._releaseConcurrency(db, job.concurrencyKey)\n      return true\n    }))\n  }\n\n  /**\n   * Applies a fenced reschedule without consuming an attempt.\n   * @param {{jobId: string, handoffId?: string, delayMs: number}} args - Reschedule report.\n   * @returns {Promise<boolean>} - Whether the lease won.\n   */\n  async markRescheduled({jobId, handoffId, delayMs}) {\n    await this.ensureReady()\n\n    return await this._withDb(async (connection) => await this._mutate(connection, async (db) => {\n      const job = await this._getJob(db, jobId)\n\n      if (!this._acceptsHandoff(job, handoffId)) return false\n      await this._lockConcurrencyRow(db, job.concurrencyKey)\n\n      const affectedRows = await this._updateAffectedRows(db, {\n        conditions: {handoff_id: handoffId, id: jobId, status: \"handed_off\"},\n        data: {\n          handed_off_at_ms: null,\n          handoff_id: null,\n          scheduled_at_ms: rescheduledBackgroundJobAtMs(delayMs, this.clock.now()),\n          status: \"queued\",\n          worker_id: null\n        },\n        tableName: LOCAL_BACKGROUND_JOBS_TABLE\n      })\n\n      if (affectedRows !== 1) return false\n      await this._releaseConcurrency(db, job.concurrencyKey)\n      return true\n    }))\n  }\n\n  /**\n   * Applies a fenced failure, retry, or terminal transition.\n   * @param {{jobId: string, handoffId?: string, error: ReturnType<typeof JSON.parse>}} args - Failure report.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Accepted transition snapshot.\n   */\n  async markFailed({jobId, handoffId, error}) {\n    await this.ensureReady()\n\n    return await this._withDb(async (connection) => await this._mutate(connection, async (db) => {\n      const job = await this._getJob(db, jobId)\n\n      if (!this._acceptsHandoff(job, handoffId)) return null\n\n      return await this._applyFailure(db, job, error)\n    }))\n  }\n\n  /**\n   * Turns every abandoned local handoff into the normal failure/retry path.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow[]>} - Recovered transitions.\n   */\n  async recoverHandedOffJobs() {\n    await this.ensureReady()\n\n    return await this._withDb(async (connection) => await this._mutate(connection, async (db) => {\n      const queues = this.configuration.getBackgroundJobsConfig().queues\n      const rows = await db.newQuery().from(LOCAL_BACKGROUND_JOBS_TABLE).where({status: \"handed_off\"}).results()\n      /** @type {import(\"./types.js\").BackgroundJobRow[]} */\n      const recovered = []\n\n      for (const rawRow of rows) {\n        const job = this._normalizeRow(rawRow)\n        const updated = await this._applyFailure(db, job, new Error(\"Local background job recovered after an interrupted dispatcher\"))\n\n        if (!updated) continue\n\n        const reconciled = updated.status === \"queued\"\n          ? await this._reconcileQueuedJobConcurrency(db, updated, queues)\n          : updated\n\n        recovered.push(reconciled)\n      }\n\n      await this._rebuildConcurrencyCounts(db)\n      return recovered\n    }))\n  }\n\n  /**\n   * Deletes local queue state for focused tests.\n   * @returns {Promise<void>} - Resolves after deletion.\n   */\n  async clearAll() {\n    await this.ensureReady()\n    await this._withDb(async (connection) => await this._mutate(connection, async (db) => {\n      await db.query(`DELETE FROM ${db.quoteTable(LOCAL_BACKGROUND_JOBS_TABLE)}`)\n      await db.query(`DELETE FROM ${db.quoteTable(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE)}`)\n    }))\n  }\n\n  /**\n   * Applies the common retry or exhausted failure transition.\n   * @param {import(\"../database/drivers/base.js\").default} db - Local SQLite connection.\n   * @param {import(\"./types.js\").BackgroundJobRow} job - Active handoff.\n   * @param {ReturnType<typeof JSON.parse>} error - Performance error.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Transition snapshot.\n   */\n  async _applyFailure(db, job, error) {\n    const attempts = (job.attempts || 0) + 1\n    const maxRetries = normalizeBackgroundJobMaxRetries(job.maxRetries)\n    const willRetry = attempts <= maxRetries\n    const nowMs = this.clock.now()\n    /** @type {Record<string, ReturnType<typeof JSON.parse>>} */\n    const data = {\n      attempts,\n      handed_off_at_ms: null,\n      handoff_id: null,\n      last_error: normalizeBackgroundJobError(error),\n      status: willRetry ? \"queued\" : \"failed\",\n      worker_id: null\n    }\n\n    if (willRetry) {\n      Object.assign(data, {scheduled_at_ms: nowMs + retryDelayMs(attempts)})\n    } else {\n      Object.assign(data, {failed_at_ms: nowMs})\n    }\n\n    await this._lockConcurrencyRow(db, job.concurrencyKey)\n    const affectedRows = await this._updateAffectedRows(db, {\n      conditions: {handoff_id: job.handoffId, id: job.id, status: \"handed_off\"},\n      data,\n      tableName: LOCAL_BACKGROUND_JOBS_TABLE\n    })\n\n    if (affectedRows !== 1) return null\n    await this._releaseConcurrency(db, job.concurrencyKey)\n\n    return {\n      ...job,\n      attempts,\n      failedAtMs: willRetry ? job.failedAtMs : nowMs,\n      handedOffAtMs: null,\n      handoffId: null,\n      lastError: data.last_error,\n      scheduledAtMs: willRetry ? Number(data.scheduled_at_ms) : job.scheduledAtMs,\n      status: data.status,\n      workerId: null\n    }\n  }\n\n  /**\n   * Ensures that a durable concurrency counter exists with the required cap.\n   * @param {import(\"../database/drivers/base.js\").default} db - Local SQLite connection.\n   * @param {import(\"./types.js\").ResolvedBackgroundJobConcurrency} concurrency - Desired counter.\n   * @returns {Promise<void>} - Resolves when ensured.\n   */\n  async _ensureConcurrency(db, concurrency) {\n    await db.upsert({\n      conflictColumns: [\"concurrency_key\"],\n      data: {active_count: 0, concurrency_key: concurrency.concurrencyKey, max_concurrency: concurrency.maxConcurrency},\n      tableName: LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE,\n      updateColumns: [\"concurrency_key\"]\n    })\n\n    const rows = await db\n      .newQuery()\n      .from(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE)\n      .where({concurrency_key: concurrency.concurrencyKey})\n      .limit(1)\n      .results()\n\n    const existingRow = /** @type {{max_concurrency: number | string}} */ (rows[0])\n    const existingCap = Number(existingRow.max_concurrency)\n\n    if (existingCap === concurrency.maxConcurrency) return\n    if (!concurrency.queueDerived) throw new Error(`Conflicting maxConcurrency for background job concurrencyKey: ${concurrency.concurrencyKey}`)\n\n    await db.update({\n      conditions: {concurrency_key: concurrency.concurrencyKey},\n      data: {max_concurrency: concurrency.maxConcurrency},\n      tableName: LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE\n    })\n  }\n\n  /**\n   * Atomically reserves one slot for a concurrency key.\n   * @param {import(\"../database/drivers/base.js\").default} db - Connection.\n   * @param {string} concurrencyKey - Concurrency key.\n   * @returns {Promise<boolean>} - Whether a slot was reserved.\n   */\n  async _reserveConcurrency(db, concurrencyKey) {\n    const table = db.quoteTable(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE)\n    const count = db.quoteColumn(\"active_count\")\n    const affectedRows = await db.affectedRows(\n      `UPDATE ${table} SET ${count} = ${count} + 1 ` +\n      `WHERE ${db.quoteColumn(\"concurrency_key\")} = ${db.quote(concurrencyKey)} ` +\n      `AND ${count} < ${db.quoteColumn(\"max_concurrency\")}`\n    )\n\n    return affectedRows === 1\n  }\n\n  /**\n   * Releases one slot for a concurrency key.\n   * @param {import(\"../database/drivers/base.js\").default} db - Connection.\n   * @param {string | null} concurrencyKey - Concurrency key.\n   * @returns {Promise<void>} - Resolves after release.\n   */\n  async _releaseConcurrency(db, concurrencyKey) {\n    if (!concurrencyKey) return\n\n    const table = db.quoteTable(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE)\n    const count = db.quoteColumn(\"active_count\")\n\n    await db.affectedRows(\n      `UPDATE ${table} SET ${count} = ${count} - 1 ` +\n      `WHERE ${db.quoteColumn(\"concurrency_key\")} = ${db.quote(concurrencyKey)} AND ${count} > 0`\n    )\n  }\n\n  /**\n   * Acquires the transaction's write lock for a concurrency counter row.\n   * @param {import(\"../database/drivers/base.js\").default} db - Connection.\n   * @param {string | null} concurrencyKey - Concurrency key.\n   * @returns {Promise<void>} - Resolves after locking.\n   */\n  async _lockConcurrencyRow(db, concurrencyKey) {\n    if (!concurrencyKey) return\n\n    const table = db.quoteTable(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE)\n    const count = db.quoteColumn(\"active_count\")\n\n    await db.query(\n      `UPDATE ${table} SET ${count} = ${count} ` +\n      `WHERE ${db.quoteColumn(\"concurrency_key\")} = ${db.quote(concurrencyKey)}`\n    )\n  }\n\n  /**\n   * Rebuilds active counters from durable handed-off jobs.\n   * @param {import(\"../database/drivers/base.js\").default} db - Connection.\n   * @returns {Promise<void>} - Resolves after counter rebuild.\n   */\n  async _rebuildConcurrencyCounts(db) {\n    const concurrencyTable = db.quoteTable(LOCAL_BACKGROUND_JOB_CONCURRENCY_TABLE)\n    const jobsTable = db.quoteTable(LOCAL_BACKGROUND_JOBS_TABLE)\n\n    await db.query(\n      `UPDATE ${concurrencyTable} SET ${db.quoteColumn(\"active_count\")} = (` +\n      `SELECT COUNT(*) FROM ${jobsTable} WHERE ${jobsTable}.${db.quoteColumn(\"status\")} = ${db.quote(\"handed_off\")} AND ` +\n      `${jobsTable}.${db.quoteColumn(\"concurrency_key\")} = ${concurrencyTable}.${db.quoteColumn(\"concurrency_key\")})`\n    )\n  }\n\n  /**\n   * Builds the configured queue-priority ordering expression.\n   * @param {import(\"../database/drivers/base.js\").default} db - Connection.\n   * @returns {string | null} - Queue priority expression.\n   */\n  _queuePriorityOrderSql(db) {\n    const queues = this.configuration.getBackgroundJobsConfig().queues\n    const prioritized = Object.entries(queues)\n      .filter(([, queue]) => Number.isFinite(queue?.priority) && Number(queue.priority) !== 0)\n      .map(([queueName, queue]) => [queueName, Number(queue.priority)])\n\n    if (prioritized.length === 0) return null\n\n    const whens = prioritized\n      .map(([queue, priority]) => `WHEN ${db.quote(queue)} THEN ${priority}`)\n      .join(\" \")\n\n    return `CASE COALESCE(${db.quoteColumn(\"queue\")}, ${db.quote(DEFAULT_BACKGROUND_JOB_QUEUE)}) ${whens} ELSE 0 END`\n  }\n\n  /**\n   * Checks whether a persisted handoff owns the supplied acknowledgement fence.\n   * @param {import(\"./types.js\").BackgroundJobRow | null} job - Persisted job.\n   * @param {string | undefined} handoffId - Handoff fence.\n   * @returns {job is import(\"./types.js\").BackgroundJobRow} - Whether accepted.\n   */\n  _acceptsHandoff(job, handoffId) {\n    return Boolean(job && job.status === \"handed_off\" && job.handoffId && job.handoffId === handoffId)\n  }\n\n  /**\n   * Finds a persisted local job using the current connection.\n   * @param {import(\"../database/drivers/base.js\").default} db - Connection.\n   * @param {string} jobId - Job id.\n   * @returns {Promise<import(\"./types.js\").BackgroundJobRow | null>} - Persisted row.\n   */\n  async _getJob(db, jobId) {\n    const rows = await db.newQuery().from(LOCAL_BACKGROUND_JOBS_TABLE).where({id: jobId}).limit(1).results()\n\n    return rows[0] ? this._normalizeRow(rows[0]) : null\n  }\n\n  /**\n   * Normalizes one raw local database row.\n   * @param {Record<string, ReturnType<typeof JSON.parse>>} row - Raw row.\n   * @returns {import(\"./types.js\").BackgroundJobRow} - Normalized row.\n   */\n  _normalizeRow(row) {\n    const parsedArgs = JSON.parse(String(row.args_json))\n    const executionMode = normalizeBackgroundJobExecutionMode({executionMode: String(row.execution_mode)}, \"inline\", LOCAL_EXECUTION_MODES)\n\n    if (!Array.isArray(parsedArgs)) throw new Error(`Invalid local background job args_json for job: ${String(row.id)}`)\n    if (executionMode !== \"inline\") throw new Error(\"Local background job execution mode invariant was violated\")\n\n    return {\n      args: parsedArgs,\n      attempts: this._numberOrNull(row.attempts),\n      completedAtMs: this._numberOrNull(row.completed_at_ms),\n      concurrencyKey: row.concurrency_key === null || row.concurrency_key === undefined ? null : String(row.concurrency_key),\n      createdAtMs: this._numberOrNull(row.created_at_ms),\n      executionMode,\n      failedAtMs: this._numberOrNull(row.failed_at_ms),\n      handedOffAtMs: this._numberOrNull(row.handed_off_at_ms),\n      handoffId: row.handoff_id === null || row.handoff_id === undefined ? null : String(row.handoff_id),\n      id: String(row.id),\n      jobName: String(row.job_name),\n      lastError: row.last_error === null || row.last_error === undefined ? null : String(row.last_error),\n      maxConcurrency: this._numberOrNull(row.max_concurrency),\n      maxRetries: this._numberOrNull(row.max_retries),\n      orphanedAtMs: null,\n      queue: row.queue ? String(row.queue) : DEFAULT_BACKGROUND_JOB_QUEUE,\n      scheduleKey: null,\n      scheduledAtMs: this._numberOrNull(row.scheduled_at_ms),\n      status: row.status ? String(row.status) : \"queued\",\n      workerId: row.worker_id === null || row.worker_id === undefined ? null : String(row.worker_id)\n    }\n  }\n\n  /**\n   * Normalizes one nullable database number.\n   * @param {ReturnType<typeof JSON.parse>} value - Database number.\n   * @returns {number | null} - Normalized number.\n   */\n  _numberOrNull(value) {\n    if (value === null || value === undefined || value === \"\") return null\n\n    const number = Number(value)\n\n    return Number.isNaN(number) ? null : number\n  }\n\n  /**\n   * Executes a structured update and reports its affected-row count.\n   * @param {import(\"../database/drivers/base.js\").default} db - Connection.\n   * @param {import(\"../database/drivers/base.js\").UpdateSqlArgsType} args - Update arguments.\n   * @returns {Promise<number>} - Affected rows.\n   */\n  async _updateAffectedRows(db, args) { return await db.affectedRows(db.updateSql(args)) }\n\n  /**\n   * Joins an ambient app transaction or uses the database's scoped operation lease.\n   * @template T\n   * @param {import(\"../database/drivers/base.js\").default} db - Connection.\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<T>} callback - Mutation.\n   * @returns {Promise<T>} - Mutation result.\n   */\n  async _mutate(db, callback) {\n    if (db.insideTransaction()) return await this._transactionResult(db, async () => await callback(db))\n\n    return await this.configuration.withTransaction({\n      databaseIdentifier: this.getDatabaseIdentifier(),\n      name: \"Local background jobs mutation\"\n    }, async (operation) => await callback(operation.connection()))\n  }\n\n  /**\n   * Runs a callback in a transaction and returns its captured result.\n   * @template T\n   * @param {import(\"../database/drivers/base.js\").default} db - 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\n    await db.transaction(async () => {\n      result = await callback()\n      completed = true\n    })\n\n    if (!completed) throw new Error(\"Local background jobs transaction callback was not invoked\")\n    return /** @type {T} */ (result)\n  }\n\n  /**\n   * Runs a callback with the configured local database connection.\n   * @template T\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<T>} callback - Connection callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async _withDb(callback) {\n    const databaseIdentifier = this.getDatabaseIdentifier()\n\n    return await this.configuration.ensureConnections({databaseIdentifiers: [databaseIdentifier], name: \"Local background jobs store\"}, async (dbs) => {\n      const db = dbs[databaseIdentifier]\n\n      if (!db) throw new Error(`No local background-jobs database connection available for identifier: ${databaseIdentifier}`)\n\n      return await callback(db)\n    })\n  }\n\n  /**\n   * Reports an unexpected local-store failure through framework channels.\n   * @param {{error: Error, stage: string}} args - Error report.\n   * @returns {void} - No return value.\n   */\n  _reportFrameworkError({error, stage}) {\n    const payload = {context: {stage}, error}\n    const errorEvents = this.configuration.getErrorEvents()\n\n    errorEvents.emit(\"framework-error\", payload)\n    errorEvents.emit(\"all-error\", {...payload, errorType: \"framework-error\"})\n  }\n}\n"]}