velocious 1.0.699 → 1.0.700

package/build/src/database/advisory-lock-backend-policy.d.ts

@@ -0,0 +1,145 @@
+export type AdvisoryLockTier = "process-local" | "file" | "driver-native" | "lock-server";
+export type AdvisoryLockBackendPolicyEntry = {
+    /**
+     * - Lock name or `*`-suffixed glob pattern (e.g. `background_jobs:*`).
+     */
+    name: string;
+    /**
+     * - Weakest tier this name may ever be served by. Defaults to `driver-native` (default-deny).
+     */
+    minTier?: AdvisoryLockTier;
+    /**
+     * - Explicit whitelist of servable tiers. Defaults to every tier at or above `minTier`.
+     */
+    allowedTiers?: AdvisoryLockTier[];
+    /**
+     * - Tier used when available; falling below it triggers the fallback report (§3). Defaults to `driver-native`.
+     */
+    preferredTier?: AdvisoryLockTier;
+};
+export type ResolvedAdvisoryLockBackendPolicy = {
+    /**
+     * - Weakest tier this name may be served by.
+     */
+    minTier: AdvisoryLockTier;
+    /**
+     * - Tiers that may serve this name (minimum-closed).
+     */
+    allowedTiers: AdvisoryLockTier[];
+    /**
+     * - Tier preferred when available.
+     */
+    preferredTier: AdvisoryLockTier;
+    /**
+     * - The matched configuration entry, or null for the default policy.
+     */
+    entry: AdvisoryLockBackendPolicyEntry | null;
+};
+/**
+ * Advisory-lock backend tiers (STC-210 design, `docs/advisory-lock-backends.md` §1/§9).
+ * `process-local` and `file` are host-local; `driver-native` and `lock-server` are
+ * cross-host. Tier strength order (strongest first):
+ * `lock-server` ≡ `driver-native` > `file` > `process-local`.
+ * @typedef {"process-local" | "file" | "driver-native" | "lock-server"} AdvisoryLockTier
+ */
+/**
+ * One per-lock-name backend policy entry as declared in configuration (§5).
+ * @typedef {object} AdvisoryLockBackendPolicyEntry
+ * @property {string} name - Lock name or `*`-suffixed glob pattern (e.g. `background_jobs:*`).
+ * @property {AdvisoryLockTier} [minTier] - Weakest tier this name may ever be served by. Defaults to `driver-native` (default-deny).
+ * @property {AdvisoryLockTier[]} [allowedTiers] - Explicit whitelist of servable tiers. Defaults to every tier at or above `minTier`.
+ * @property {AdvisoryLockTier} [preferredTier] - Tier used when available; falling below it triggers the fallback report (§3). Defaults to `driver-native`.
+ */
+/**
+ * Policy resolved for one concrete lock name, with tier gaps already closed:
+ * `allowedTiers` always contains every tier at or above `minTier`, so a
+ * cross-host-minimum name can never be served by `file` or `process-local`.
+ * @typedef {object} ResolvedAdvisoryLockBackendPolicy
+ * @property {AdvisoryLockTier} minTier - Weakest tier this name may be served by.
+ * @property {AdvisoryLockTier[]} allowedTiers - Tiers that may serve this name (minimum-closed).
+ * @property {AdvisoryLockTier} preferredTier - Tier preferred when available.
+ * @property {AdvisoryLockBackendPolicyEntry | null} entry - The matched configuration entry, or null for the default policy.
+ */
+/**
+ * Thrown when an acquisition would have to be served by a tier below the
+ * lock name's declared minimum tier. Fail-closed refusal (§9): the name is
+ * never served by the weaker tier, and the refusal is reported on the
+ * framework-error channel as `advisory-lock-min-tier-refused`.
+ */
+export declare class AdvisoryLockMinTierRefusedError extends Error {
+    lockName: string;
+    requestedBackend: AdvisoryLockTier;
+    minTier: AdvisoryLockTier;
+    /**
+     * Runs constructor.
+     * @param {string} message - Error message.
+     * @param {{lockName: string, requestedBackend: AdvisoryLockTier, minTier: AdvisoryLockTier}} args - Refusal details.
+     */
+    constructor(message: string, { lockName, requestedBackend, minTier }: {
+        lockName: string;
+        requestedBackend: AdvisoryLockTier;
+        minTier: AdvisoryLockTier;
+    });
+}
+/**
+ * Thrown when no enabled backend that satisfies the lock name's minimum tier
+ * is available (§9). Distinct from `AdvisoryLockTimeoutError` (a backend
+ * served the wait but the holder never released).
+ */
+export declare class AdvisoryLockBackendUnavailableError extends Error {
+    lockName: string;
+    minTier: AdvisoryLockTier;
+    reasons: string[];
+    /**
+     * Runs constructor.
+     * @param {string} message - Error message.
+     * @param {{lockName: string, minTier: AdvisoryLockTier, reasons: string[]}} args - Unavailability details.
+     */
+    constructor(message: string, { lockName, minTier, reasons }: {
+        lockName: string;
+        minTier: AdvisoryLockTier;
+        reasons: string[];
+    });
+}
+/**
+ * Runs tier rank.
+ * @param {AdvisoryLockTier} tier - Tier to rank.
+ * @returns {number} - Strength rank (higher is stronger).
+ */
+export declare function advisoryLockTierRank(tier: AdvisoryLockTier): number;
+/**
+ * Runs tier is at least as strong as.
+ * @param {AdvisoryLockTier} tier - Candidate serving tier.
+ * @param {AdvisoryLockTier} minimum - Required minimum tier.
+ * @returns {boolean} - Whether `tier` satisfies the minimum.
+ */
+export declare function advisoryLockTierSatisfies(tier: AdvisoryLockTier, minimum: AdvisoryLockTier): boolean;
+/**
+ * Resolves the effective backend policy for one concrete lock name:
+ * longest-prefix glob match over the configured entries (exact names win),
+ * default-deny for undeclared names (`minTier: driver-native`,
+ * `preferredTier: driver-native`), and `allowedTiers` closed upward so a
+ * cross-host minimum can never be served by a host-local tier.
+ * @param {string} lockName - Concrete lock name.
+ * @param {AdvisoryLockBackendPolicyEntry[] | undefined} policy - Configured policy entries.
+ * @returns {ResolvedAdvisoryLockBackendPolicy} - Resolved policy.
+ */
+export declare function resolveAdvisoryLockBackendPolicy(lockName: string, policy: AdvisoryLockBackendPolicyEntry[] | undefined): ResolvedAdvisoryLockBackendPolicy;
+/**
+ * Refuses a downgrade below the lock name's minimum tier before any contact
+ * with the weaker backend (§9), reporting the refusal on the framework-error
+ * channel so a silent downgrade is impossible to hide.
+ * @param {object} args - Refusal args.
+ * @param {import("../configuration.js").default} args.configuration - Configuration owning the error channel.
+ * @param {string} args.lockName - Lock name.
+ * @param {AdvisoryLockTier} args.requestedBackend - Tier the acquisition would fall to.
+ * @param {AdvisoryLockTier} args.minTier - Declared minimum tier.
+ * @returns {never} - Always throws.
+ */
+export declare function refuseAdvisoryLockTierBelowMinimum({ configuration, lockName, requestedBackend, minTier }: {
+    configuration: import("../configuration.js").default;
+    lockName: string;
+    requestedBackend: AdvisoryLockTier;
+    minTier: AdvisoryLockTier;
+}): never;
+//# sourceMappingURL=advisory-lock-backend-policy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"advisory-lock-backend-policy.d.ts","sourceRoot":"","sources":["../../../src/database/advisory-lock-backend-policy.js"],"names":[],"mappings":"AAOG,YAAsE,gBAAgB,GAA5E,eAAe,GAAG,MAAM,GAAG,eAAe,GAAG,aAAa,CAAkB;AAItF,YAAkB,8BAA8B,GAChD;;;;IAAmB,IAAI,EAAZ,MAAM,CACjB;;;;IAA8B,OAAO,AAArC,CACA,EADW,gBAAgB,CAC3B;;;;IAAgC,YAAY,AAA5C,CACA,EADW,gBAAgB,EAAE,CAC7B;;;;IAA8B,aAAa,AAA3C,CACF,EADa,gBAAgB,CAC7B;CAAA,CAAA;AAKE,YAAkB,iCAAiC,GACnD;;;;IAA6B,OAAO,EAAzB,gBAAgB,CAC3B;;;;IAA+B,YAAY,EAAhC,gBAAgB,EAAE,CAC7B;;;;IAA6B,aAAa,EAA/B,gBAAgB,CAC3B;;;;IAAkD,KAAK,EAA5C,8BAA8B,GAAG,IAAI,CAClD;CAAA,CAAA;AAxBD;;;;;;GAMG;AACH;;;;;;;GAOG;AACH;;;;;;;;;GASG;AAEH;;;;;GAKG;AACH,qBAAa,+BAAgC,SAAQ,KAAK;IASjD,QAAQ;IACR,gBAAgB;IAChB,OAAO;IAVd;;;;OAIG;IACH,YAAY,OAAO,EAHR,MAGQ,EAAE,EAAC,QAAQ,EAAE,gBAAgB,EAAE,OAAO,EAAC,EAF/C;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,gBAAgB,CAAC;QAAC,OAAO,EAAE,gBAAgB,CAAA;KAEjC,EAMzD;CACF;AAED;;;;GAIG;AACH,qBAAa,mCAAoC,SAAQ,KAAK;IASrD,QAAQ;IACR,OAAO;IACP,OAAO;IAVd;;;;OAIG;IACH,YAAY,OAAO,EAHR,MAGQ,EAAE,EAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAC,EAFtC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,gBAAgB,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAEzB,EAMhD;CACF;AAgBD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAH9B,gBAG8B,GAF5B,MAAM,CAQlB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAJnC,gBAImC,EAAE,OAAO,EAH5C,gBAG4C,GAF1C,OAAO,CAInB;AAED;;;;;;;;;GASG;AACH,wBAAgB,gCAAgC,CAAC,QAAQ,EAJ9C,MAI8C,EAAE,MAAM,EAHtD,8BAA8B,EAAE,GAAG,SAGmB,GAFpD,iCAAiC,CAsB7C;AAiCD;;;;;;;;;;GAUG;AACH,wBAAgB,kCAAkC,CAAC,EAAC,aAAa,EAAE,QAAQ,EAAE,gBAAgB,EAAE,OAAO,EAAC,EANpG;IAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO,CAC7C;IAAqB,QAAQ,EAArB,MAAM,CACd;IAA+B,gBAAgB,EAAvC,gBAAgB,CACxB;IAA+B,OAAO,EAA9B,gBAAgB,CACxB;CAEoG,GAF1F,KAAK,CAyBjB"}

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

