velocious 1.0.709 → 1.0.710

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

@@ -0,0 +1,474 @@
+// @ts-check
+import WebSocket from "ws";
+import VelociousWebsocketClient from "../http-client/websocket-client.js";
+import { AdvisoryLockServiceUnavailableError } from "./advisory-lock-errors.js";
+/**
+ * @typedef {object} LockServerConnectionLike
+ * @property {Promise<void>} ready - Resolves when the server accepted the 1:1 connection.
+ * @property {(body: Record<string, unknown>) => void} sendMessage - Sends one connection message.
+ * @property {() => void} [close] - Closes the connection.
+ * @typedef {object} LockServerClientLike
+ * @property {() => Promise<void>} connect - Opens the transport.
+ * @property {(type: string, args: {onMessage: (body: Record<string, unknown>) => void, params: Record<string, unknown>, timeoutMs: number}) => LockServerConnectionLike} openConnection - Opens the 1:1 connection.
+ * @property {() => Promise<void> | void} [close] - Closes the transport.
+ * @typedef {{epoch: number, name: string, timer: ReturnType<typeof setInterval>, leaseExpiresAt: number}} LockServerHold
+ * @typedef {{status: "acquired", epoch: number, leaseExpiresAt: number} | {status: "busy"} | {status: "timeout"}} LockServerAcquireResult
+ */
+/** Protocol version spoken by the centralized lock server (consens-lock v2). */
+export const LOCK_SERVER_PROTOCOL_VERSION = 2;
+/** Connection role registered on the lock server. */
+const LOCK_SERVER_CONNECTION_TYPE = "lock";
+/**
+ * Tier (b) backend: the centralized lock server (`consens-lock`, protocol v2).
+ *
+ * The server holds every lock in its own process memory, so a held lock never
+ * pins a database connection — that is the whole point of this tier. Ownership
+ * is bound to this process's connection: the server mints the `holderId`, so a
+ * client can only renew or release its own leases, and a dropped connection
+ * releases all of them immediately.
+ *
+ * Holds are leases renewed every third of the lease window. A fenced lease
+ * (the server granted the name to another holder after an expiry or partition)
+ * is recorded per lock name and surfaced by the runner as
+ * `AdvisoryLockLostError` after the critical section settles.
+ *
+ * Unavailability is cached for `reprobeCooldownMs` so a flapping server cannot
+ * turn every waiting caller into a connection attempt (design §2).
+ */
+export default class AdvisoryLockLockServerBackend {
+    /**
+     * Creates the lock-server backend. The transport is created on first use, so
+     * constructing this object never performs I/O.
+     * @param {object} args - Backend options.
+     * @param {string} [args.authToken] - Shared secret; the server fails closed without a matching token.
+     * @param {(args: {authToken: string, url: string}) => LockServerClientLike} [args.clientFactory] - Transport factory (tests inject a fake).
+     * @param {number} [args.connectTimeoutMs] - Handshake timeout.
+     * @param {number} [args.leaseMs] - Lease duration used until the server advertises its own.
+     * @param {(error: Error) => void} [args.onError] - Async error reporter.
+     * @param {number} [args.reprobeCooldownMs] - How long an unavailable server is not re-probed.
+     * @param {string} args.url - Lock-server websocket URL.
+     */
+    constructor({ authToken = "", clientFactory = defaultClientFactory, connectTimeoutMs = 3000, leaseMs = 30_000, onError, reprobeCooldownMs = 5000, url }) {
+        this.url = url;
+        this.authToken = authToken;
+        this.clientFactory = clientFactory;
+        this.connectTimeoutMs = connectTimeoutMs;
+        this.leaseMs = leaseMs;
+        this.onError = onError;
+        this.reprobeCooldownMs = reprobeCooldownMs;
+        /** @type {LockServerClientLike | null} */
+        this.client = null;
+        /** @type {LockServerConnectionLike | null} */
+        this.connection = null;
+        /** @type {Promise<void> | null} */
+        this.connectPromise = null;
+        /** @type {{reject: (error: Error) => void, resolve: () => void, timer: ReturnType<typeof setTimeout> | null} | null} */
+        this.helloWaiter = null;
+        /** @type {Map<string, {epoch: number, name: string, timer: ReturnType<typeof setInterval>, leaseExpiresAt: number}>} */
+        this.holds = new Map();
+        /** @type {Map<string, {currentEpoch: number | null, epoch: number | null}>} */
+        this.fencedHolds = new Map();
+        /** @type {Map<string, {reject: (error: Error) => void, resolve: (message: Record<string, unknown>) => void, timer: ReturnType<typeof setTimeout> | null}>} */
+        this.pending = new Map();
+        /** @type {{lastError: string | null, lastProbeAt: string | null, unavailableUntil: number}} */
+        this.status = { lastError: null, lastProbeAt: null, unavailableUntil: 0 };
+        this.requestCounter = 0;
+        this.closed = false;
+    }
+    /**
+     * Opens the connection if needed, honoring the re-probe cooldown.
+     * @param {string} lockName - Lock name, for error messages.
+     * @returns {Promise<void>} - Resolves when connected.
+     */
+    async ensureConnected(lockName) {
+        if (this.closed)
+            throw new AdvisoryLockServiceUnavailableError("Lock server backend is closed", { lockName, reason: "closed" });
+        if (this.connection)
+            return;
+        if (this.connectPromise)
+            return await this.connectPromise;
+        if (Date.now() < this.status.unavailableUntil) {
+            throw new AdvisoryLockServiceUnavailableError(`Lock server ${this.url} is marked unavailable: ${String(this.status.lastError)}`, { lockName, reason: "cooldown" });
+        }
+        this.connectPromise = this.openConnection(lockName);
+        try {
+            await this.connectPromise;
+        }
+        finally {
+            this.connectPromise = null;
+        }
+    }
+    /**
+     * Opens the transport and completes the hello handshake.
+     * @param {string} lockName - Lock name, for error messages.
+     * @returns {Promise<void>} - Resolves when the handshake completed.
+     */
+    async openConnection(lockName) {
+        this.status.lastProbeAt = new Date().toISOString();
+        try {
+            const client = this.clientFactory({ authToken: this.authToken, url: this.url });
+            this.client = client;
+            await client.connect();
+            /** @type {Promise<void>} */
+            const helloPromise = new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    reject(new AdvisoryLockServiceUnavailableError(`Lock server ${this.url} did not answer the handshake within ${this.connectTimeoutMs}ms`, { lockName, reason: "handshake-timeout" }));
+                }, this.connectTimeoutMs);
+                timer.unref?.();
+                this.helloWaiter = { reject, resolve, timer };
+            });
+            const connection = client.openConnection(LOCK_SERVER_CONNECTION_TYPE, {
+                onMessage: (body) => this.handleMessage(body),
+                params: { authToken: this.authToken, protocolVersion: LOCK_SERVER_PROTOCOL_VERSION },
+                timeoutMs: this.connectTimeoutMs
+            });
+            this.connection = connection;
+            await connection.ready;
+            await helloPromise;
+            this.status.lastError = null;
+            this.status.unavailableUntil = 0;
+        }
+        catch (error) {
+            const normalized = error instanceof Error ? error : new Error(String(error));
+            this.markUnavailable(normalized);
+            this.teardown();
+            throw new AdvisoryLockServiceUnavailableError(`Lock server ${this.url} is unavailable: ${normalized.message}`, { lockName, reason: "connect-failed" });
+        }
+    }
+    /**
+     * Waits for a lock through the server's FIFO queue.
+     * @param {string} name - Lock name.
+     * @param {{timeoutMs?: number | null}} [args] - Bounded wait; the server defaults to 30s.
+     * @returns {Promise<boolean>} - True when the lease was granted, false on timeout.
+     */
+    async acquire(name, { timeoutMs } = {}) {
+        await this.ensureConnected(name);
+        /** @type {LockServerAcquireResult} */
+        const result = /** @type {LockServerAcquireResult} */ (await this.request("acquire", {
+            name,
+            timeoutMs: typeof timeoutMs === "number" && timeoutMs > 0 ? timeoutMs : undefined
+        }, typeof timeoutMs === "number" ? timeoutMs + this.connectTimeoutMs : null));
+        if (result.status === "acquired") {
+            this.startRenewal(name, result.epoch);
+            return true;
+        }
+        if (result.status === "busy")
+            return false;
+        return false;
+    }
+    /**
+     * Takes a lock only if the server grants it immediately.
+     * @param {string} name - Lock name.
+     * @returns {Promise<boolean>} - True when granted.
+     */
+    async tryAcquire(name) {
+        await this.ensureConnected(name);
+        /** @type {LockServerAcquireResult} */
+        const result = /** @type {LockServerAcquireResult} */ (await this.request("try-acquire", { name }));
+        if (result.status !== "acquired")
+            return false;
+        this.startRenewal(name, result.epoch);
+        return true;
+    }
+    /**
+     * Releases a held lease and stops its renewal.
+     * @param {string} name - Lock name.
+     * @returns {Promise<void>} - Resolves when released (or when the transport is gone).
+     */
+    async release(name) {
+        const hold = this.holds.get(name);
+        if (!hold)
+            return;
+        this.holds.delete(name);
+        clearInterval(hold.timer);
+        if (!this.connection)
+            return;
+        try {
+            await this.request("release", { epoch: hold.epoch, name });
+        }
+        catch (error) {
+            if (!(error instanceof AdvisoryLockServiceUnavailableError))
+                throw error;
+            // The server releases every lease of a closed connection, and the lease
+            // expires otherwise; both paths reclaim the name.
+            this.reportError(error);
+        }
+    }
+    /**
+     * Releases every lease this process holds (shutdown path).
+     * @returns {Promise<void>} - Resolves when every lease was released.
+     */
+    async releaseAllHeld() {
+        for (const name of [...this.holds.keys()])
+            await this.release(name);
+    }
+    /**
+     * Runs the server's live holder list (diagnostics).
+     * @returns {Promise<Record<string, unknown>[]>} - Live holders.
+     */
+    async list() {
+        const response = await this.request("list", {});
+        const holders = response.holders;
+        return /** @type {Record<string, unknown>[]} */ (Array.isArray(holders) ? holders : []);
+    }
+    /**
+     * Runs who-holds for one name (diagnostics).
+     * @param {string} name - Lock name.
+     * @returns {Promise<Record<string, unknown> | null>} - Holder, or null.
+     */
+    async whoHolds(name) {
+        const response = await this.request("who-holds", { name });
+        const holder = response.holder;
+        return /** @type {Record<string, unknown> | null} */ (holder && typeof holder === "object" ? holder : null);
+    }
+    /**
+     * Runs the fencing epoch granted for one held lease.
+     * @param {string} name - Lock name.
+     * @returns {number | null} - Granted epoch, or null when the lease is not (or no longer) held.
+     */
+    getHoldEpoch(name) {
+        return this.holds.get(name)?.epoch ?? null;
+    }
+    /**
+     * Whether this hold was fenced or lost during its critical section.
+     * @param {string} name - Lock name.
+     * @param {number | null} epoch - Epoch the hold was granted.
+     * @returns {{currentEpoch: number | null, epoch: number | null} | null} - Fencing details when lost.
+     */
+    takeLoss(name, epoch) {
+        const loss = this.fencedHolds.get(name);
+        if (loss) {
+            this.fencedHolds.delete(name);
+            return loss;
+        }
+        const hold = this.holds.get(name);
+        if (hold && hold.epoch !== epoch)
+            return { currentEpoch: hold.epoch, epoch };
+        return null;
+    }
+    /**
+     * Reports connection state and the names currently leased through this
+     * process, for `getAdvisoryLockBackendStatus()`.
+     * @returns {{connected: boolean, lastError: string | null, lastProbeAt: string | null, leasedNames: string[]}} - Backend status for diagnostics.
+     */
+    getStatus() {
+        return {
+            connected: Boolean(this.connection),
+            lastError: this.status.lastError,
+            lastProbeAt: this.status.lastProbeAt,
+            leasedNames: [...this.holds.keys()]
+        };
+    }
+    /**
+     * Closes the backend: explicit release first, then the transport.
+     * @returns {Promise<void>} - Resolves when closed.
+     */
+    async close() {
+        this.closed = true;
+        await this.releaseAllHeld();
+        this.teardown();
+    }
+    /**
+     * Dispatches one server message.
+     * @param {Record<string, unknown>} body - Server message.
+     * @returns {void}
+     */
+    handleMessage(body) {
+        if (!body || typeof body !== "object")
+            return;
+        if (body.type === "hello-ack") {
+            const advertisedLeaseMs = Number(body.leaseMs);
+            if (Number.isFinite(advertisedLeaseMs) && advertisedLeaseMs > 0)
+                this.leaseMs = advertisedLeaseMs;
+            const helloWaiter = this.helloWaiter;
+            this.helloWaiter = null;
+            if (helloWaiter) {
+                if (helloWaiter.timer)
+                    clearTimeout(helloWaiter.timer);
+                helloWaiter.resolve();
+            }
+            return;
+        }
+        if (body.type === "lost") {
+            const name = String(body.name ?? "");
+            const hold = this.holds.get(name);
+            if (!hold)
+                return;
+            this.holds.delete(name);
+            clearInterval(hold.timer);
+            this.fencedHolds.set(name, { currentEpoch: Number(body.epoch ?? 0), epoch: hold.epoch });
+            return;
+        }
+        if (body.type !== "response" || typeof body.correlationId !== "string")
+            return;
+        const pending = this.pending.get(body.correlationId);
+        if (!pending)
+            return;
+        this.pending.delete(body.correlationId);
+        if (pending.timer)
+            clearTimeout(pending.timer);
+        if (body.status === "error") {
+            pending.reject(new Error(String(body.error || "Lock server error")));
+            return;
+        }
+        pending.resolve(body);
+    }
+    /**
+     * Sends one request and awaits its correlated response.
+     * @param {string} type - Request type.
+     * @param {Record<string, unknown>} payload - Request fields.
+     * @param {number | null} [timeoutMs] - Response timeout; null waits for the server.
+     * @returns {Promise<Record<string, unknown>>} - Response body.
+     */
+    async request(type, payload, timeoutMs = null) {
+        const connection = this.connection;
+        if (!connection) {
+            throw new AdvisoryLockServiceUnavailableError("Lock server connection is not open", { lockName: String(payload.name ?? ""), reason: "not-connected" });
+        }
+        const correlationId = `req-${++this.requestCounter}`;
+        return await new Promise((resolve, reject) => {
+            const timer = typeof timeoutMs === "number" && timeoutMs > 0
+                ? setTimeout(() => {
+                    this.pending.delete(correlationId);
+                    reject(new AdvisoryLockServiceUnavailableError(`Lock server request timed out: ${type} ${String(payload.name ?? "")}`, { lockName: String(payload.name ?? ""), reason: "request-timeout" }));
+                }, timeoutMs)
+                : null;
+            timer?.unref?.();
+            this.pending.set(correlationId, { reject, resolve, timer });
+            try {
+                connection.sendMessage({ ...payload, correlationId, type });
+            }
+            catch (error) {
+                this.pending.delete(correlationId);
+                if (timer)
+                    clearTimeout(timer);
+                this.markUnavailable(error instanceof Error ? error : new Error(String(error)));
+                reject(new AdvisoryLockServiceUnavailableError(`Lock server send failed: ${error instanceof Error ? error.message : String(error)}`, { lockName: String(payload.name ?? ""), reason: "send-failed" }));
+            }
+        });
+    }
+    /**
+     * Starts lease renewal for a granted lock.
+     * @param {string} name - Lock name.
+     * @param {number} epoch - Granted epoch.
+     * @returns {void}
+     */
+    startRenewal(name, epoch) {
+        const existing = this.holds.get(name);
+        if (existing)
+            clearInterval(existing.timer);
+        const intervalMs = Math.max(250, Math.floor(this.leaseMs / 3));
+        const timer = setInterval(() => {
+            void this.renew(name, epoch);
+        }, intervalMs);
+        timer.unref?.();
+        this.holds.set(name, { epoch, leaseExpiresAt: Date.now() + this.leaseMs, name, timer });
+    }
+    /**
+     * Renews one lease; a fenced lease is recorded for the runner to surface.
+     * @param {string} name - Lock name.
+     * @param {number} epoch - Epoch the hold believes it owns.
+     * @returns {Promise<void>} - Resolves after the renewal round-trip.
+     */
+    async renew(name, epoch) {
+        const hold = this.holds.get(name);
+        if (!hold || !this.connection)
+            return;
+        try {
+            const response = await this.request("renew", { epoch, name }, this.connectTimeoutMs * 2);
+            const status = String(response.status);
+            if (status === "renewed") {
+                hold.leaseExpiresAt = Number(response.leaseExpiresAt);
+                return;
+            }
+            if (status === "lost" || status === "not-found") {
+                this.holds.delete(name);
+                clearInterval(hold.timer);
+                this.fencedHolds.set(name, { currentEpoch: Number(response.currentEpoch ?? 0), epoch });
+            }
+        }
+        catch (error) {
+            if (!(error instanceof AdvisoryLockServiceUnavailableError))
+                throw error;
+            // A lease that cannot be renewed can no longer be proven to be ours: the
+            // server may have fenced it while the transport was failing. Recording it
+            // as lost is the only honest answer, and stops the renewal loop.
+            this.markUnavailable(error);
+            this.holds.delete(name);
+            clearInterval(hold.timer);
+            this.fencedHolds.set(name, { currentEpoch: null, epoch });
+            this.reportError(error);
+        }
+    }
+    /**
+     * Records that the lock server is unreachable and starts the re-probe cooldown.
+     * @param {Error} error - Failure.
+     * @returns {void}
+     */
+    markUnavailable(error) {
+        this.status.lastError = error.message;
+        this.status.lastProbeAt = new Date().toISOString();
+        this.status.unavailableUntil = Date.now() + this.reprobeCooldownMs;
+    }
+    /**
+     * Drops transport state and marks every outstanding hold lost.
+     * @returns {void}
+     */
+    teardown() {
+        for (const [name, hold] of this.holds) {
+            clearInterval(hold.timer);
+            this.fencedHolds.set(name, { currentEpoch: null, epoch: hold.epoch });
+        }
+        this.holds.clear();
+        for (const pending of this.pending.values()) {
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(new AdvisoryLockServiceUnavailableError("Lock server connection dropped", { lockName: "", reason: "connection-dropped" }));
+        }
+        this.pending.clear();
+        const connection = this.connection;
+        const client = this.client;
+        this.connection = null;
+        this.client = null;
+        try {
+            connection?.close?.();
+        }
+        catch (error) {
+            this.reportError(error instanceof Error ? error : new Error(String(error)));
+        }
+        try {
+            void client?.close?.();
+        }
+        catch (error) {
+            this.reportError(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Reports a transport-side failure without breaking lock handling.
+     * @param {unknown} error - Failure to report.
+     * @returns {void}
+     */
+    reportError(error) {
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        this.status.lastError = normalized.message;
+        if (this.onError)
+            this.onError(normalized);
+    }
+}
+/**
+ * Default transport factory: the framework websocket client with the Node
+ * `ws` implementation bound explicitly (no global mutation).
+ * @param {{authToken: string, url: string}} args - Connection args.
+ * @returns {LockServerClientLike} - Websocket client.
+ */
+function defaultClientFactory({ url }) {
+    // Node's global WebSocket is not guaranteed to exist, so the implementation is
+    // bound explicitly instead of mutating `globalThis`.
+    const webSocketImplementation = /** @type {typeof globalThis.WebSocket} */ ( /** @type {unknown} */(WebSocket));
+    return /** @type {LockServerClientLike} */ ( /** @type {unknown} */(new VelociousWebsocketClient({
+        heartbeatIntervalMs: 10_000,
+        url,
+        webSocketImplementation
+    })));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advisory-lock-lock-server-backend.js","sourceRoot":"","sources":["../../../src/database/advisory-lock-lock-server-backend.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,SAAS,MAAM,IAAI,CAAA;AAE1B,OAAO,wBAAwB,MAAM,oCAAoC,CAAA;AACzE,OAAO,EAAC,mCAAmC,EAAC,MAAM,2BAA2B,CAAA;AAE7E;;;;;;;;;;;GAWG;AAEH,gFAAgF;AAChF,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAA;AAE7C,qDAAqD;AACrD,MAAM,2BAA2B,GAAG,MAAM,CAAA;AAE1C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,OAAO,OAAO,6BAA6B;IAChD;;;;;;;;;;;OAWG;IACH,YAAY,EAAC,SAAS,GAAG,EAAE,EAAE,aAAa,GAAG,oBAAoB,EAAE,gBAAgB,GAAG,IAAI,EAAE,OAAO,GAAG,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,IAAI,EAAE,GAAG,EAAC;QACnJ,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;QACd,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,aAAa,GAAG,aAAa,CAAA;QAClC,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAA;QACxC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAA;QAC1C,0CAA0C;QAC1C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAA;QAClB,8CAA8C;QAC9C,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;QACtB,mCAAmC;QACnC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAA;QAC1B,wHAAwH;QACxH,IAAI,CAAC,WAAW,GAAG,IAAI,CAAA;QACvB,wHAAwH;QACxH,IAAI,CAAC,KAAK,GAAG,IAAI,GAAG,EAAE,CAAA;QACtB,+EAA+E;QAC/E,IAAI,CAAC,WAAW,GAAG,IAAI,GAAG,EAAE,CAAA;QAC5B,8JAA8J;QAC9J,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,EAAE,CAAA;QACxB,+FAA+F;QAC/F,IAAI,CAAC,MAAM,GAAG,EAAC,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,EAAC,CAAA;QACvE,IAAI,CAAC,cAAc,GAAG,CAAC,CAAA;QACvB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;IACrB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,eAAe,CAAC,QAAQ;QAC5B,IAAI,IAAI,CAAC,MAAM;YAAE,MAAM,IAAI,mCAAmC,CAAC,+BAA+B,EAAE,EAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAC,CAAC,CAAA;QAC7H,IAAI,IAAI,CAAC,UAAU;YAAE,OAAM;QAC3B,IAAI,IAAI,CAAC,cAAc;YAAE,OAAO,MAAM,IAAI,CAAC,cAAc,CAAA;QAEzD,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;YAC9C,MAAM,IAAI,mCAAmC,CAC3C,eAAe,IAAI,CAAC,GAAG,2BAA2B,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,EACjF,EAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAC,CAC/B,CAAA;QACH,CAAC;QAED,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAA;QAEnD,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,cAAc,CAAA;QAC3B,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,cAAc,GAAG,IAAI,CAAA;QAC5B,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,cAAc,CAAC,QAAQ;QAC3B,IAAI,CAAC,MAAM,CAAC,WAAW,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAA;QAElD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,EAAC,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAC,CAAC,CAAA;YAE7E,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;YACpB,MAAM,MAAM,CAAC,OAAO,EAAE,CAAA;YAEtB,4BAA4B;YAC5B,MAAM,YAAY,GAAG,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACnD,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;oBAC5B,MAAM,CAAC,IAAI,mCAAmC,CAC5C,eAAe,IAAI,CAAC,GAAG,wCAAwC,IAAI,CAAC,gBAAgB,IAAI,EACxF,EAAC,QAAQ,EAAE,MAAM,EAAE,mBAAmB,EAAC,CACxC,CAAC,CAAA;gBACJ,CAAC,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAA;gBAEzB,KAAK,CAAC,KAAK,EAAE,EAAE,CAAA;gBACf,IAAI,CAAC,WAAW,GAAG,EAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAC,CAAA;YAC7C,CAAC,CAAC,CAAA;YAEF,MAAM,UAAU,GAAG,MAAM,CAAC,cAAc,CAAC,2BAA2B,EAAE;gBACpE,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC;gBAC7C,MAAM,EAAE,EAAC,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,eAAe,EAAE,4BAA4B,EAAC;gBAClF,SAAS,EAAE,IAAI,CAAC,gBAAgB;aACjC,CAAC,CAAA;YAEF,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;YAC5B,MAAM,UAAU,CAAC,KAAK,CAAA;YACtB,MAAM,YAAY,CAAA;YAElB,IAAI,CAAC,MAAM,CAAC,SAAS,GAAG,IAAI,CAAA;YAC5B,IAAI,CAAC,MAAM,CAAC,gBAAgB,GAAG,CAAC,CAAA;QAClC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,UAAU,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;YAE5E,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAA;YAChC,IAAI,CAAC,QAAQ,EAAE,CAAA;YAEf,MAAM,IAAI,mCAAmC,CAC3C,eAAe,IAAI,CAAC,GAAG,oBAAoB,UAAU,CAAC,OAAO,EAAE,EAC/D,EAAC,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAC,CACrC,CAAA;QACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,EAAC,SAAS,EAAC,GAAG,EAAE;QAClC,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAA;QAEhC,sCAAsC;QACtC,MAAM,MAAM,GAAG,sCAAsC,CAAC,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE;YACnF,IAAI;YACJ,SAAS,EAAE,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS;SAClF,EAAE,OAAO,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAA;QAE7E,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YACjC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAA;YAErC,OAAO,IAAI,CAAA;QACb,CAAC;QAED,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM;YAAE,OAAO,KAAK,CAAA;QAE1C,OAAO,KAAK,CAAA;IACd,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,UAAU,CAAC,IAAI;QACnB,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAA;QAEhC,sCAAsC;QACtC,MAAM,MAAM,GAAG,sCAAsC,CAAC,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,EAAC,IAAI,EAAC,CAAC,CAAC,CAAA;QAEjG,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU;YAAE,OAAO,KAAK,CAAA;QAE9C,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAA;QAErC,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO,CAAC,IAAI;QAChB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAEjC,IAAI,CAAC,IAAI;YAAE,OAAM;QAEjB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QACvB,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAEzB,IAAI,CAAC,IAAI,CAAC,UAAU;YAAE,OAAM;QAE5B,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,EAAC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,EAAC,CAAC,CAAA;QAC1D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,CAAC,KAAK,YAAY,mCAAmC,CAAC;gBAAE,MAAM,KAAK,CAAA;YACxE,wEAAwE;YACxE,kDAAkD;YAClD,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAA;QACzB,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,cAAc;QAClB,KAAK,MAAM,IAAI,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;YAAE,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;IACrE,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,IAAI;QACR,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAA;QAC/C,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAA;QAEhC,OAAO,wCAAwC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;IACzF,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,QAAQ,CAAC,IAAI;QACjB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,EAAC,IAAI,EAAC,CAAC,CAAA;QACxD,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAA;QAE9B,OAAO,6CAA6C,CAAC,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;IAC7G,CAAC;IAED;;;;OAIG;IACH,YAAY,CAAC,IAAI;QACf,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,KAAK,IAAI,IAAI,CAAA;IAC5C,CAAC;IAED;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,KAAK;QAClB,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAEvC,IAAI,IAAI,EAAE,CAAC;YACT,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;YAE7B,OAAO,IAAI,CAAA;QACb,CAAC;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAEjC,IAAI,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK;YAAE,OAAO,EAAC,YAAY,EAAE,IAAI,CAAC,KAAK,EAAE,KAAK,EAAC,CAAA;QAE1E,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,SAAS;QACP,OAAO;YACL,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC;YACnC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,SAAS;YAChC,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW;YACpC,WAAW,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;SACpC,CAAA;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,CAAC,MAAM,GAAG,IAAI,CAAA;QAClB,MAAM,IAAI,CAAC,cAAc,EAAE,CAAA;QAE3B,IAAI,CAAC,QAAQ,EAAE,CAAA;IACjB,CAAC;IAED;;;;OAIG;IACH,aAAa,CAAC,IAAI;QAChB,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,OAAM;QAE7C,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;YAC9B,MAAM,iBAAiB,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;YAE9C,IAAI,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAC,IAAI,iBAAiB,GAAG,CAAC;gBAAE,IAAI,CAAC,OAAO,GAAG,iBAAiB,CAAA;YAEjG,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAA;YAEpC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAA;YACvB,IAAI,WAAW,EAAE,CAAC;gBAChB,IAAI,WAAW,CAAC,KAAK;oBAAE,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CAAA;gBACtD,WAAW,CAAC,OAAO,EAAE,CAAA;YACvB,CAAC;YAED,OAAM;QACR,CAAC;QAED,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YACzB,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC,CAAA;YACpC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;YAEjC,IAAI,CAAC,IAAI;gBAAE,OAAM;YAEjB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;YACvB,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YACzB,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,EAAC,YAAY,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAC,CAAC,CAAA;YAEtF,OAAM;QACR,CAAC;QAED,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU,IAAI,OAAO,IAAI,CAAC,aAAa,KAAK,QAAQ;YAAE,OAAM;QAE9E,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAA;QAEpD,IAAI,CAAC,OAAO;YAAE,OAAM;QAEpB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAA;QACvC,IAAI,OAAO,CAAC,KAAK;YAAE,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAE9C,IAAI,IAAI,CAAC,MAAM,KAAK,OAAO,EAAE,CAAC;YAC5B,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,IAAI,mBAAmB,CAAC,CAAC,CAAC,CAAA;YAEpE,OAAM;QACR,CAAC;QAED,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;IACvB,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,GAAG,IAAI;QAC3C,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAA;QAElC,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,mCAAmC,CAAC,oCAAoC,EAAE,EAAC,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,eAAe,EAAC,CAAC,CAAA;QACtJ,CAAC;QAED,MAAM,aAAa,GAAG,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,CAAA;QAEpD,OAAO,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC3C,MAAM,KAAK,GAAG,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,GAAG,CAAC;gBAC1D,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE;oBAChB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAA;oBAClC,MAAM,CAAC,IAAI,mCAAmC,CAC5C,kCAAkC,IAAI,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,EACtE,EAAC,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,iBAAiB,EAAC,CAClE,CAAC,CAAA;gBACJ,CAAC,EAAE,SAAS,CAAC;gBACb,CAAC,CAAC,IAAI,CAAA;YAER,KAAK,EAAE,KAAK,EAAE,EAAE,CAAA;YAChB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,EAAE,EAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAC,CAAC,CAAA;YAEzD,IAAI,CAAC;gBACH,UAAU,CAAC,WAAW,CAAC,EAAC,GAAG,OAAO,EAAE,aAAa,EAAE,IAAI,EAAC,CAAC,CAAA;YAC3D,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAA;gBAClC,IAAI,KAAK;oBAAE,YAAY,CAAC,KAAK,CAAC,CAAA;gBAC9B,IAAI,CAAC,eAAe,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;gBAC/E,MAAM,CAAC,IAAI,mCAAmC,CAC5C,4BAA4B,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,EACpF,EAAC,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,aAAa,EAAC,CAC9D,CAAC,CAAA;YACJ,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,IAAI,EAAE,KAAK;QACtB,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAErC,IAAI,QAAQ;YAAE,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;QAE3C,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAA;QAC9D,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE;YAC7B,KAAK,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;QAC9B,CAAC,EAAE,UAAU,CAAC,CAAA;QAEd,KAAK,CAAC,KAAK,EAAE,EAAE,CAAA;QACf,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,EAAC,KAAK,EAAE,cAAc,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAC,CAAC,CAAA;IACvF,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK;QACrB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAEjC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU;YAAE,OAAM;QAErC,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,EAAC,KAAK,EAAE,IAAI,EAAC,EAAE,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAA;YACtF,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;YAEtC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACzB,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAA;gBAErD,OAAM;YACR,CAAC;YAED,IAAI,MAAM,KAAK,MAAM,IAAI,MAAM,KAAK,WAAW,EAAE,CAAC;gBAChD,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;gBACvB,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;gBACzB,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,EAAC,YAAY,EAAE,MAAM,CAAC,QAAQ,CAAC,YAAY,IAAI,CAAC,CAAC,EAAE,KAAK,EAAC,CAAC,CAAA;YACvF,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,CAAC,KAAK,YAAY,mCAAmC,CAAC;gBAAE,MAAM,KAAK,CAAA;YAExE,yEAAyE;YACzE,0EAA0E;YAC1E,iEAAiE;YACjE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAA;YAC3B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;YACvB,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YACzB,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,EAAC,YAAY,EAAE,IAAI,EAAE,KAAK,EAAC,CAAC,CAAA;YACvD,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAA;QACzB,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,eAAe,CAAC,KAAK;QACnB,IAAI,CAAC,MAAM,CAAC,SAAS,GAAG,KAAK,CAAC,OAAO,CAAA;QACrC,IAAI,CAAC,MAAM,CAAC,WAAW,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAA;QAClD,IAAI,CAAC,MAAM,CAAC,gBAAgB,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,iBAAiB,CAAA;IACpE,CAAC;IAED;;;OAGG;IACH,QAAQ;QACN,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACtC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YACzB,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,EAAC,YAAY,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAC,CAAC,CAAA;QACrE,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAA;QAElB,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;YAC5C,IAAI,OAAO,CAAC,KAAK;gBAAE,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;YAC9C,OAAO,CAAC,MAAM,CAAC,IAAI,mCAAmC,CAAC,gCAAgC,EAAE,EAAC,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,oBAAoB,EAAC,CAAC,CAAC,CAAA;QACzI,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAA;QAEpB,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAA;QAClC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAA;QAE1B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAA;QAElB,IAAI,CAAC;YACH,UAAU,EAAE,KAAK,EAAE,EAAE,CAAA;QACvB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,WAAW,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QAC7E,CAAC;QAED,IAAI,CAAC;YACH,KAAK,MAAM,EAAE,KAAK,EAAE,EAAE,CAAA;QACxB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,WAAW,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QAC7E,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,WAAW,CAAC,KAAK;QACf,MAAM,UAAU,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;QAE5E,IAAI,CAAC,MAAM,CAAC,SAAS,GAAG,UAAU,CAAC,OAAO,CAAA;QAE1C,IAAI,IAAI,CAAC,OAAO;YAAE,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;IAC5C,CAAC;CACF;AAED;;;;;GAKG;AACH,SAAS,oBAAoB,CAAC,EAAC,GAAG,EAAC;IACjC,+EAA+E;IAC/E,qDAAqD;IACrD,MAAM,uBAAuB,GAAG,0CAA0C,CAAC,EAAC,sBAAuB,CAAC,SAAS,CAAC,CAAC,CAAA;IAE/G,OAAO,mCAAmC,CAAC,EAAC,sBAAuB,CAAC,IAAI,wBAAwB,CAAC;QAC/F,mBAAmB,EAAE,MAAM;QAC3B,GAAG;QACH,uBAAuB;KACxB,CAAC,CAAC,CAAC,CAAA;AACN,CAAC","sourcesContent":["// @ts-check\n\nimport WebSocket from \"ws\"\n\nimport VelociousWebsocketClient from \"../http-client/websocket-client.js\"\nimport {AdvisoryLockServiceUnavailableError} from \"./advisory-lock-errors.js\"\n\n/**\n * @typedef {object} LockServerConnectionLike\n * @property {Promise<void>} ready - Resolves when the server accepted the 1:1 connection.\n * @property {(body: Record<string, unknown>) => void} sendMessage - Sends one connection message.\n * @property {() => void} [close] - Closes the connection.\n * @typedef {object} LockServerClientLike\n * @property {() => Promise<void>} connect - Opens the transport.\n * @property {(type: string, args: {onMessage: (body: Record<string, unknown>) => void, params: Record<string, unknown>, timeoutMs: number}) => LockServerConnectionLike} openConnection - Opens the 1:1 connection.\n * @property {() => Promise<void> | void} [close] - Closes the transport.\n * @typedef {{epoch: number, name: string, timer: ReturnType<typeof setInterval>, leaseExpiresAt: number}} LockServerHold\n * @typedef {{status: \"acquired\", epoch: number, leaseExpiresAt: number} | {status: \"busy\"} | {status: \"timeout\"}} LockServerAcquireResult\n */\n\n/** Protocol version spoken by the centralized lock server (consens-lock v2). */\nexport const LOCK_SERVER_PROTOCOL_VERSION = 2\n\n/** Connection role registered on the lock server. */\nconst LOCK_SERVER_CONNECTION_TYPE = \"lock\"\n\n/**\n * Tier (b) backend: the centralized lock server (`consens-lock`, protocol v2).\n *\n * The server holds every lock in its own process memory, so a held lock never\n * pins a database connection — that is the whole point of this tier. Ownership\n * is bound to this process's connection: the server mints the `holderId`, so a\n * client can only renew or release its own leases, and a dropped connection\n * releases all of them immediately.\n *\n * Holds are leases renewed every third of the lease window. A fenced lease\n * (the server granted the name to another holder after an expiry or partition)\n * is recorded per lock name and surfaced by the runner as\n * `AdvisoryLockLostError` after the critical section settles.\n *\n * Unavailability is cached for `reprobeCooldownMs` so a flapping server cannot\n * turn every waiting caller into a connection attempt (design §2).\n */\nexport default class AdvisoryLockLockServerBackend {\n  /**\n   * Creates the lock-server backend. The transport is created on first use, so\n   * constructing this object never performs I/O.\n   * @param {object} args - Backend options.\n   * @param {string} [args.authToken] - Shared secret; the server fails closed without a matching token.\n   * @param {(args: {authToken: string, url: string}) => LockServerClientLike} [args.clientFactory] - Transport factory (tests inject a fake).\n   * @param {number} [args.connectTimeoutMs] - Handshake timeout.\n   * @param {number} [args.leaseMs] - Lease duration used until the server advertises its own.\n   * @param {(error: Error) => void} [args.onError] - Async error reporter.\n   * @param {number} [args.reprobeCooldownMs] - How long an unavailable server is not re-probed.\n   * @param {string} args.url - Lock-server websocket URL.\n   */\n  constructor({authToken = \"\", clientFactory = defaultClientFactory, connectTimeoutMs = 3000, leaseMs = 30_000, onError, reprobeCooldownMs = 5000, url}) {\n    this.url = url\n    this.authToken = authToken\n    this.clientFactory = clientFactory\n    this.connectTimeoutMs = connectTimeoutMs\n    this.leaseMs = leaseMs\n    this.onError = onError\n    this.reprobeCooldownMs = reprobeCooldownMs\n    /** @type {LockServerClientLike | null} */\n    this.client = null\n    /** @type {LockServerConnectionLike | null} */\n    this.connection = null\n    /** @type {Promise<void> | null} */\n    this.connectPromise = null\n    /** @type {{reject: (error: Error) => void, resolve: () => void, timer: ReturnType<typeof setTimeout> | null} | null} */\n    this.helloWaiter = null\n    /** @type {Map<string, {epoch: number, name: string, timer: ReturnType<typeof setInterval>, leaseExpiresAt: number}>} */\n    this.holds = new Map()\n    /** @type {Map<string, {currentEpoch: number | null, epoch: number | null}>} */\n    this.fencedHolds = new Map()\n    /** @type {Map<string, {reject: (error: Error) => void, resolve: (message: Record<string, unknown>) => void, timer: ReturnType<typeof setTimeout> | null}>} */\n    this.pending = new Map()\n    /** @type {{lastError: string | null, lastProbeAt: string | null, unavailableUntil: number}} */\n    this.status = {lastError: null, lastProbeAt: null, unavailableUntil: 0}\n    this.requestCounter = 0\n    this.closed = false\n  }\n\n  /**\n   * Opens the connection if needed, honoring the re-probe cooldown.\n   * @param {string} lockName - Lock name, for error messages.\n   * @returns {Promise<void>} - Resolves when connected.\n   */\n  async ensureConnected(lockName) {\n    if (this.closed) throw new AdvisoryLockServiceUnavailableError(\"Lock server backend is closed\", {lockName, reason: \"closed\"})\n    if (this.connection) return\n    if (this.connectPromise) return await this.connectPromise\n\n    if (Date.now() < this.status.unavailableUntil) {\n      throw new AdvisoryLockServiceUnavailableError(\n        `Lock server ${this.url} is marked unavailable: ${String(this.status.lastError)}`,\n        {lockName, reason: \"cooldown\"}\n      )\n    }\n\n    this.connectPromise = this.openConnection(lockName)\n\n    try {\n      await this.connectPromise\n    } finally {\n      this.connectPromise = null\n    }\n  }\n\n  /**\n   * Opens the transport and completes the hello handshake.\n   * @param {string} lockName - Lock name, for error messages.\n   * @returns {Promise<void>} - Resolves when the handshake completed.\n   */\n  async openConnection(lockName) {\n    this.status.lastProbeAt = new Date().toISOString()\n\n    try {\n      const client = this.clientFactory({authToken: this.authToken, url: this.url})\n\n      this.client = client\n      await client.connect()\n\n      /** @type {Promise<void>} */\n      const helloPromise = new Promise((resolve, reject) => {\n        const timer = setTimeout(() => {\n          reject(new AdvisoryLockServiceUnavailableError(\n            `Lock server ${this.url} did not answer the handshake within ${this.connectTimeoutMs}ms`,\n            {lockName, reason: \"handshake-timeout\"}\n          ))\n        }, this.connectTimeoutMs)\n\n        timer.unref?.()\n        this.helloWaiter = {reject, resolve, timer}\n      })\n\n      const connection = client.openConnection(LOCK_SERVER_CONNECTION_TYPE, {\n        onMessage: (body) => this.handleMessage(body),\n        params: {authToken: this.authToken, protocolVersion: LOCK_SERVER_PROTOCOL_VERSION},\n        timeoutMs: this.connectTimeoutMs\n      })\n\n      this.connection = connection\n      await connection.ready\n      await helloPromise\n\n      this.status.lastError = null\n      this.status.unavailableUntil = 0\n    } catch (error) {\n      const normalized = error instanceof Error ? error : new Error(String(error))\n\n      this.markUnavailable(normalized)\n      this.teardown()\n\n      throw new AdvisoryLockServiceUnavailableError(\n        `Lock server ${this.url} is unavailable: ${normalized.message}`,\n        {lockName, reason: \"connect-failed\"}\n      )\n    }\n  }\n\n  /**\n   * Waits for a lock through the server's FIFO queue.\n   * @param {string} name - Lock name.\n   * @param {{timeoutMs?: number | null}} [args] - Bounded wait; the server defaults to 30s.\n   * @returns {Promise<boolean>} - True when the lease was granted, false on timeout.\n   */\n  async acquire(name, {timeoutMs} = {}) {\n    await this.ensureConnected(name)\n\n    /** @type {LockServerAcquireResult} */\n    const result = /** @type {LockServerAcquireResult} */ (await this.request(\"acquire\", {\n      name,\n      timeoutMs: typeof timeoutMs === \"number\" && timeoutMs > 0 ? timeoutMs : undefined\n    }, typeof timeoutMs === \"number\" ? timeoutMs + this.connectTimeoutMs : null))\n\n    if (result.status === \"acquired\") {\n      this.startRenewal(name, result.epoch)\n\n      return true\n    }\n\n    if (result.status === \"busy\") return false\n\n    return false\n  }\n\n  /**\n   * Takes a lock only if the server grants it immediately.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - True when granted.\n   */\n  async tryAcquire(name) {\n    await this.ensureConnected(name)\n\n    /** @type {LockServerAcquireResult} */\n    const result = /** @type {LockServerAcquireResult} */ (await this.request(\"try-acquire\", {name}))\n\n    if (result.status !== \"acquired\") return false\n\n    this.startRenewal(name, result.epoch)\n\n    return true\n  }\n\n  /**\n   * Releases a held lease and stops its renewal.\n   * @param {string} name - Lock name.\n   * @returns {Promise<void>} - Resolves when released (or when the transport is gone).\n   */\n  async release(name) {\n    const hold = this.holds.get(name)\n\n    if (!hold) return\n\n    this.holds.delete(name)\n    clearInterval(hold.timer)\n\n    if (!this.connection) return\n\n    try {\n      await this.request(\"release\", {epoch: hold.epoch, name})\n    } catch (error) {\n      if (!(error instanceof AdvisoryLockServiceUnavailableError)) throw error\n      // The server releases every lease of a closed connection, and the lease\n      // expires otherwise; both paths reclaim the name.\n      this.reportError(error)\n    }\n  }\n\n  /**\n   * Releases every lease this process holds (shutdown path).\n   * @returns {Promise<void>} - Resolves when every lease was released.\n   */\n  async releaseAllHeld() {\n    for (const name of [...this.holds.keys()]) await this.release(name)\n  }\n\n  /**\n   * Runs the server's live holder list (diagnostics).\n   * @returns {Promise<Record<string, unknown>[]>} - Live holders.\n   */\n  async list() {\n    const response = await this.request(\"list\", {})\n    const holders = response.holders\n\n    return /** @type {Record<string, unknown>[]} */ (Array.isArray(holders) ? holders : [])\n  }\n\n  /**\n   * Runs who-holds for one name (diagnostics).\n   * @param {string} name - Lock name.\n   * @returns {Promise<Record<string, unknown> | null>} - Holder, or null.\n   */\n  async whoHolds(name) {\n    const response = await this.request(\"who-holds\", {name})\n    const holder = response.holder\n\n    return /** @type {Record<string, unknown> | null} */ (holder && typeof holder === \"object\" ? holder : null)\n  }\n\n  /**\n   * Runs the fencing epoch granted for one held lease.\n   * @param {string} name - Lock name.\n   * @returns {number | null} - Granted epoch, or null when the lease is not (or no longer) held.\n   */\n  getHoldEpoch(name) {\n    return this.holds.get(name)?.epoch ?? null\n  }\n\n  /**\n   * Whether this hold was fenced or lost during its critical section.\n   * @param {string} name - Lock name.\n   * @param {number | null} epoch - Epoch the hold was granted.\n   * @returns {{currentEpoch: number | null, epoch: number | null} | null} - Fencing details when lost.\n   */\n  takeLoss(name, epoch) {\n    const loss = this.fencedHolds.get(name)\n\n    if (loss) {\n      this.fencedHolds.delete(name)\n\n      return loss\n    }\n\n    const hold = this.holds.get(name)\n\n    if (hold && hold.epoch !== epoch) return {currentEpoch: hold.epoch, epoch}\n\n    return null\n  }\n\n  /**\n   * Reports connection state and the names currently leased through this\n   * process, for `getAdvisoryLockBackendStatus()`.\n   * @returns {{connected: boolean, lastError: string | null, lastProbeAt: string | null, leasedNames: string[]}} - Backend status for diagnostics.\n   */\n  getStatus() {\n    return {\n      connected: Boolean(this.connection),\n      lastError: this.status.lastError,\n      lastProbeAt: this.status.lastProbeAt,\n      leasedNames: [...this.holds.keys()]\n    }\n  }\n\n  /**\n   * Closes the backend: explicit release first, then the transport.\n   * @returns {Promise<void>} - Resolves when closed.\n   */\n  async close() {\n    this.closed = true\n    await this.releaseAllHeld()\n\n    this.teardown()\n  }\n\n  /**\n   * Dispatches one server message.\n   * @param {Record<string, unknown>} body - Server message.\n   * @returns {void}\n   */\n  handleMessage(body) {\n    if (!body || typeof body !== \"object\") return\n\n    if (body.type === \"hello-ack\") {\n      const advertisedLeaseMs = Number(body.leaseMs)\n\n      if (Number.isFinite(advertisedLeaseMs) && advertisedLeaseMs > 0) this.leaseMs = advertisedLeaseMs\n\n      const helloWaiter = this.helloWaiter\n\n      this.helloWaiter = null\n      if (helloWaiter) {\n        if (helloWaiter.timer) clearTimeout(helloWaiter.timer)\n        helloWaiter.resolve()\n      }\n\n      return\n    }\n\n    if (body.type === \"lost\") {\n      const name = String(body.name ?? \"\")\n      const hold = this.holds.get(name)\n\n      if (!hold) return\n\n      this.holds.delete(name)\n      clearInterval(hold.timer)\n      this.fencedHolds.set(name, {currentEpoch: Number(body.epoch ?? 0), epoch: hold.epoch})\n\n      return\n    }\n\n    if (body.type !== \"response\" || typeof body.correlationId !== \"string\") return\n\n    const pending = this.pending.get(body.correlationId)\n\n    if (!pending) return\n\n    this.pending.delete(body.correlationId)\n    if (pending.timer) clearTimeout(pending.timer)\n\n    if (body.status === \"error\") {\n      pending.reject(new Error(String(body.error || \"Lock server error\")))\n\n      return\n    }\n\n    pending.resolve(body)\n  }\n\n  /**\n   * Sends one request and awaits its correlated response.\n   * @param {string} type - Request type.\n   * @param {Record<string, unknown>} payload - Request fields.\n   * @param {number | null} [timeoutMs] - Response timeout; null waits for the server.\n   * @returns {Promise<Record<string, unknown>>} - Response body.\n   */\n  async request(type, payload, timeoutMs = null) {\n    const connection = this.connection\n\n    if (!connection) {\n      throw new AdvisoryLockServiceUnavailableError(\"Lock server connection is not open\", {lockName: String(payload.name ?? \"\"), reason: \"not-connected\"})\n    }\n\n    const correlationId = `req-${++this.requestCounter}`\n\n    return await new Promise((resolve, reject) => {\n      const timer = typeof timeoutMs === \"number\" && timeoutMs > 0\n        ? setTimeout(() => {\n          this.pending.delete(correlationId)\n          reject(new AdvisoryLockServiceUnavailableError(\n            `Lock server request timed out: ${type} ${String(payload.name ?? \"\")}`,\n            {lockName: String(payload.name ?? \"\"), reason: \"request-timeout\"}\n          ))\n        }, timeoutMs)\n        : null\n\n      timer?.unref?.()\n      this.pending.set(correlationId, {reject, resolve, timer})\n\n      try {\n        connection.sendMessage({...payload, correlationId, type})\n      } catch (error) {\n        this.pending.delete(correlationId)\n        if (timer) clearTimeout(timer)\n        this.markUnavailable(error instanceof Error ? error : new Error(String(error)))\n        reject(new AdvisoryLockServiceUnavailableError(\n          `Lock server send failed: ${error instanceof Error ? error.message : String(error)}`,\n          {lockName: String(payload.name ?? \"\"), reason: \"send-failed\"}\n        ))\n      }\n    })\n  }\n\n  /**\n   * Starts lease renewal for a granted lock.\n   * @param {string} name - Lock name.\n   * @param {number} epoch - Granted epoch.\n   * @returns {void}\n   */\n  startRenewal(name, epoch) {\n    const existing = this.holds.get(name)\n\n    if (existing) clearInterval(existing.timer)\n\n    const intervalMs = Math.max(250, Math.floor(this.leaseMs / 3))\n    const timer = setInterval(() => {\n      void this.renew(name, epoch)\n    }, intervalMs)\n\n    timer.unref?.()\n    this.holds.set(name, {epoch, leaseExpiresAt: Date.now() + this.leaseMs, name, timer})\n  }\n\n  /**\n   * Renews one lease; a fenced lease is recorded for the runner to surface.\n   * @param {string} name - Lock name.\n   * @param {number} epoch - Epoch the hold believes it owns.\n   * @returns {Promise<void>} - Resolves after the renewal round-trip.\n   */\n  async renew(name, epoch) {\n    const hold = this.holds.get(name)\n\n    if (!hold || !this.connection) return\n\n    try {\n      const response = await this.request(\"renew\", {epoch, name}, this.connectTimeoutMs * 2)\n      const status = String(response.status)\n\n      if (status === \"renewed\") {\n        hold.leaseExpiresAt = Number(response.leaseExpiresAt)\n\n        return\n      }\n\n      if (status === \"lost\" || status === \"not-found\") {\n        this.holds.delete(name)\n        clearInterval(hold.timer)\n        this.fencedHolds.set(name, {currentEpoch: Number(response.currentEpoch ?? 0), epoch})\n      }\n    } catch (error) {\n      if (!(error instanceof AdvisoryLockServiceUnavailableError)) throw error\n\n      // A lease that cannot be renewed can no longer be proven to be ours: the\n      // server may have fenced it while the transport was failing. Recording it\n      // as lost is the only honest answer, and stops the renewal loop.\n      this.markUnavailable(error)\n      this.holds.delete(name)\n      clearInterval(hold.timer)\n      this.fencedHolds.set(name, {currentEpoch: null, epoch})\n      this.reportError(error)\n    }\n  }\n\n  /**\n   * Records that the lock server is unreachable and starts the re-probe cooldown.\n   * @param {Error} error - Failure.\n   * @returns {void}\n   */\n  markUnavailable(error) {\n    this.status.lastError = error.message\n    this.status.lastProbeAt = new Date().toISOString()\n    this.status.unavailableUntil = Date.now() + this.reprobeCooldownMs\n  }\n\n  /**\n   * Drops transport state and marks every outstanding hold lost.\n   * @returns {void}\n   */\n  teardown() {\n    for (const [name, hold] of this.holds) {\n      clearInterval(hold.timer)\n      this.fencedHolds.set(name, {currentEpoch: null, epoch: hold.epoch})\n    }\n\n    this.holds.clear()\n\n    for (const pending of this.pending.values()) {\n      if (pending.timer) clearTimeout(pending.timer)\n      pending.reject(new AdvisoryLockServiceUnavailableError(\"Lock server connection dropped\", {lockName: \"\", reason: \"connection-dropped\"}))\n    }\n\n    this.pending.clear()\n\n    const connection = this.connection\n    const client = this.client\n\n    this.connection = null\n    this.client = null\n\n    try {\n      connection?.close?.()\n    } catch (error) {\n      this.reportError(error instanceof Error ? error : new Error(String(error)))\n    }\n\n    try {\n      void client?.close?.()\n    } catch (error) {\n      this.reportError(error instanceof Error ? error : new Error(String(error)))\n    }\n  }\n\n  /**\n   * Reports a transport-side failure without breaking lock handling.\n   * @param {unknown} error - Failure to report.\n   * @returns {void}\n   */\n  reportError(error) {\n    const normalized = error instanceof Error ? error : new Error(String(error))\n\n    this.status.lastError = normalized.message\n\n    if (this.onError) this.onError(normalized)\n  }\n}\n\n/**\n * Default transport factory: the framework websocket client with the Node\n * `ws` implementation bound explicitly (no global mutation).\n * @param {{authToken: string, url: string}} args - Connection args.\n * @returns {LockServerClientLike} - Websocket client.\n */\nfunction defaultClientFactory({url}) {\n  // Node's global WebSocket is not guaranteed to exist, so the implementation is\n  // bound explicitly instead of mutating `globalThis`.\n  const webSocketImplementation = /** @type {typeof globalThis.WebSocket} */ (/** @type {unknown} */ (WebSocket))\n\n  return /** @type {LockServerClientLike} */ (/** @type {unknown} */ (new VelociousWebsocketClient({\n    heartbeatIntervalMs: 10_000,\n    url,\n    webSocketImplementation\n  })))\n}\n"]}