velocious 1.0.699 → 1.0.700

package/build/src/database/advisory-lock-file-backend.js

@@ -0,0 +1,313 @@
+// @ts-check
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import wait from "awaitery/build/wait.js";
+/**
+ * Owner metadata written inside one file-lock directory.
+ * @typedef {object} AdvisoryLockFileOwner
+ * @property {number} pid - PID of the holding process.
+ * @property {string} hostname - Host of the holding process.
+ * @property {string} holderId - Unique id of the acquiring backend instance.
+ * @property {string} acquiredAt - ISO timestamp of acquisition.
+ * @property {string} leaseExpiresAt - ISO timestamp when the current lease expires without renewal.
+ * @property {string} [host] - Extra owner field: HTTP host (server lock only).
+ * @property {number} [port] - Extra owner field: HTTP port (server lock only).
+ */
+/**
+ * Directory-based advisory-lock backend for the STC-210 `file` tier
+ * (`docs/advisory-lock-backends.md` tier (d)). This generalizes the pattern
+ * already used by `src/http-server/server-lock.js` and the Node SQLite
+ * driver's filesystem layer into one reusable backend behind the shared
+ * advisory-lock seam:
+ *
+ * - Atomic publication: a lock is claimed by `fs.mkdtemp` + `fs.rename` onto
+ *   the stable lock path, so a losing candidate never observes or deletes a
+ *   half-written owner record.
+ * - Lease + renewal: each hold carries a `leaseMs` lease renewed on
+ *   `renewIntervalMs` while held, so a holder that dies without releasing
+ *   (or whose PID was recycled) is reclaimable once the lease expires.
+ * - Staleness: a lock directory is stale when its owner metadata is
+ *   unreadable, its lease expired, or its owner is a dead local process
+ *   (`kill(pid, 0)` → `ESRCH`). Cross-host owners are only reclaimable via
+ *   lease expiry because PID liveness cannot be probed remotely.
+ *
+ * This tier provides no fencing tokens (design §8: a file lock has no
+ * monotonic authority a partitioned holder can be checked against), so
+ * acquisitions report `fencingSupported: false` instead of pretending.
+ */
+export default class AdvisoryLockFileBackend {
+    /**
+     * Creates one file-lock backend.
+     * @param {object} args - Backend options.
+     * @param {string} args.directory - Directory that holds the lock directories.
+     * @param {Record<string, string | number>} [args.extraOwnerFields] - Extra fields merged into every owner metadata record (e.g. the HTTP server lock's host/port).
+     * @param {number} [args.leaseMs] - Lease duration for one hold; expired leases make a lock stale. Defaults to 30000.
+     * @param {number} [args.renewIntervalMs] - Renewal cadence while holding; must stay below `leaseMs`. Defaults to 10000.
+     * @param {"hashed" | "plain"} [args.pathStyle] - `hashed` derives `<safeName>-<hash>.lock` names (advisory-lock tier); `plain` uses `<name>.lock` (HTTP server lock). Defaults to `hashed`.
+     * @param {number} [args.pollIntervalMs] - Wait between acquisition retries. Defaults to 50.
+     */
+    constructor({ directory, extraOwnerFields = {}, leaseMs = 30_000, renewIntervalMs = 10_000, pathStyle = "hashed", pollIntervalMs = 50 }) {
+        this.directory = directory;
+        this.extraOwnerFields = extraOwnerFields;
+        this.leaseMs = leaseMs;
+        this.renewIntervalMs = renewIntervalMs;
+        this.pathStyle = pathStyle;
+        this.pollIntervalMs = pollIntervalMs;
+        this.holderId = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+        /** @type {Map<string, {timer: ReturnType<typeof setInterval>}>} */
+        this.holdsByName = new Map();
+    }
+    /**
+     * Resolves the stable lock directory path for one lock name.
+     * @param {string} name - Lock name.
+     * @returns {string} - Filesystem path for the lock directory.
+     */
+    lockPathFor(name) {
+        if (this.pathStyle === "plain")
+            return path.join(this.directory, `${name}.lock`);
+        const hash = createHash("sha256").update(name).digest("hex").slice(0, 16);
+        const safeName = name.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 64);
+        return path.join(this.directory, `${safeName}-${hash}.lock`);
+    }
+    /**
+     * Blocks until the named lock is acquired or `timeoutMs` elapses.
+     * @param {string} name - Lock name.
+     * @param {{timeoutMs?: number | null}} [args] - Timeout args; `null`, `undefined`, or negative waits indefinitely.
+     * @returns {Promise<boolean>} - True when acquired, false when the timeout elapsed.
+     */
+    async acquire(name, { timeoutMs } = {}) {
+        const deadline = typeof timeoutMs === "number" && timeoutMs >= 0 ? Date.now() + timeoutMs : null;
+        await this.ensureDirectory();
+        // Intentionally looping without a fixed iteration cap — either the
+        // publication succeeds, the deadline elapses, or an unexpected error is
+        // re-thrown.
+        while (true) {
+            if (await this.tryAcquire(name))
+                return true;
+            if (deadline !== null) {
+                const remaining = deadline - Date.now();
+                if (remaining <= 0)
+                    return false;
+                await wait(Math.min(this.pollIntervalMs, remaining));
+            }
+            else {
+                await wait(this.pollIntervalMs);
+            }
+        }
+    }
+    /**
+     * Attempts to acquire the named lock without waiting, reclaiming a stale
+     * lock directory when one is found.
+     * @param {string} name - Lock name.
+     * @returns {Promise<boolean>} - True when this backend became the lock owner.
+     */
+    async tryAcquire(name) {
+        if (this.holdsByName.has(name))
+            return false;
+        await this.ensureDirectory();
+        const lockPath = this.lockPathFor(name);
+        if (await this.publishLockDirectory(lockPath))
+            return this.startHold(name);
+        if (await this.isStale(lockPath)) {
+            await fs.rm(lockPath, { recursive: true, force: true });
+            if (await this.publishLockDirectory(lockPath))
+                return this.startHold(name);
+        }
+        return false;
+    }
+    /**
+     * Releases the lock only when this backend instance owns it, mirroring the
+     * "you can only release locks you own" contract of the database tiers.
+     * @param {string} name - Lock name.
+     * @returns {Promise<boolean>} - True when the held lock was released.
+     */
+    async release(name) {
+        const hold = this.holdsByName.get(name);
+        if (!hold)
+            return false;
+        this.clearHold(name);
+        const owner = await this.readOwner(this.lockPathFor(name));
+        if (!owner || owner.holderId !== this.holderId)
+            return false;
+        await fs.rm(this.lockPathFor(name), { recursive: true, force: true });
+        return true;
+    }
+    /**
+     * Runs is held.
+     * @param {string} name - Lock name.
+     * @returns {Promise<boolean>} - Whether the lock is currently held by a live, unexpired owner.
+     */
+    async isHeld(name) {
+        const lockPath = this.lockPathFor(name);
+        try {
+            await fs.stat(lockPath);
+        }
+        catch {
+            return false;
+        }
+        return !await this.isStale(lockPath);
+    }
+    /**
+     * Reads the current owner metadata for diagnostics.
+     * @param {string} name - Lock name.
+     * @returns {Promise<AdvisoryLockFileOwner | null>} - Parsed owner metadata, when a lock directory exists.
+     */
+    async holderInfo(name) {
+        return await this.readOwner(this.lockPathFor(name));
+    }
+    /**
+     * Releases every lock this backend instance currently holds (shutdown path).
+     * @returns {Promise<void>} - Resolves after best-effort release of all holds.
+     */
+    async releaseAllHeld() {
+        for (const name of [...this.holdsByName.keys()]) {
+            await this.release(name);
+        }
+    }
+    /**
+     * Ensures the parent lock directory exists.
+     * @returns {Promise<void>} - Resolves after the directory exists.
+     */
+    async ensureDirectory() {
+        await fs.mkdir(this.directory, { recursive: true });
+    }
+    /**
+     * Publishes a fully initialized lock directory with one atomic rename so
+     * concurrent candidates cannot observe a half-written owner record.
+     * @param {string} lockPath - Stable lock directory path.
+     * @returns {Promise<boolean>} - Whether this candidate became the lock owner.
+     */
+    async publishLockDirectory(lockPath) {
+        const candidatePath = await fs.mkdtemp(`${lockPath}.pending-`);
+        let published = false;
+        try {
+            await this.writeOwner(candidatePath);
+            try {
+                await fs.rename(candidatePath, lockPath);
+                published = true;
+                return true;
+            }
+            catch (error) {
+                const code = /** @type {Error & {code?: string}} */ (error)?.code;
+                if (code === "EEXIST" || code === "ENOTEMPTY")
+                    return false;
+                throw error;
+            }
+        }
+        finally {
+            if (!published)
+                await fs.rm(candidatePath, { recursive: true, force: true });
+        }
+    }
+    /**
+     * Starts lease renewal for a freshly acquired hold.
+     * @param {string} name - Lock name.
+     * @returns {true} - Always true; the hold is now tracked.
+     */
+    startHold(name) {
+        const timer = setInterval(() => {
+            void this.renewHold(name);
+        }, this.renewIntervalMs);
+        if (typeof timer.unref === "function")
+            timer.unref();
+        this.holdsByName.set(name, { timer });
+        return true;
+    }
+    /**
+     * Extends this instance's lease on one held lock; stops renewing when the
+     * directory is no longer ours (the lock was reclaimed).
+     * @param {string} name - Lock name.
+     * @returns {Promise<void>} - Resolves after the renewal attempt.
+     */
+    async renewHold(name) {
+        const hold = this.holdsByName.get(name);
+        if (!hold)
+            return;
+        const owner = await this.readOwner(this.lockPathFor(name));
+        if (!owner || owner.holderId !== this.holderId) {
+            this.clearHold(name);
+            return;
+        }
+        await this.writeOwner(this.lockPathFor(name));
+    }
+    /**
+     * Clears the renewal timer for one hold.
+     * @param {string} name - Lock name.
+     * @returns {void}
+     */
+    clearHold(name) {
+        const hold = this.holdsByName.get(name);
+        if (!hold)
+            return;
+        clearInterval(hold.timer);
+        this.holdsByName.delete(name);
+    }
+    /**
+     * Writes owner + lease metadata into a lock directory.
+     * @param {string} lockDirPath - Lock directory to write metadata into.
+     * @returns {Promise<void>} - Resolves after metadata is written.
+     */
+    async writeOwner(lockDirPath) {
+        /** @type {AdvisoryLockFileOwner} */
+        const owner = {
+            acquiredAt: new Date().toISOString(),
+            holderId: this.holderId,
+            hostname: os.hostname(),
+            leaseExpiresAt: new Date(Date.now() + this.leaseMs).toISOString(),
+            pid: process.pid,
+            ...this.extraOwnerFields
+        };
+        await fs.writeFile(path.join(lockDirPath, "owner.json"), JSON.stringify(owner));
+    }
+    /**
+     * Reads owner metadata from a lock directory.
+     * @param {string} lockPath - Lock directory path.
+     * @returns {Promise<AdvisoryLockFileOwner | null>} - Parsed owner metadata, when readable.
+     */
+    async readOwner(lockPath) {
+        /** @type {string} */
+        let rawOwner;
+        try {
+            rawOwner = await fs.readFile(path.join(lockPath, "owner.json"), "utf8");
+        }
+        catch {
+            return null;
+        }
+        try {
+            return /** @type {AdvisoryLockFileOwner} */ (JSON.parse(rawOwner));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * A lock directory is stale when its metadata is unreadable, its lease has
+     * expired, or its owner is a dead process on this host. Cross-host owners
+     * are only reclaimable via lease expiry — PID probing is unreliable beyond
+     * one host, which is exactly why this tier is the opt-in single-host last
+     * resort (design §4/§8).
+     * @param {string} lockPath - Lock directory path.
+     * @returns {Promise<boolean>} - Whether the lock can be reclaimed.
+     */
+    async isStale(lockPath) {
+        const owner = await this.readOwner(lockPath);
+        if (!owner || typeof owner.pid !== "number")
+            return true;
+        if (owner.leaseExpiresAt && new Date(owner.leaseExpiresAt).getTime() <= Date.now())
+            return true;
+        if (owner.hostname && owner.hostname !== os.hostname())
+            return false;
+        try {
+            // `kill(pid, 0)` is a no-op signal that fails with ESRCH when the
+            // process is gone; permission errors still prove the process exists.
+            process.kill(owner.pid, 0);
+            return false;
+        }
+        catch (error) {
+            return /** @type {Error & {code?: string}} */ (error).code === "ESRCH";
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advisory-lock-file-backend.js","sourceRoot":"","sources":["../../../src/database/advisory-lock-file-backend.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAC,UAAU,EAAC,MAAM,aAAa,CAAA;AACtC,OAAO,EAAE,MAAM,kBAAkB,CAAA;AACjC,OAAO,EAAE,MAAM,SAAS,CAAA;AACxB,OAAO,IAAI,MAAM,WAAW,CAAA;AAC5B,OAAO,IAAI,MAAM,wBAAwB,CAAA;AAEzC;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,OAAO,OAAO,uBAAuB;IAC1C;;;;;;;;;OASG;IACH,YAAY,EAAC,SAAS,EAAE,gBAAgB,GAAG,EAAE,EAAE,OAAO,GAAG,MAAM,EAAE,eAAe,GAAG,MAAM,EAAE,SAAS,GAAG,QAAQ,EAAE,cAAc,GAAG,EAAE,EAAC;QACnI,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAA;QACxC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,IAAI,CAAC,eAAe,GAAG,eAAe,CAAA;QACtC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,cAAc,GAAG,cAAc,CAAA;QACpC,IAAI,CAAC,QAAQ,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAA;QACzF,mEAAmE;QACnE,IAAI,CAAC,WAAW,GAAG,IAAI,GAAG,EAAE,CAAA;IAC9B,CAAC;IAED;;;;OAIG;IACH,WAAW,CAAC,IAAI;QACd,IAAI,IAAI,CAAC,SAAS,KAAK,OAAO;YAAE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,IAAI,OAAO,CAAC,CAAA;QAEhF,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;QACzE,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;QAEnE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,QAAQ,IAAI,IAAI,OAAO,CAAC,CAAA;IAC9D,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,EAAC,SAAS,EAAC,GAAG,EAAE;QAClC,MAAM,QAAQ,GAAG,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,CAAA;QAEhG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAA;QAE5B,mEAAmE;QACnE,wEAAwE;QACxE,aAAa;QACb,OAAO,IAAI,EAAE,CAAC;YACZ,IAAI,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;gBAAE,OAAO,IAAI,CAAA;YAE5C,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;gBACtB,MAAM,SAAS,GAAG,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;gBAEvC,IAAI,SAAS,IAAI,CAAC;oBAAE,OAAO,KAAK,CAAA;gBAEhC,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC,CAAA;YACtD,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAA;YACjC,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,UAAU,CAAC,IAAI;QACnB,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO,KAAK,CAAA;QAE5C,MAAM,IAAI,CAAC,eAAe,EAAE,CAAA;QAE5B,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAA;QAEvC,IAAI,MAAM,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC;YAAE,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;QAE1E,IAAI,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YACjC,MAAM,EAAE,CAAC,EAAE,CAAC,QAAQ,EAAE,EAAC,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC,CAAA;YAErD,IAAI,MAAM,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC;gBAAE,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;QAC5E,CAAC;QAED,OAAO,KAAK,CAAA;IACd,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,OAAO,CAAC,IAAI;QAChB,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAEvC,IAAI,CAAC,IAAI;YAAE,OAAO,KAAK,CAAA;QAEvB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;QAEpB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAA;QAE1D,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,QAAQ,KAAK,IAAI,CAAC,QAAQ;YAAE,OAAO,KAAK,CAAA;QAE5D,MAAM,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,EAAC,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC,CAAA;QAEnE,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM,CAAC,IAAI;QACf,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAA;QAEvC,IAAI,CAAC;YACH,MAAM,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACzB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAA;QACd,CAAC;QAED,OAAO,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;IACtC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,UAAU,CAAC,IAAI;QACnB,OAAO,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAA;IACrD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,cAAc;QAClB,KAAK,MAAM,IAAI,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;YAChD,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;QAC1B,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,eAAe;QACnB,MAAM,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,EAAE,EAAC,SAAS,EAAE,IAAI,EAAC,CAAC,CAAA;IACnD,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,oBAAoB,CAAC,QAAQ;QACjC,MAAM,aAAa,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,GAAG,QAAQ,WAAW,CAAC,CAAA;QAC9D,IAAI,SAAS,GAAG,KAAK,CAAA;QAErB,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,CAAA;YAEpC,IAAI,CAAC;gBACH,MAAM,EAAE,CAAC,MAAM,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAA;gBACxC,SAAS,GAAG,IAAI,CAAA;gBAChB,OAAO,IAAI,CAAA;YACb,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,IAAI,GAAG,sCAAsC,CAAC,CAAC,KAAK,CAAC,EAAE,IAAI,CAAA;gBAEjE,IAAI,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,WAAW;oBAAE,OAAO,KAAK,CAAA;gBAC3D,MAAM,KAAK,CAAA;YACb,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,SAAS;gBAAE,MAAM,EAAE,CAAC,EAAE,CAAC,aAAa,EAAE,EAAC,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC,CAAA;QAC5E,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,IAAI;QACZ,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE;YAC7B,KAAK,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;QAC3B,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,CAAA;QAExB,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,UAAU;YAAE,KAAK,CAAC,KAAK,EAAE,CAAA;QAEpD,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,EAAC,KAAK,EAAC,CAAC,CAAA;QAEnC,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,SAAS,CAAC,IAAI;QAClB,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAEvC,IAAI,CAAC,IAAI;YAAE,OAAM;QAEjB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAA;QAE1D,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,QAAQ,KAAK,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC/C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;YACpB,OAAM;QACR,CAAC;QAED,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAA;IAC/C,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,IAAI;QACZ,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAEvC,IAAI,CAAC,IAAI;YAAE,OAAM;QAEjB,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACzB,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAC/B,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,UAAU,CAAC,WAAW;QAC1B,oCAAoC;QACpC,MAAM,KAAK,GAAG;YACZ,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,QAAQ,EAAE,EAAE,CAAC,QAAQ,EAAE;YACvB,cAAc,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE;YACjE,GAAG,EAAE,OAAO,CAAC,GAAG;YAChB,GAAG,IAAI,CAAC,gBAAgB;SACzB,CAAA;QAED,MAAM,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,YAAY,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAA;IACjF,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,SAAS,CAAC,QAAQ;QACtB,qBAAqB;QACrB,IAAI,QAAQ,CAAA;QAEZ,IAAI,CAAC;YACH,QAAQ,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,YAAY,CAAC,EAAE,MAAM,CAAC,CAAA;QACzE,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,IAAI,CAAA;QACb,CAAC;QAED,IAAI,CAAC;YACH,OAAO,oCAAoC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAA;QACpE,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,IAAI,CAAA;QACb,CAAC;IACH,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,OAAO,CAAC,QAAQ;QACpB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAA;QAE5C,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,CAAC,GAAG,KAAK,QAAQ;YAAE,OAAO,IAAI,CAAA;QAExD,IAAI,KAAK,CAAC,cAAc,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,OAAO,EAAE,IAAI,IAAI,CAAC,GAAG,EAAE;YAAE,OAAO,IAAI,CAAA;QAE/F,IAAI,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,QAAQ,KAAK,EAAE,CAAC,QAAQ,EAAE;YAAE,OAAO,KAAK,CAAA;QAEpE,IAAI,CAAC;YACH,kEAAkE;YAClE,qEAAqE;YACrE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAA;YAE1B,OAAO,KAAK,CAAA;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,sCAAsC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,KAAK,OAAO,CAAA;QACxE,CAAC;IACH,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport {createHash} from \"node:crypto\"\nimport fs from \"node:fs/promises\"\nimport os from \"node:os\"\nimport path from \"node:path\"\nimport wait from \"awaitery/build/wait.js\"\n\n/**\n * Owner metadata written inside one file-lock directory.\n * @typedef {object} AdvisoryLockFileOwner\n * @property {number} pid - PID of the holding process.\n * @property {string} hostname - Host of the holding process.\n * @property {string} holderId - Unique id of the acquiring backend instance.\n * @property {string} acquiredAt - ISO timestamp of acquisition.\n * @property {string} leaseExpiresAt - ISO timestamp when the current lease expires without renewal.\n * @property {string} [host] - Extra owner field: HTTP host (server lock only).\n * @property {number} [port] - Extra owner field: HTTP port (server lock only).\n */\n\n/**\n * Directory-based advisory-lock backend for the STC-210 `file` tier\n * (`docs/advisory-lock-backends.md` tier (d)). This generalizes the pattern\n * already used by `src/http-server/server-lock.js` and the Node SQLite\n * driver's filesystem layer into one reusable backend behind the shared\n * advisory-lock seam:\n *\n * - Atomic publication: a lock is claimed by `fs.mkdtemp` + `fs.rename` onto\n *   the stable lock path, so a losing candidate never observes or deletes a\n *   half-written owner record.\n * - Lease + renewal: each hold carries a `leaseMs` lease renewed on\n *   `renewIntervalMs` while held, so a holder that dies without releasing\n *   (or whose PID was recycled) is reclaimable once the lease expires.\n * - Staleness: a lock directory is stale when its owner metadata is\n *   unreadable, its lease expired, or its owner is a dead local process\n *   (`kill(pid, 0)` → `ESRCH`). Cross-host owners are only reclaimable via\n *   lease expiry because PID liveness cannot be probed remotely.\n *\n * This tier provides no fencing tokens (design §8: a file lock has no\n * monotonic authority a partitioned holder can be checked against), so\n * acquisitions report `fencingSupported: false` instead of pretending.\n */\nexport default class AdvisoryLockFileBackend {\n  /**\n   * Creates one file-lock backend.\n   * @param {object} args - Backend options.\n   * @param {string} args.directory - Directory that holds the lock directories.\n   * @param {Record<string, string | number>} [args.extraOwnerFields] - Extra fields merged into every owner metadata record (e.g. the HTTP server lock's host/port).\n   * @param {number} [args.leaseMs] - Lease duration for one hold; expired leases make a lock stale. Defaults to 30000.\n   * @param {number} [args.renewIntervalMs] - Renewal cadence while holding; must stay below `leaseMs`. Defaults to 10000.\n   * @param {\"hashed\" | \"plain\"} [args.pathStyle] - `hashed` derives `<safeName>-<hash>.lock` names (advisory-lock tier); `plain` uses `<name>.lock` (HTTP server lock). Defaults to `hashed`.\n   * @param {number} [args.pollIntervalMs] - Wait between acquisition retries. Defaults to 50.\n   */\n  constructor({directory, extraOwnerFields = {}, leaseMs = 30_000, renewIntervalMs = 10_000, pathStyle = \"hashed\", pollIntervalMs = 50}) {\n    this.directory = directory\n    this.extraOwnerFields = extraOwnerFields\n    this.leaseMs = leaseMs\n    this.renewIntervalMs = renewIntervalMs\n    this.pathStyle = pathStyle\n    this.pollIntervalMs = pollIntervalMs\n    this.holderId = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`\n    /** @type {Map<string, {timer: ReturnType<typeof setInterval>}>} */\n    this.holdsByName = new Map()\n  }\n\n  /**\n   * Resolves the stable lock directory path for one lock name.\n   * @param {string} name - Lock name.\n   * @returns {string} - Filesystem path for the lock directory.\n   */\n  lockPathFor(name) {\n    if (this.pathStyle === \"plain\") return path.join(this.directory, `${name}.lock`)\n\n    const hash = createHash(\"sha256\").update(name).digest(\"hex\").slice(0, 16)\n    const safeName = name.replace(/[^a-zA-Z0-9._-]/g, \"_\").slice(0, 64)\n\n    return path.join(this.directory, `${safeName}-${hash}.lock`)\n  }\n\n  /**\n   * Blocks until the named lock is acquired or `timeoutMs` elapses.\n   * @param {string} name - Lock name.\n   * @param {{timeoutMs?: number | null}} [args] - Timeout args; `null`, `undefined`, or negative waits indefinitely.\n   * @returns {Promise<boolean>} - True when acquired, false when the timeout elapsed.\n   */\n  async acquire(name, {timeoutMs} = {}) {\n    const deadline = typeof timeoutMs === \"number\" && timeoutMs >= 0 ? Date.now() + timeoutMs : null\n\n    await this.ensureDirectory()\n\n    // Intentionally looping without a fixed iteration cap — either the\n    // publication succeeds, the deadline elapses, or an unexpected error is\n    // re-thrown.\n    while (true) {\n      if (await this.tryAcquire(name)) return true\n\n      if (deadline !== null) {\n        const remaining = deadline - Date.now()\n\n        if (remaining <= 0) return false\n\n        await wait(Math.min(this.pollIntervalMs, remaining))\n      } else {\n        await wait(this.pollIntervalMs)\n      }\n    }\n  }\n\n  /**\n   * Attempts to acquire the named lock without waiting, reclaiming a stale\n   * lock directory when one is found.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - True when this backend became the lock owner.\n   */\n  async tryAcquire(name) {\n    if (this.holdsByName.has(name)) return false\n\n    await this.ensureDirectory()\n\n    const lockPath = this.lockPathFor(name)\n\n    if (await this.publishLockDirectory(lockPath)) return this.startHold(name)\n\n    if (await this.isStale(lockPath)) {\n      await fs.rm(lockPath, {recursive: true, force: true})\n\n      if (await this.publishLockDirectory(lockPath)) return this.startHold(name)\n    }\n\n    return false\n  }\n\n  /**\n   * Releases the lock only when this backend instance owns it, mirroring the\n   * \"you can only release locks you own\" contract of the database tiers.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - True when the held lock was released.\n   */\n  async release(name) {\n    const hold = this.holdsByName.get(name)\n\n    if (!hold) return false\n\n    this.clearHold(name)\n\n    const owner = await this.readOwner(this.lockPathFor(name))\n\n    if (!owner || owner.holderId !== this.holderId) return false\n\n    await fs.rm(this.lockPathFor(name), {recursive: true, force: true})\n\n    return true\n  }\n\n  /**\n   * Runs is held.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - Whether the lock is currently held by a live, unexpired owner.\n   */\n  async isHeld(name) {\n    const lockPath = this.lockPathFor(name)\n\n    try {\n      await fs.stat(lockPath)\n    } catch {\n      return false\n    }\n\n    return !await this.isStale(lockPath)\n  }\n\n  /**\n   * Reads the current owner metadata for diagnostics.\n   * @param {string} name - Lock name.\n   * @returns {Promise<AdvisoryLockFileOwner | null>} - Parsed owner metadata, when a lock directory exists.\n   */\n  async holderInfo(name) {\n    return await this.readOwner(this.lockPathFor(name))\n  }\n\n  /**\n   * Releases every lock this backend instance currently holds (shutdown path).\n   * @returns {Promise<void>} - Resolves after best-effort release of all holds.\n   */\n  async releaseAllHeld() {\n    for (const name of [...this.holdsByName.keys()]) {\n      await this.release(name)\n    }\n  }\n\n  /**\n   * Ensures the parent lock directory exists.\n   * @returns {Promise<void>} - Resolves after the directory exists.\n   */\n  async ensureDirectory() {\n    await fs.mkdir(this.directory, {recursive: true})\n  }\n\n  /**\n   * Publishes a fully initialized lock directory with one atomic rename so\n   * concurrent candidates cannot observe a half-written owner record.\n   * @param {string} lockPath - Stable lock directory path.\n   * @returns {Promise<boolean>} - Whether this candidate became the lock owner.\n   */\n  async publishLockDirectory(lockPath) {\n    const candidatePath = await fs.mkdtemp(`${lockPath}.pending-`)\n    let published = false\n\n    try {\n      await this.writeOwner(candidatePath)\n\n      try {\n        await fs.rename(candidatePath, lockPath)\n        published = true\n        return true\n      } catch (error) {\n        const code = /** @type {Error & {code?: string}} */ (error)?.code\n\n        if (code === \"EEXIST\" || code === \"ENOTEMPTY\") return false\n        throw error\n      }\n    } finally {\n      if (!published) await fs.rm(candidatePath, {recursive: true, force: true})\n    }\n  }\n\n  /**\n   * Starts lease renewal for a freshly acquired hold.\n   * @param {string} name - Lock name.\n   * @returns {true} - Always true; the hold is now tracked.\n   */\n  startHold(name) {\n    const timer = setInterval(() => {\n      void this.renewHold(name)\n    }, this.renewIntervalMs)\n\n    if (typeof timer.unref === \"function\") timer.unref()\n\n    this.holdsByName.set(name, {timer})\n\n    return true\n  }\n\n  /**\n   * Extends this instance's lease on one held lock; stops renewing when the\n   * directory is no longer ours (the lock was reclaimed).\n   * @param {string} name - Lock name.\n   * @returns {Promise<void>} - Resolves after the renewal attempt.\n   */\n  async renewHold(name) {\n    const hold = this.holdsByName.get(name)\n\n    if (!hold) return\n\n    const owner = await this.readOwner(this.lockPathFor(name))\n\n    if (!owner || owner.holderId !== this.holderId) {\n      this.clearHold(name)\n      return\n    }\n\n    await this.writeOwner(this.lockPathFor(name))\n  }\n\n  /**\n   * Clears the renewal timer for one hold.\n   * @param {string} name - Lock name.\n   * @returns {void}\n   */\n  clearHold(name) {\n    const hold = this.holdsByName.get(name)\n\n    if (!hold) return\n\n    clearInterval(hold.timer)\n    this.holdsByName.delete(name)\n  }\n\n  /**\n   * Writes owner + lease metadata into a lock directory.\n   * @param {string} lockDirPath - Lock directory to write metadata into.\n   * @returns {Promise<void>} - Resolves after metadata is written.\n   */\n  async writeOwner(lockDirPath) {\n    /** @type {AdvisoryLockFileOwner} */\n    const owner = {\n      acquiredAt: new Date().toISOString(),\n      holderId: this.holderId,\n      hostname: os.hostname(),\n      leaseExpiresAt: new Date(Date.now() + this.leaseMs).toISOString(),\n      pid: process.pid,\n      ...this.extraOwnerFields\n    }\n\n    await fs.writeFile(path.join(lockDirPath, \"owner.json\"), JSON.stringify(owner))\n  }\n\n  /**\n   * Reads owner metadata from a lock directory.\n   * @param {string} lockPath - Lock directory path.\n   * @returns {Promise<AdvisoryLockFileOwner | null>} - Parsed owner metadata, when readable.\n   */\n  async readOwner(lockPath) {\n    /** @type {string} */\n    let rawOwner\n\n    try {\n      rawOwner = await fs.readFile(path.join(lockPath, \"owner.json\"), \"utf8\")\n    } catch {\n      return null\n    }\n\n    try {\n      return /** @type {AdvisoryLockFileOwner} */ (JSON.parse(rawOwner))\n    } catch {\n      return null\n    }\n  }\n\n  /**\n   * A lock directory is stale when its metadata is unreadable, its lease has\n   * expired, or its owner is a dead process on this host. Cross-host owners\n   * are only reclaimable via lease expiry — PID probing is unreliable beyond\n   * one host, which is exactly why this tier is the opt-in single-host last\n   * resort (design §4/§8).\n   * @param {string} lockPath - Lock directory path.\n   * @returns {Promise<boolean>} - Whether the lock can be reclaimed.\n   */\n  async isStale(lockPath) {\n    const owner = await this.readOwner(lockPath)\n\n    if (!owner || typeof owner.pid !== \"number\") return true\n\n    if (owner.leaseExpiresAt && new Date(owner.leaseExpiresAt).getTime() <= Date.now()) return true\n\n    if (owner.hostname && owner.hostname !== os.hostname()) return false\n\n    try {\n      // `kill(pid, 0)` is a no-op signal that fails with ESRCH when the\n      // process is gone; permission errors still prove the process exists.\n      process.kill(owner.pid, 0)\n\n      return false\n    } catch (error) {\n      return /** @type {Error & {code?: string}} */ (error).code === \"ESRCH\"\n    }\n  }\n}\n"]}

package/build/src/database/advisory-lock-runner.d.ts

@@ -1,3 +1,36 @@
+export type AdvisoryLockBackendProvenance = {
+    /**
+     * - Tier that served the acquisition.
+     */
+    backend: import("./advisory-lock-backend-policy.js").AdvisoryLockTier;
+    /**
+     * - Database driver type when the driver tier served it.
+     */
+    driverType?: string;
+    /**
+     * - Whether this tier carries fencing tokens (design §8); the file tier reports false rather than pretending.
+     */
+    fencingSupported: boolean;
+    /**
+     * - Backend holder id for the file tier.
+     */
+    holderId?: string;
+    /**
+     * - Lock name this provenance belongs to.
+     */
+    lockName?: string;
+};
+/**
+ * Provenance of one advisory-lock acquisition (STC-210 design §3): every
+ * held lock reports the tier that actually served it, so a fallback is
+ * visible to the callback, in logs, and in `getAdvisoryLockBackendStatus()`.
+ * @typedef {object} AdvisoryLockBackendProvenance
+ * @property {import("./advisory-lock-backend-policy.js").AdvisoryLockTier} backend - Tier that served the acquisition.
+ * @property {string} [driverType] - Database driver type when the driver tier served it.
+ * @property {boolean} fencingSupported - Whether this tier carries fencing tokens (design §8); the file tier reports false rather than pretending.
+ * @property {string} [holderId] - Backend holder id for the file tier.
+ * @property {string} [lockName] - Lock name this provenance belongs to.
+ */
 /**
  * Thrown when an advisory lock could not be acquired before `timeoutMs` elapsed.
  */
@@ -69,12 +102,13 @@ export default class AdvisoryLockRunner {
      * cleanup can release the lock even if callback database work is stuck.
      * @template T
      * @param {string} name - Lock name.
-     * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {(args?: {control?: import("awaitery/build/timeout.js").TimeoutControl, lockBackend: AdvisoryLockBackendProvenance}) => Promise<T>} callback - Callback to invoke while the lock is held.
      * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null, dedicatedConnection?: boolean}} [args] - Lock and hold timeout options.
      * @returns {Promise<T>} - Resolves with the callback result.
      */
     withAdvisoryLock<T>(name: string, callback: (args?: {
-        control: import("awaitery/build/timeout.js").TimeoutControl;
+        control?: import("awaitery/build/timeout.js").TimeoutControl;
+        lockBackend: AdvisoryLockBackendProvenance;
     }) => Promise<T>, args?: {
         timeoutMs?: number | null;
         holdTimeoutMs?: number | null;
@@ -89,16 +123,18 @@ export default class AdvisoryLockRunner {
      * cancellation.
      * @template T
      * @param {string} name - Lock name.
-     * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {(args?: {control?: import("awaitery/build/timeout.js").TimeoutControl, lockBackend: AdvisoryLockBackendProvenance}) => Promise<T>} callback - Callback to invoke while the lock is held.
      * @param {{holdTimeoutMs?: number | null, dedicatedConnection?: boolean}} [args] - Hold timeout options.
      * @returns {Promise<T>} - Resolves with the callback result.
      */
     withAdvisoryLockOrFail<T>(name: string, callback: (args?: {
-        control: import("awaitery/build/timeout.js").TimeoutControl;
+        control?: import("awaitery/build/timeout.js").TimeoutControl;
+        lockBackend: AdvisoryLockBackendProvenance;
     }) => Promise<T>, args?: {
         holdTimeoutMs?: number | null;
         dedicatedConnection?: boolean;
     }): Promise<T>;
+    /**
     /**
      * Runs a callback if the advisory lock can be acquired without waiting;
      * otherwise returns a `{acquired: false}` defer result instead of throwing.
@@ -114,12 +150,13 @@ export default class AdvisoryLockRunner {
      * file lock), so a caller never branches on the backend.
      * @template T
      * @param {string} name - Lock name.
-     * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {(args?: {control?: import("awaitery/build/timeout.js").TimeoutControl, lockBackend: AdvisoryLockBackendProvenance}) => Promise<T>} callback - Callback to invoke while the lock is held.
      * @param {{holdTimeoutMs?: number | null, dedicatedConnection?: boolean}} [args] - Hold timeout options.
      * @returns {Promise<{acquired: true, result: T} | {acquired: false, reason: "contended", lockName: string}>} - Either the held-callback result or the defer outcome.
      */
     withAdvisoryLockOrDefer<T>(name: string, callback: (args?: {
-        control: import("awaitery/build/timeout.js").TimeoutControl;
+        control?: import("awaitery/build/timeout.js").TimeoutControl;
+        lockBackend: AdvisoryLockBackendProvenance;
     }) => Promise<T>, args?: {
         holdTimeoutMs?: number | null;
         dedicatedConnection?: boolean;
@@ -132,19 +169,73 @@ export default class AdvisoryLockRunner {
         lockName: string;
     }>;
     /**
-     * Runs the lock holder callback and releases the lock from its owning connection.
+     * Runs the lock holder callback and releases the lock from its owning backend.
      * @template T
-     * @param {{callback: (args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>, connection: import("./drivers/base.js").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.
+     * @param {{callback: (args?: {control?: import("awaitery/build/timeout.js").TimeoutControl, lockBackend: AdvisoryLockBackendProvenance}) => Promise<T>, holdTimeoutMs?: number | null, lockBackend: AdvisoryLockBackendProvenance, name: string, release: () => Promise<unknown>}} args - Locked callback args.
      * @returns {Promise<T>} - Resolves with the callback result.
      */
-    runLockedCallback<T>({ callback, connection, holdTimeoutMs, name }: {
+    runLockedCallback<T>({ callback, holdTimeoutMs, lockBackend, name, release }: {
         callback: (args?: {
-            control: import("awaitery/build/timeout.js").TimeoutControl;
+            control?: import("awaitery/build/timeout.js").TimeoutControl;
+            lockBackend: AdvisoryLockBackendProvenance;
         }) => Promise<T>;
-        connection: import("./drivers/base.js").default;
         holdTimeoutMs?: number | null;
+        lockBackend: AdvisoryLockBackendProvenance;
         name: string;
+        release: () => Promise<unknown>;
     }): Promise<T>;
+    /**
+     * Resolves the backend policy for one lock name and returns the file
+     * backend when the name explicitly opts into the file tier
+     * (`preferredTier: "file"` plus `advisoryLocks.backends.file.enabled: true`).
+     * A name whose declared minimum tier is cross-host is refused loudly
+     * (`AdvisoryLockMinTierRefusedError`) before any contact with the file
+     * tier. A name that prefers the file tier while the backend is disabled
+     * moves to the driver path (a stronger-or-equal tier), never the other way
+     * around. Nothing here ever auto-enables the file tier.
+     * @param {string} name - Lock name.
+     * @returns {Promise<import("./advisory-lock-file-backend.js").default | null>} - Resolves with the file backend serving this name, or null for the driver path.
+     */
+    fileBackendForName(name: string): Promise<import("./advisory-lock-file-backend.js").default | null>;
+    /**
+     * Fail-closed check on the driver path (design §9): an undeclared lock name
+     * keeps today's behavior (any driver serves it — full backward
+     * compatibility), but a name with an explicit policy entry is refused with
+     * `AdvisoryLockBackendUnavailableError` when the configured driver cannot
+     * satisfy its minimum tier (e.g. `minTier: "driver-native"` on a SQLite
+     * driver, which has no native advisory-lock primitive).
+     * @param {string} name - Lock name.
+     * @param {AdvisoryLockBackendProvenance} lockBackend - Tier the driver path would serve with.
+     * @returns {void}
+     */
+    assertDriverTierEligible(name: string, lockBackend: AdvisoryLockBackendProvenance): void;
+    /**
+     * Resolves the wait bound for a file-tier acquisition: an explicit caller
+     * `timeoutMs` (including an explicit `null` opt-out) wins, otherwise the
+     * same framework default that bounds driver acquisitions applies.
+     * @param {{timeoutMs?: number | null}} args - Lock options.
+     * @returns {number | null} - Wait bound in milliseconds, or `null` for an indefinite wait.
+     */
+    fileAcquireTimeoutMs(args: {
+        timeoutMs?: number | null;
+    }): number | null;
+    /**
+     * Builds the acquisition provenance for a file-tier hold. The file tier
+     * cannot carry fencing tokens, so the limitation is reported on every
+     * acquisition rather than silently pretended away (design §8).
+     * @param {import("./advisory-lock-file-backend.js").default} backend - Backend that served the acquisition.
+     * @param {string} name - Lock name.
+     * @returns {AdvisoryLockBackendProvenance} - Acquisition provenance.
+     */
+    fileProvenance(backend: import("./advisory-lock-file-backend.js").default, name: string): AdvisoryLockBackendProvenance;
+    /**
+     * Builds the acquisition provenance for a driver-served hold. SQLite has no
+     * native advisory-lock primitive, so its emulation tier is reported as
+     * `process-local` rather than pretending to be database-native.
+     * @param {import("./drivers/base.js").default} connection - Connection that served the acquisition.
+     * @returns {AdvisoryLockBackendProvenance} - Acquisition provenance.
+     */
+    driverProvenance(connection: import("./drivers/base.js").default): AdvisoryLockBackendProvenance;
     /**
      * Runs lock work on the caller connection unless `dedicatedConnection` is
      * requested or a positive hold timeout needs its own lock connection.
@@ -172,16 +263,26 @@ export default class AdvisoryLockRunner {
      *
      * The callback receives a `TimeoutControl` from awaitery, enabling cooperative
      * cancellation via `control.check()`, `control.signal`, `control.timedOut`,
-     * and `control.remaining()`.
+     * and `control.remaining()`, plus `lockBackend` provenance for the tier that
+     * served the acquisition.
      * @template T
      * @param {string} name - Lock name (for the error message).
-     * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback holding the lock.
+     * @param {(args?: {control?: import("awaitery/build/timeout.js").TimeoutControl, lockBackend: AdvisoryLockBackendProvenance}) => Promise<T>} callback - Callback holding the lock.
      * @param {number | null} [holdTimeoutMs] - Max hold time; falsy disables the timeout.
+     * @param {AdvisoryLockBackendProvenance} [lockBackend] - Provenance of the acquisition serving this hold.
      * @returns {Promise<T>} - Resolves with the callback result.
      */
     static runWithAdvisoryLockHoldTimeout<T>(name: string, callback: (args?: {
-        control: import("awaitery/build/timeout.js").TimeoutControl;
-    }) => Promise<T>, holdTimeoutMs?: number | null): Promise<T>;
+        control?: import("awaitery/build/timeout.js").TimeoutControl;
+        lockBackend: AdvisoryLockBackendProvenance;
+    }) => Promise<T>, holdTimeoutMs?: number | null, lockBackend?: AdvisoryLockBackendProvenance): Promise<T>;
+    /**
+     * Neutral provenance for direct `runWithAdvisoryLockHoldTimeout` callers that
+     * hold a lock acquired outside this runner.
+     * @returns {AdvisoryLockBackendProvenance} - Provenance with an unknown tier.
+     */
+    static unknownBackendProvenance(): AdvisoryLockBackendProvenance;
 }
 export { AdvisoryLockBusyError, AdvisoryLockHoldTimeoutError, AdvisoryLockTimeoutError };
+export { AdvisoryLockBackendUnavailableError, AdvisoryLockMinTierRefusedError } from "./advisory-lock-backend-policy.js";
 //# sourceMappingURL=advisory-lock-runner.d.ts.map

package/build/src/database/advisory-lock-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"advisory-lock-runner.d.ts","sourceRoot":"","sources":["../../../src/database/advisory-lock-runner.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"advisory-lock-runner.d.ts","sourceRoot":"","sources":["../../../src/database/advisory-lock-runner.js"],"names":[],"mappings":"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"}