@@ -0,0 +1,184 @@
+// @ts-check
+/**
+ * Advisory-lock backend tiers (STC-210 design, `docs/advisory-lock-backends.md` §1/§9).
+ * `process-local` and `file` are host-local; `driver-native` and `lock-server` are
+ * cross-host. Tier strength order (strongest first):
+ * `lock-server` ≡ `driver-native` > `file` > `process-local`.
+ * @typedef {"process-local" | "file" | "driver-native" | "lock-server"} AdvisoryLockTier
+ */
+/**
+ * One per-lock-name backend policy entry as declared in configuration (§5).
+ * @typedef {object} AdvisoryLockBackendPolicyEntry
+ * @property {string} name - Lock name or `*`-suffixed glob pattern (e.g. `background_jobs:*`).
+ * @property {AdvisoryLockTier} [minTier] - Weakest tier this name may ever be served by. Defaults to `driver-native` (default-deny).
+ * @property {AdvisoryLockTier[]} [allowedTiers] - Explicit whitelist of servable tiers. Defaults to every tier at or above `minTier`.
+ * @property {AdvisoryLockTier} [preferredTier] - Tier used when available; falling below it triggers the fallback report (§3). Defaults to `driver-native`.
+ */
+/**
+ * Policy resolved for one concrete lock name, with tier gaps already closed:
+ * `allowedTiers` always contains every tier at or above `minTier`, so a
+ * cross-host-minimum name can never be served by `file` or `process-local`.
+ * @typedef {object} ResolvedAdvisoryLockBackendPolicy
+ * @property {AdvisoryLockTier} minTier - Weakest tier this name may be served by.
+ * @property {AdvisoryLockTier[]} allowedTiers - Tiers that may serve this name (minimum-closed).
+ * @property {AdvisoryLockTier} preferredTier - Tier preferred when available.
+ * @property {AdvisoryLockBackendPolicyEntry | null} entry - The matched configuration entry, or null for the default policy.
+ */
+/**
+ * Thrown when an acquisition would have to be served by a tier below the
+ * lock name's declared minimum tier. Fail-closed refusal (§9): the name is
+ * never served by the weaker tier, and the refusal is reported on the
+ * framework-error channel as `advisory-lock-min-tier-refused`.
+ */
+export class AdvisoryLockMinTierRefusedError extends Error {
+    /**
+     * Runs constructor.
+     * @param {string} message - Error message.
+     * @param {{lockName: string, requestedBackend: AdvisoryLockTier, minTier: AdvisoryLockTier}} args - Refusal details.
+     */
+    constructor(message, { lockName, requestedBackend, minTier }) {
+        super(message);
+        this.name = "AdvisoryLockMinTierRefusedError";
+        this.lockName = lockName;
+        this.requestedBackend = requestedBackend;
+        this.minTier = minTier;
+    }
+}
+/**
+ * Thrown when no enabled backend that satisfies the lock name's minimum tier
+ * is available (§9). Distinct from `AdvisoryLockTimeoutError` (a backend
+ * served the wait but the holder never released).
+ */
+export class AdvisoryLockBackendUnavailableError extends Error {
+    /**
+     * Runs constructor.
+     * @param {string} message - Error message.
+     * @param {{lockName: string, minTier: AdvisoryLockTier, reasons: string[]}} args - Unavailability details.
+     */
+    constructor(message, { lockName, minTier, reasons }) {
+        super(message);
+        this.name = "AdvisoryLockBackendUnavailableError";
+        this.lockName = lockName;
+        this.minTier = minTier;
+        this.reasons = reasons;
+    }
+}
+/**
+ * Tier strength ranks (§9): higher rank is stronger. `lock-server` and
+ * `driver-native` are both cross-host and rank equal.
+ * @type {Record<AdvisoryLockTier, number>} */
+const TIER_RANKS = {
+    "driver-native": 2,
+    file: 1,
+    "lock-server": 3,
+    "process-local": 0
+};
+/** All tiers ordered strongest-first. */
+const TIERS_STRONGEST_FIRST = /** @type {AdvisoryLockTier[]} */ (["lock-server", "driver-native", "file", "process-local"]);
+/**
+ * Runs tier rank.
+ * @param {AdvisoryLockTier} tier - Tier to rank.
+ * @returns {number} - Strength rank (higher is stronger).
+ */
+export function advisoryLockTierRank(tier) {
+    const rank = TIER_RANKS[tier];
+    if (rank === undefined)
+        throw new Error(`Unknown advisory-lock tier ${JSON.stringify(String(tier))}`);
+    return rank;
+}
+/**
+ * Runs tier is at least as strong as.
+ * @param {AdvisoryLockTier} tier - Candidate serving tier.
+ * @param {AdvisoryLockTier} minimum - Required minimum tier.
+ * @returns {boolean} - Whether `tier` satisfies the minimum.
+ */
+export function advisoryLockTierSatisfies(tier, minimum) {
+    return advisoryLockTierRank(tier) >= advisoryLockTierRank(minimum);
+}
+/**
+ * Resolves the effective backend policy for one concrete lock name:
+ * longest-prefix glob match over the configured entries (exact names win),
+ * default-deny for undeclared names (`minTier: driver-native`,
+ * `preferredTier: driver-native`), and `allowedTiers` closed upward so a
+ * cross-host minimum can never be served by a host-local tier.
+ * @param {string} lockName - Concrete lock name.
+ * @param {AdvisoryLockBackendPolicyEntry[] | undefined} policy - Configured policy entries.
+ * @returns {ResolvedAdvisoryLockBackendPolicy} - Resolved policy.
+ */
+export function resolveAdvisoryLockBackendPolicy(lockName, policy) {
+    const entry = matchAdvisoryLockPolicyEntry(lockName, policy);
+    const minTier = entry?.minTier ?? "driver-native";
+    const preferredTier = entry?.preferredTier ?? "driver-native";
+    // §9: eligibility filters to tier strength >= minTier even when a weaker
+    // tier was declared in `allowedTiers` — a cross-host minimum can never be
+    // served by `file` or `process-local`. A `preferredTier` below the minimum
+    // stays visible here so the runner can refuse it loudly before contacting
+    // the weaker backend.
+    const declaredAllowed = entry?.allowedTiers;
+    const allowedTiers = TIERS_STRONGEST_FIRST.filter((tier) => {
+        if (!advisoryLockTierSatisfies(tier, minTier))
+            return false;
+        if (!Array.isArray(declaredAllowed))
+            return true;
+        return declaredAllowed.includes(tier);
+    });
+    return { allowedTiers, entry: entry ?? null, minTier, preferredTier };
+}
+/**
+ * Matches one policy entry for a lock name: exact `name` matches win;
+ * otherwise the longest `*`-suffixed prefix pattern wins.
+ * @param {string} lockName - Concrete lock name.
+ * @param {AdvisoryLockBackendPolicyEntry[] | undefined} policy - Configured policy entries.
+ * @returns {AdvisoryLockBackendPolicyEntry | null} - Matched entry or null.
+ */
+function matchAdvisoryLockPolicyEntry(lockName, policy) {
+    if (!Array.isArray(policy))
+        return null;
+    let bestPrefixMatch = null;
+    let bestPrefixLength = -1;
+    for (const entry of policy) {
+        if (typeof entry?.name !== "string")
+            continue;
+        if (entry.name === lockName)
+            return entry;
+        if (entry.name.endsWith("*")) {
+            const prefix = entry.name.slice(0, -1);
+            if (lockName.startsWith(prefix) && prefix.length > bestPrefixLength) {
+                bestPrefixMatch = entry;
+                bestPrefixLength = prefix.length;
+            }
+        }
+    }
+    return bestPrefixMatch;
+}
+/**
+ * Refuses a downgrade below the lock name's minimum tier before any contact
+ * with the weaker backend (§9), reporting the refusal on the framework-error
+ * channel so a silent downgrade is impossible to hide.
+ * @param {object} args - Refusal args.
+ * @param {import("../configuration.js").default} args.configuration - Configuration owning the error channel.
+ * @param {string} args.lockName - Lock name.
+ * @param {AdvisoryLockTier} args.requestedBackend - Tier the acquisition would fall to.
+ * @param {AdvisoryLockTier} args.minTier - Declared minimum tier.
+ * @returns {never} - Always throws.
+ */
+export function refuseAdvisoryLockTierBelowMinimum({ configuration, lockName, requestedBackend, minTier }) {
+    const error = new AdvisoryLockMinTierRefusedError(`Advisory lock ${JSON.stringify(lockName)} requires minimum tier ${JSON.stringify(minTier)}; the ${JSON.stringify(requestedBackend)} tier is refused. Enable a cross-host backend or declare minTier: "file" for this lock name (single-host deployments only).`, { lockName, minTier, requestedBackend });
+    configuration.getErrorEvents().emit("framework-error", {
+        context: "advisory-lock-min-tier-refused",
+        error,
+        lockName,
+        minTier,
+        requestedBackend
+    });
+    configuration.getErrorEvents().emit("all-error", {
+        context: "advisory-lock-min-tier-refused",
+        error,
+        errorType: "framework-error",
+        lockName,
+        minTier,
+        requestedBackend
+    });
+    throw error;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advisory-lock-backend-policy.js","sourceRoot":"","sources":["../../../src/database/advisory-lock-backend-policy.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Advisory-lock backend tiers (STC-210 design, `docs/advisory-lock-backends.md` §1/§9).\n * `process-local` and `file` are host-local; `driver-native` and `lock-server` are\n * cross-host. Tier strength order (strongest first):\n * `lock-server` ≡ `driver-native` > `file` > `process-local`.\n * @typedef {\"process-local\" | \"file\" | \"driver-native\" | \"lock-server\"} AdvisoryLockTier\n */\n/**\n * One per-lock-name backend policy entry as declared in configuration (§5).\n * @typedef {object} AdvisoryLockBackendPolicyEntry\n * @property {string} name - Lock name or `*`-suffixed glob pattern (e.g. `background_jobs:*`).\n * @property {AdvisoryLockTier} [minTier] - Weakest tier this name may ever be served by. Defaults to `driver-native` (default-deny).\n * @property {AdvisoryLockTier[]} [allowedTiers] - Explicit whitelist of servable tiers. Defaults to every tier at or above `minTier`.\n * @property {AdvisoryLockTier} [preferredTier] - Tier used when available; falling below it triggers the fallback report (§3). Defaults to `driver-native`.\n */\n/**\n * Policy resolved for one concrete lock name, with tier gaps already closed:\n * `allowedTiers` always contains every tier at or above `minTier`, so a\n * cross-host-minimum name can never be served by `file` or `process-local`.\n * @typedef {object} ResolvedAdvisoryLockBackendPolicy\n * @property {AdvisoryLockTier} minTier - Weakest tier this name may be served by.\n * @property {AdvisoryLockTier[]} allowedTiers - Tiers that may serve this name (minimum-closed).\n * @property {AdvisoryLockTier} preferredTier - Tier preferred when available.\n * @property {AdvisoryLockBackendPolicyEntry | null} entry - The matched configuration entry, or null for the default policy.\n */\n\n/**\n * Thrown when an acquisition would have to be served by a tier below the\n * lock name's declared minimum tier. Fail-closed refusal (§9): the name is\n * never served by the weaker tier, and the refusal is reported on the\n * framework-error channel as `advisory-lock-min-tier-refused`.\n */\nexport class AdvisoryLockMinTierRefusedError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{lockName: string, requestedBackend: AdvisoryLockTier, minTier: AdvisoryLockTier}} args - Refusal details.\n   */\n  constructor(message, {lockName, requestedBackend, minTier}) {\n    super(message)\n    this.name = \"AdvisoryLockMinTierRefusedError\"\n    this.lockName = lockName\n    this.requestedBackend = requestedBackend\n    this.minTier = minTier\n  }\n}\n\n/**\n * Thrown when no enabled backend that satisfies the lock name's minimum tier\n * is available (§9). Distinct from `AdvisoryLockTimeoutError` (a backend\n * served the wait but the holder never released).\n */\nexport class AdvisoryLockBackendUnavailableError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{lockName: string, minTier: AdvisoryLockTier, reasons: string[]}} args - Unavailability details.\n   */\n  constructor(message, {lockName, minTier, reasons}) {\n    super(message)\n    this.name = \"AdvisoryLockBackendUnavailableError\"\n    this.lockName = lockName\n    this.minTier = minTier\n    this.reasons = reasons\n  }\n}\n\n/**\n * Tier strength ranks (§9): higher rank is stronger. `lock-server` and\n * `driver-native` are both cross-host and rank equal.\n * @type {Record<AdvisoryLockTier, number>} */\nconst TIER_RANKS = {\n  \"driver-native\": 2,\n  file: 1,\n  \"lock-server\": 3,\n  \"process-local\": 0\n}\n\n/** All tiers ordered strongest-first. */\nconst TIERS_STRONGEST_FIRST = /** @type {AdvisoryLockTier[]} */ ([\"lock-server\", \"driver-native\", \"file\", \"process-local\"])\n\n/**\n * Runs tier rank.\n * @param {AdvisoryLockTier} tier - Tier to rank.\n * @returns {number} - Strength rank (higher is stronger).\n */\nexport function advisoryLockTierRank(tier) {\n  const rank = TIER_RANKS[tier]\n\n  if (rank === undefined) throw new Error(`Unknown advisory-lock tier ${JSON.stringify(String(tier))}`)\n\n  return rank\n}\n\n/**\n * Runs tier is at least as strong as.\n * @param {AdvisoryLockTier} tier - Candidate serving tier.\n * @param {AdvisoryLockTier} minimum - Required minimum tier.\n * @returns {boolean} - Whether `tier` satisfies the minimum.\n */\nexport function advisoryLockTierSatisfies(tier, minimum) {\n  return advisoryLockTierRank(tier) >= advisoryLockTierRank(minimum)\n}\n\n/**\n * Resolves the effective backend policy for one concrete lock name:\n * longest-prefix glob match over the configured entries (exact names win),\n * default-deny for undeclared names (`minTier: driver-native`,\n * `preferredTier: driver-native`), and `allowedTiers` closed upward so a\n * cross-host minimum can never be served by a host-local tier.\n * @param {string} lockName - Concrete lock name.\n * @param {AdvisoryLockBackendPolicyEntry[] | undefined} policy - Configured policy entries.\n * @returns {ResolvedAdvisoryLockBackendPolicy} - Resolved policy.\n */\nexport function resolveAdvisoryLockBackendPolicy(lockName, policy) {\n  const entry = matchAdvisoryLockPolicyEntry(lockName, policy)\n  const minTier = entry?.minTier ?? \"driver-native\"\n  const preferredTier = entry?.preferredTier ?? \"driver-native\"\n\n  // §9: eligibility filters to tier strength >= minTier even when a weaker\n  // tier was declared in `allowedTiers` — a cross-host minimum can never be\n  // served by `file` or `process-local`. A `preferredTier` below the minimum\n  // stays visible here so the runner can refuse it loudly before contacting\n  // the weaker backend.\n  const declaredAllowed = entry?.allowedTiers\n  const allowedTiers = TIERS_STRONGEST_FIRST.filter((tier) => {\n    if (!advisoryLockTierSatisfies(tier, minTier)) return false\n\n    if (!Array.isArray(declaredAllowed)) return true\n\n    return declaredAllowed.includes(tier)\n  })\n\n  return {allowedTiers, entry: entry ?? null, minTier, preferredTier}\n}\n\n/**\n * Matches one policy entry for a lock name: exact `name` matches win;\n * otherwise the longest `*`-suffixed prefix pattern wins.\n * @param {string} lockName - Concrete lock name.\n * @param {AdvisoryLockBackendPolicyEntry[] | undefined} policy - Configured policy entries.\n * @returns {AdvisoryLockBackendPolicyEntry | null} - Matched entry or null.\n */\nfunction matchAdvisoryLockPolicyEntry(lockName, policy) {\n  if (!Array.isArray(policy)) return null\n\n  let bestPrefixMatch = null\n  let bestPrefixLength = -1\n\n  for (const entry of policy) {\n    if (typeof entry?.name !== \"string\") continue\n\n    if (entry.name === lockName) return entry\n\n    if (entry.name.endsWith(\"*\")) {\n      const prefix = entry.name.slice(0, -1)\n\n      if (lockName.startsWith(prefix) && prefix.length > bestPrefixLength) {\n        bestPrefixMatch = entry\n        bestPrefixLength = prefix.length\n      }\n    }\n  }\n\n  return bestPrefixMatch\n}\n\n/**\n * Refuses a downgrade below the lock name's minimum tier before any contact\n * with the weaker backend (§9), reporting the refusal on the framework-error\n * channel so a silent downgrade is impossible to hide.\n * @param {object} args - Refusal args.\n * @param {import(\"../configuration.js\").default} args.configuration - Configuration owning the error channel.\n * @param {string} args.lockName - Lock name.\n * @param {AdvisoryLockTier} args.requestedBackend - Tier the acquisition would fall to.\n * @param {AdvisoryLockTier} args.minTier - Declared minimum tier.\n * @returns {never} - Always throws.\n */\nexport function refuseAdvisoryLockTierBelowMinimum({configuration, lockName, requestedBackend, minTier}) {\n  const error = new AdvisoryLockMinTierRefusedError(\n    `Advisory lock ${JSON.stringify(lockName)} requires minimum tier ${JSON.stringify(minTier)}; the ${JSON.stringify(requestedBackend)} tier is refused. Enable a cross-host backend or declare minTier: \"file\" for this lock name (single-host deployments only).`,\n    {lockName, minTier, requestedBackend}\n  )\n\n  configuration.getErrorEvents().emit(\"framework-error\", {\n    context: \"advisory-lock-min-tier-refused\",\n    error,\n    lockName,\n    minTier,\n    requestedBackend\n  })\n  configuration.getErrorEvents().emit(\"all-error\", {\n    context: \"advisory-lock-min-tier-refused\",\n    error,\n    errorType: \"framework-error\",\n    lockName,\n    minTier,\n    requestedBackend\n  })\n\n  throw error\n}\n"]}

package/build/src/database/advisory-lock-file-backend.d.ts

@@ -0,0 +1,194 @@
+export type AdvisoryLockFileOwner = {
+    /**
+     * - PID of the holding process.
+     */
+    pid: number;
+    /**
+     * - Host of the holding process.
+     */
+    hostname: string;
+    /**
+     * - Unique id of the acquiring backend instance.
+     */
+    holderId: string;
+    /**
+     * - ISO timestamp of acquisition.
+     */
+    acquiredAt: string;
+    /**
+     * - ISO timestamp when the current lease expires without renewal.
+     */
+    leaseExpiresAt: string;
+    /**
+     * - Extra owner field: HTTP host (server lock only).
+     */
+    host?: string;
+    /**
+     * - Extra owner field: HTTP port (server lock only).
+     */
+    port?: number;
+};
+/**
+ * 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 {
+    directory: string;
+    extraOwnerFields: Record<string, string | number>;
+    leaseMs: number;
+    renewIntervalMs: number;
+    pathStyle: "hashed" | "plain";
+    pollIntervalMs: number;
+    holderId: string;
+    /** @type {Map<string, {timer: ReturnType<typeof setInterval>}>} */
+    holdsByName: Map<string, {
+        timer: ReturnType<typeof setInterval>;
+    }>;
+    /**
+     * 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, renewIntervalMs, pathStyle, pollIntervalMs }: {
+        directory: string;
+        extraOwnerFields?: Record<string, string | number>;
+        leaseMs?: number;
+        renewIntervalMs?: number;
+        pathStyle?: "hashed" | "plain";
+        pollIntervalMs?: number;
+    });
+    /**
+     * 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: string): string;
+    /**
+     * 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.
+     */
+    acquire(name: string, { timeoutMs }?: {
+        timeoutMs?: number | null;
+    }): Promise<boolean>;
+    /**
+     * 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.
+     */
+    tryAcquire(name: string): Promise<boolean>;
+    /**
+     * 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.
+     */
+    release(name: string): Promise<boolean>;
+    /**
+     * Runs is held.
+     * @param {string} name - Lock name.
+     * @returns {Promise<boolean>} - Whether the lock is currently held by a live, unexpired owner.
+     */
+    isHeld(name: string): Promise<boolean>;
+    /**
+     * Reads the current owner metadata for diagnostics.
+     * @param {string} name - Lock name.
+     * @returns {Promise<AdvisoryLockFileOwner | null>} - Parsed owner metadata, when a lock directory exists.
+     */
+    holderInfo(name: string): Promise<AdvisoryLockFileOwner | null>;
+    /**
+     * Releases every lock this backend instance currently holds (shutdown path).
+     * @returns {Promise<void>} - Resolves after best-effort release of all holds.
+     */
+    releaseAllHeld(): Promise<void>;
+    /**
+     * Ensures the parent lock directory exists.
+     * @returns {Promise<void>} - Resolves after the directory exists.
+     */
+    ensureDirectory(): Promise<void>;
+    /**
+     * 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.
+     */
+    publishLockDirectory(lockPath: string): Promise<boolean>;
+    /**
+     * Starts lease renewal for a freshly acquired hold.
+     * @param {string} name - Lock name.
+     * @returns {true} - Always true; the hold is now tracked.
+     */
+    startHold(name: string): 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.
+     */
+    renewHold(name: string): Promise<void>;
+    /**
+     * Clears the renewal timer for one hold.
+     * @param {string} name - Lock name.
+     * @returns {void}
+     */
+    clearHold(name: string): void;
+    /**
+     * 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.
+     */
+    writeOwner(lockDirPath: string): Promise<void>;
+    /**
+     * Reads owner metadata from a lock directory.
+     * @param {string} lockPath - Lock directory path.
+     * @returns {Promise<AdvisoryLockFileOwner | null>} - Parsed owner metadata, when readable.
+     */
+    readOwner(lockPath: string): Promise<AdvisoryLockFileOwner | 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.
+     */
+    isStale(lockPath: string): Promise<boolean>;
+}
+//# sourceMappingURL=advisory-lock-file-backend.d.ts.map

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

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