@zukhruf/mutex 0.0.0-stage → 0.2.0

package/dist/lock-stores/sqlite/sqlite-store.js

@@ -0,0 +1,105 @@
+import { DatabaseSync } from 'node:sqlite';
+import { isBusy } from "../../shared/sqlite/is-busy.js";
+import { FileLockStore } from "../file-system/file-lock-store.js";
+import { MemoryStore } from "../memory/memory-store.js";
+/**
+ * Holds an exclusive SQLite transaction on the key's database file. SQLite
+ * locks through the kernel, which releases them when the holder dies, so a
+ * crash never leaves a key locked. Keep the default rollback journal: in WAL
+ * mode an exclusive transaction no longer blocks readers.
+ *
+ * Callers in this process first line up in a queue in memory, so only the
+ * first one opens a database connection: one open file per key per process,
+ * however many callers wait, and first-come order within the process.
+ */
+export class SqliteStore extends FileLockStore {
+    #inProcess = new MemoryStore();
+    async acquire(key, options = {}) {
+        // Joining the in-process queue is synchronous, so the order is the order of the calls.
+        const turn = await this.#inProcess.acquire(key, options);
+        try {
+            return withTurn(await super.acquire(key, options), turn);
+        }
+        catch (error) {
+            await turn[Symbol.asyncDispose]();
+            throw error;
+        }
+    }
+    async tryAcquire(key) {
+        const turn = await this.#inProcess.tryAcquire(key);
+        if (!turn)
+            return undefined;
+        try {
+            const lease = await super.tryAcquire(key);
+            if (lease)
+                return withTurn(lease, turn);
+        }
+        catch (error) {
+            await turn[Symbol.asyncDispose]();
+            throw error;
+        }
+        await turn[Symbol.asyncDispose]();
+        return undefined;
+    }
+    async lock(path, signal) {
+        const database = new DatabaseSync(path, { timeout: 0 });
+        try {
+            await this.poll(async () => (begin(database) ? true : undefined), {
+                signal,
+            });
+        }
+        catch (error) {
+            database.close();
+            throw error;
+        }
+        return holding(database);
+    }
+    async tryLock(path) {
+        const database = new DatabaseSync(path, { timeout: 0 });
+        try {
+            if (begin(database))
+                return holding(database);
+        }
+        catch (error) {
+            database.close();
+            throw error;
+        }
+        database.close();
+        return undefined;
+    }
+}
+/** Starts the exclusive transaction, or reports that another connection holds it. */
+function begin(database) {
+    try {
+        database.exec('BEGIN EXCLUSIVE');
+        return true;
+    }
+    catch (error) {
+        if (isBusy(error))
+            return false;
+        throw error;
+    }
+}
+function holding(database) {
+    return {
+        [Symbol.asyncDispose]: async () => {
+            database.exec('ROLLBACK');
+            database.close();
+        },
+    };
+}
+/** Releases the database lock first, then lets the next caller in this process try. */
+function withTurn(lease, turn) {
+    return {
+        token: lease.token,
+        [Symbol.asyncDispose]: async () => {
+            try {
+                await lease[Symbol.asyncDispose]();
+            }
+            finally {
+                await turn[Symbol.asyncDispose]();
+            }
+        },
+    };
+}
+//# sourceMappingURL=sqlite-store.js.map

package/dist/lock-stores/sqlite/sqlite-store.js.map

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

package/dist/lock-stores/thread/parent-port-connection.d.ts

@@ -0,0 +1,20 @@
+import type { MessagePort } from 'node:worker_threads';
+import type { Connection, ConnectionHandlers } from '../remote/connection.ts';
+import { type LockRequest, type LockResponse } from '../remote/protocol.ts';
+/**
+ * A worker thread's end of the message port to the thread that started it.
+ * A `message` listener keeps the worker alive, so this adapter listens only
+ * while referenced; messages that arrive meanwhile wait in the port. The
+ * coordinator cannot stop without its workers stopping too, so `close` is
+ * never reported.
+ */
+export declare class ParentPortConnection implements Connection<LockRequest, LockResponse> {
+    #private;
+    constructor(port: MessagePort);
+    send(request: LockRequest): Promise<void>;
+    listen(handlers: ConnectionHandlers<LockResponse>): void;
+    ref(): void;
+    unref(): void;
+    close(): void;
+}
+//# sourceMappingURL=parent-port-connection.d.ts.map

package/dist/lock-stores/thread/parent-port-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parent-port-connection.d.ts","sourceRoot":"","sources":["../../../src/lock-stores/thread/parent-port-connection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE9E,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,YAAY,EAElB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;GAMG;AACH,qBAAa,oBAAqB,YAAW,UAAU,CACrD,WAAW,EACX,YAAY,CACb;;gBAUa,IAAI,EAAE,WAAW;IAIvB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/C,MAAM,CAAC,QAAQ,EAAE,kBAAkB,CAAC,YAAY,CAAC;IAIjD,GAAG;IAMH,KAAK;IAML,KAAK;CAGN"}

package/dist/lock-stores/thread/parent-port-connection.js

@@ -0,0 +1,44 @@
+import { unwrap, wrap } from "../remote/envelope.js";
+import { isLockResponse, } from "../remote/protocol.js";
+/**
+ * A worker thread's end of the message port to the thread that started it.
+ * A `message` listener keeps the worker alive, so this adapter listens only
+ * while referenced; messages that arrive meanwhile wait in the port. The
+ * coordinator cannot stop without its workers stopping too, so `close` is
+ * never reported.
+ */
+export class ParentPortConnection {
+    #port;
+    #handlers;
+    #listening = false;
+    #onMessage = (envelope) => {
+        const response = unwrap(envelope);
+        if (isLockResponse(response))
+            this.#handlers?.message(response);
+    };
+    constructor(port) {
+        this.#port = port;
+    }
+    async send(request) {
+        this.#port.postMessage(wrap(request));
+    }
+    listen(handlers) {
+        this.#handlers = handlers;
+    }
+    ref() {
+        if (this.#listening)
+            return;
+        this.#listening = true;
+        this.#port.on('message', this.#onMessage);
+    }
+    unref() {
+        if (!this.#listening)
+            return;
+        this.#listening = false;
+        this.#port.off('message', this.#onMessage);
+    }
+    close() {
+        this.unref();
+    }
+}
+//# sourceMappingURL=parent-port-connection.js.map

package/dist/lock-stores/thread/parent-port-connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parent-port-connection.js","sourceRoot":"","sources":["../../../src/lock-stores/thread/parent-port-connection.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAGL,cAAc,GACf,MAAM,uBAAuB,CAAC;AAE/B;;;;;;GAMG;AACH,MAAM,OAAO,oBAAoB;IAItB,KAAK,CAAc;IAC5B,SAAS,CAA+C;IACxD,UAAU,GAAG,KAAK,CAAC;IAEV,UAAU,GAAG,CAAC,QAAiB,EAAE,EAAE;QAC1C,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAClC,IAAI,cAAc,CAAC,QAAQ,CAAC;YAAE,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAClE,CAAC,CAAC;IAEF,YAAY,IAAiB;QAC3B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,OAAoB;QAC7B,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IACxC,CAAC;IAED,MAAM,CAAC,QAA0C;QAC/C,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;IAC5B,CAAC;IAED,GAAG;QACD,IAAI,IAAI,CAAC,UAAU;YAAE,OAAO;QAC5B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAC5C,CAAC;IAED,KAAK;QACH,IAAI,CAAC,IAAI,CAAC,UAAU;YAAE,OAAO;QAC7B,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAC7C,CAAC;IAED,KAAK;QACH,IAAI,CAAC,KAAK,EAAE,CAAC;IACf,CAAC;CACF"}

package/dist/lock-stores/thread/thread-lock-coordinator.d.ts

@@ -0,0 +1,22 @@
+import type { Worker } from 'node:worker_threads';
+import type { TokenSource } from '../../fencing/token-source.ts';
+import type { Lease } from '../../mutex/lease.ts';
+import type { AcquireOptions, LockStore } from '../../mutex/lock-store.ts';
+export interface ThreadLockCoordinatorOptions {
+    /** Defaults to an in-memory counter, which lives as long as this process. */
+    tokens?: TokenSource;
+}
+/**
+ * Grants keys to the thread that owns it and to every worker thread it adopts,
+ * which use `ThreadStore`. One thread decides every grant, so two threads can
+ * never both be granted a key. Its reach is one process.
+ */
+export declare class ThreadLockCoordinator implements LockStore {
+    #private;
+    constructor({ tokens, }?: ThreadLockCoordinatorOptions);
+    acquire(key: string, options?: AcquireOptions): Promise<Lease>;
+    tryAcquire(key: string): Promise<Lease | undefined>;
+    /** Serves `worker`. When the thread stops, everything it held or waited for is released. */
+    adopt(worker: Worker): void;
+}
+//# sourceMappingURL=thread-lock-coordinator.d.ts.map

package/dist/lock-stores/thread/thread-lock-coordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread-lock-coordinator.d.ts","sourceRoot":"","sources":["../../../src/lock-stores/thread/thread-lock-coordinator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAGlD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAI3E,MAAM,WAAW,4BAA4B;IAC3C,6EAA6E;IAC7E,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;GAIG;AACH,qBAAa,qBAAsB,YAAW,SAAS;;gBAGzC,EACV,MAAiC,GAClC,GAAE,4BAAiC;IAIpC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC;IAI9D,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC;IAInD,4FAA4F;IAC5F,KAAK,CAAC,MAAM,EAAE,MAAM;CAGrB"}

package/dist/lock-stores/thread/thread-lock-coordinator.js

@@ -0,0 +1,25 @@
+import { CounterTokenSource } from "../../fencing/counter-token-source.js";
+import { LockCoordinator } from "../remote/lock-coordinator.js";
+import { WorkerConnection } from "./worker-connection.js";
+/**
+ * Grants keys to the thread that owns it and to every worker thread it adopts,
+ * which use `ThreadStore`. One thread decides every grant, so two threads can
+ * never both be granted a key. Its reach is one process.
+ */
+export class ThreadLockCoordinator {
+    #coordinator;
+    constructor({ tokens = new CounterTokenSource(), } = {}) {
+        this.#coordinator = new LockCoordinator({ tokens });
+    }
+    acquire(key, options) {
+        return this.#coordinator.acquire(key, options);
+    }
+    tryAcquire(key) {
+        return this.#coordinator.tryAcquire(key);
+    }
+    /** Serves `worker`. When the thread stops, everything it held or waited for is released. */
+    adopt(worker) {
+        this.#coordinator.serve(new WorkerConnection(worker));
+    }
+}
+//# sourceMappingURL=thread-lock-coordinator.js.map

package/dist/lock-stores/thread/thread-lock-coordinator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread-lock-coordinator.js","sourceRoot":"","sources":["../../../src/lock-stores/thread/thread-lock-coordinator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAI3E,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAO1D;;;;GAIG;AACH,MAAM,OAAO,qBAAqB;IACvB,YAAY,CAAkB;IAEvC,YAAY,EACV,MAAM,GAAG,IAAI,kBAAkB,EAAE,MACD,EAAE;QAClC,IAAI,CAAC,YAAY,GAAG,IAAI,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IACtD,CAAC;IAED,OAAO,CAAC,GAAW,EAAE,OAAwB;QAC3C,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IACjD,CAAC;IAED,UAAU,CAAC,GAAW;QACpB,OAAO,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IAC3C,CAAC;IAED,4FAA4F;IAC5F,KAAK,CAAC,MAAc;QAClB,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;IACxD,CAAC;CACF"}

package/dist/lock-stores/thread/thread-store.d.ts

@@ -0,0 +1,13 @@
+import type { Lease } from '../../mutex/lease.ts';
+import type { AcquireOptions, LockStore } from '../../mutex/lock-store.ts';
+/**
+ * The worker-thread side of `ThreadLockCoordinator`: asks the thread that
+ * started this worker for keys, through the worker's message port.
+ */
+export declare class ThreadStore implements LockStore {
+    #private;
+    constructor();
+    acquire(key: string, options?: AcquireOptions): Promise<Lease>;
+    tryAcquire(key: string): Promise<Lease | undefined>;
+}
+//# sourceMappingURL=thread-store.d.ts.map

package/dist/lock-stores/thread/thread-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread-store.d.ts","sourceRoot":"","sources":["../../../src/lock-stores/thread/thread-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAqB3E;;;GAGG;AACH,qBAAa,WAAY,YAAW,SAAS;;;IAY3C,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC;IAI9D,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC;CAGpD"}

package/dist/lock-stores/thread/thread-store.js

@@ -0,0 +1,37 @@
+import { parentPort } from 'node:worker_threads';
+import { RemoteLockClient } from "../remote/remote-lock-client.js";
+import { ParentPortConnection } from "./parent-port-connection.js";
+/** A worker has one port to its parent thread for its whole life. */
+class ParentPortConnector {
+    #port;
+    #handedOut = false;
+    constructor(port) {
+        this.#port = port;
+    }
+    async connect() {
+        if (this.#handedOut)
+            return undefined;
+        this.#handedOut = true;
+        return new ParentPortConnection(this.#port);
+    }
+}
+/**
+ * The worker-thread side of `ThreadLockCoordinator`: asks the thread that
+ * started this worker for keys, through the worker's message port.
+ */
+export class ThreadStore {
+    #client;
+    constructor() {
+        if (!parentPort) {
+            throw new Error('ThreadStore runs in a worker thread; use ThreadLockCoordinator in the thread that starts the workers.');
+        }
+        this.#client = new RemoteLockClient(new ParentPortConnector(parentPort));
+    }
+    acquire(key, options) {
+        return this.#client.acquire(key, options);
+    }
+    tryAcquire(key) {
+        return this.#client.tryAcquire(key);
+    }
+}
+//# sourceMappingURL=thread-store.js.map

package/dist/lock-stores/thread/thread-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread-store.js","sourceRoot":"","sources":["../../../src/lock-stores/thread/thread-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAKnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,qEAAqE;AACrE,MAAM,mBAAmB;IACd,KAAK,CAAc;IAC5B,UAAU,GAAG,KAAK,CAAC;IAEnB,YAAY,IAAiB;QAC3B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,OAAO;QACX,IAAI,IAAI,CAAC,UAAU;YAAE,OAAO,SAAS,CAAC;QACtC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,OAAO,IAAI,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,WAAW;IACb,OAAO,CAAmB;IAEnC;QACE,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CACb,uGAAuG,CACxG,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,OAAO,GAAG,IAAI,gBAAgB,CAAC,IAAI,mBAAmB,CAAC,UAAU,CAAC,CAAC,CAAC;IAC3E,CAAC;IAED,OAAO,CAAC,GAAW,EAAE,OAAwB;QAC3C,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC5C,CAAC;IAED,UAAU,CAAC,GAAW;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IACtC,CAAC;CACF"}

package/dist/lock-stores/thread/worker-connection.d.ts

@@ -0,0 +1,19 @@
+import type { Worker } from 'node:worker_threads';
+import type { Connection, ConnectionHandlers } from '../remote/connection.ts';
+import { type LockRequest, type LockResponse } from '../remote/protocol.ts';
+/**
+ * The coordinator's end of the message port to one worker thread. `Worker`
+ * emits `exit` however the thread stops, so a terminated or crashed holder
+ * is always noticed.
+ */
+export declare class WorkerConnection implements Connection<LockResponse, LockRequest> {
+    #private;
+    constructor(worker: Worker);
+    send(response: LockResponse): Promise<void>;
+    listen({ message, close }: ConnectionHandlers<LockRequest>): void;
+    /** The running worker already keeps its starting thread alive. */
+    ref(): void;
+    unref(): void;
+    close(): void;
+}
+//# sourceMappingURL=worker-connection.d.ts.map

package/dist/lock-stores/thread/worker-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-connection.d.ts","sourceRoot":"","sources":["../../../src/lock-stores/thread/worker-connection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE9E,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,YAAY,EAElB,MAAM,uBAAuB,CAAC;AAE/B;;;;GAIG;AACH,qBAAa,gBAAiB,YAAW,UAAU,CAAC,YAAY,EAAE,WAAW,CAAC;;gBAKhE,MAAM,EAAE,MAAM;IAIpB,IAAI,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAKjD,MAAM,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,kBAAkB,CAAC,WAAW,CAAC;IAkB1D,kEAAkE;IAClE,GAAG;IAEH,KAAK;IAEL,KAAK;CAGN"}

package/dist/lock-stores/thread/worker-connection.js

@@ -0,0 +1,45 @@
+import { unwrap, wrap } from "../remote/envelope.js";
+import { isLockRequest, } from "../remote/protocol.js";
+/**
+ * The coordinator's end of the message port to one worker thread. `Worker`
+ * emits `exit` however the thread stops, so a terminated or crashed holder
+ * is always noticed.
+ */
+export class WorkerConnection {
+    #worker;
+    #exited = false;
+    #detach = () => { };
+    constructor(worker) {
+        this.#worker = worker;
+    }
+    async send(response) {
+        if (this.#exited)
+            throw new Error('The worker thread has exited.');
+        this.#worker.postMessage(wrap(response));
+    }
+    listen({ message, close }) {
+        const onMessage = (envelope) => {
+            const request = unwrap(envelope);
+            if (isLockRequest(request))
+                message(request);
+        };
+        const onExit = () => {
+            this.#exited = true;
+            this.close();
+            close();
+        };
+        this.#worker.on('message', onMessage);
+        this.#worker.once('exit', onExit);
+        this.#detach = () => {
+            this.#worker.off('message', onMessage);
+            this.#worker.off('exit', onExit);
+        };
+    }
+    /** The running worker already keeps its starting thread alive. */
+    ref() { }
+    unref() { }
+    close() {
+        this.#detach();
+    }
+}
+//# sourceMappingURL=worker-connection.js.map

package/dist/lock-stores/thread/worker-connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-connection.js","sourceRoot":"","sources":["../../../src/lock-stores/thread/worker-connection.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAGL,aAAa,GACd,MAAM,uBAAuB,CAAC;AAE/B;;;;GAIG;AACH,MAAM,OAAO,gBAAgB;IAClB,OAAO,CAAS;IACzB,OAAO,GAAG,KAAK,CAAC;IAChB,OAAO,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;IAEnB,YAAY,MAAc;QACxB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,QAAsB;QAC/B,IAAI,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;QACnE,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC3C,CAAC;IAED,MAAM,CAAC,EAAE,OAAO,EAAE,KAAK,EAAmC;QACxD,MAAM,SAAS,GAAG,CAAC,QAAiB,EAAE,EAAE;YACtC,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;YACjC,IAAI,aAAa,CAAC,OAAO,CAAC;gBAAE,OAAO,CAAC,OAAO,CAAC,CAAC;QAC/C,CAAC,CAAC;QACF,MAAM,MAAM,GAAG,GAAG,EAAE;YAClB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC,KAAK,EAAE,CAAC;YACb,KAAK,EAAE,CAAC;QACV,CAAC,CAAC;QACF,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACtC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAClC,IAAI,CAAC,OAAO,GAAG,GAAG,EAAE;YAClB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;YACvC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACnC,CAAC,CAAC;IACJ,CAAC;IAED,kEAAkE;IAClE,GAAG,KAAI,CAAC;IAER,KAAK,KAAI,CAAC;IAEV,KAAK;QACH,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;CACF"}

package/dist/mutex/acquire-mode.d.ts

@@ -0,0 +1,30 @@
+import type { Lease } from './lease.ts';
+import type { LockStore } from './lock-store.ts';
+/** Whether an acquire mode always ends with the key held, or may give up. */
+export type Outcome = 'always' | 'maybe';
+/**
+ * What one caller does while its key is busy. Exclusivity never depends on
+ * the acquire mode, so callers of one key can use different modes.
+ */
+export interface AcquireMode<O extends Outcome = Outcome> {
+    readonly outcome: O;
+    /** Resolves with a lease, or `undefined` when this caller gives up. */
+    acquire(store: LockStore, key: string): Promise<Lease | undefined>;
+}
+export interface Acquired<T> {
+    readonly acquired: true;
+    readonly value: T;
+}
+export interface NotAcquired {
+    readonly acquired: false;
+}
+/** What a run gives back, for each outcome. */
+export interface OutcomeResults<T> {
+    /** A mode that always acquires gives the task's value. */
+    always: T;
+    /** A mode that may give up says whether it acquired. */
+    maybe: Acquired<T> | NotAcquired;
+}
+/** The result of a run with mode `M`. */
+export type ModeResult<M extends AcquireMode, T> = OutcomeResults<T>[M['outcome']];
+//# sourceMappingURL=acquire-mode.d.ts.map

package/dist/mutex/acquire-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acquire-mode.d.ts","sourceRoot":"","sources":["../../src/mutex/acquire-mode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,6EAA6E;AAC7E,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEzC;;;GAGG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO;IACtD,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB,uEAAuE;IACvE,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;CACpE;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;CAC1B;AAED,+CAA+C;AAC/C,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,0DAA0D;IAC1D,MAAM,EAAE,CAAC,CAAC;IACV,wDAAwD;IACxD,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC;CAClC;AAED,yCAAyC;AACzC,MAAM,MAAM,UAAU,CACpB,CAAC,SAAS,WAAW,EACrB,CAAC,IACC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC"}

package/dist/mutex/acquire-mode.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=acquire-mode.js.map

package/dist/mutex/acquire-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acquire-mode.js","sourceRoot":"","sources":["../../src/mutex/acquire-mode.ts"],"names":[],"mappings":""}

package/dist/mutex/acquire-modes/modes.d.ts

@@ -0,0 +1,9 @@
+import { SkipIfBusyMode, type SkipIfBusyOptions } from './skip-if-busy-mode.ts';
+import { WaitMode } from './wait-mode.ts';
+export declare const Modes: {
+    /** Wait until the key is granted. The task always runs. */
+    wait: () => WaitMode;
+    /** Give up when the key stays busy, at once or after `waitAtMost` ms. The task may not run. */
+    skipIfBusy: (options?: SkipIfBusyOptions) => SkipIfBusyMode;
+};
+//# sourceMappingURL=modes.d.ts.map

package/dist/mutex/acquire-modes/modes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modes.d.ts","sourceRoot":"","sources":["../../../src/mutex/acquire-modes/modes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChF,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,eAAO,MAAM,KAAK;IAChB,2DAA2D;;IAE3D,+FAA+F;2BACxE,iBAAiB;CACzC,CAAC"}

package/dist/mutex/acquire-modes/modes.js

@@ -0,0 +1,9 @@
+import { SkipIfBusyMode } from "./skip-if-busy-mode.js";
+import { WaitMode } from "./wait-mode.js";
+export const Modes = {
+    /** Wait until the key is granted. The task always runs. */
+    wait: () => new WaitMode(),
+    /** Give up when the key stays busy, at once or after `waitAtMost` ms. The task may not run. */
+    skipIfBusy: (options) => new SkipIfBusyMode(options),
+};
+//# sourceMappingURL=modes.js.map

package/dist/mutex/acquire-modes/modes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modes.js","sourceRoot":"","sources":["../../../src/mutex/acquire-modes/modes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAA0B,MAAM,wBAAwB,CAAC;AAChF,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,2DAA2D;IAC3D,IAAI,EAAE,GAAG,EAAE,CAAC,IAAI,QAAQ,EAAE;IAC1B,+FAA+F;IAC/F,UAAU,EAAE,CAAC,OAA2B,EAAE,EAAE,CAAC,IAAI,cAAc,CAAC,OAAO,CAAC;CACzE,CAAC"}

package/dist/mutex/acquire-modes/skip-if-busy-mode.d.ts

@@ -0,0 +1,15 @@
+import type { AcquireMode } from '../acquire-mode.ts';
+import type { Lease } from '../lease.ts';
+import type { LockStore } from '../lock-store.ts';
+export interface SkipIfBusyOptions {
+    /** Milliseconds to wait for a busy key before giving up. Defaults to 0: one attempt only. */
+    waitAtMost?: number;
+}
+/** Gives up when the key stays busy, at once or after `waitAtMost`, so the task may not run. */
+export declare class SkipIfBusyMode implements AcquireMode<'maybe'> {
+    #private;
+    readonly outcome: "maybe";
+    constructor({ waitAtMost }?: SkipIfBusyOptions);
+    acquire(store: LockStore, key: string): Promise<Lease | undefined>;
+}
+//# sourceMappingURL=skip-if-busy-mode.d.ts.map

package/dist/mutex/acquire-modes/skip-if-busy-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skip-if-busy-mode.d.ts","sourceRoot":"","sources":["../../../src/mutex/acquire-modes/skip-if-busy-mode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,MAAM,WAAW,iBAAiB;IAChC,6FAA6F;IAC7F,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,gGAAgG;AAChG,qBAAa,cAAe,YAAW,WAAW,CAAC,OAAO,CAAC;;IACzD,QAAQ,CAAC,OAAO,EAAG,OAAO,CAAU;gBAGxB,EAAE,UAAc,EAAE,GAAE,iBAAsB;IAShD,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC;CAazE"}

package/dist/mutex/acquire-modes/skip-if-busy-mode.js

@@ -0,0 +1,27 @@
+/** Gives up when the key stays busy, at once or after `waitAtMost`, so the task may not run. */
+export class SkipIfBusyMode {
+    outcome = 'maybe';
+    #waitAtMost;
+    constructor({ waitAtMost = 0 } = {}) {
+        if (!(waitAtMost >= 0) || !Number.isFinite(waitAtMost)) {
+            throw new RangeError(`waitAtMost must be a finite number of milliseconds >= 0, got ${waitAtMost}.`);
+        }
+        this.#waitAtMost = waitAtMost;
+    }
+    async acquire(store, key) {
+        // Always one attempt first: a time limit must never skip a key that is free.
+        const lease = await store.tryAcquire(key);
+        if (lease || this.#waitAtMost === 0)
+            return lease;
+        const signal = AbortSignal.timeout(this.#waitAtMost);
+        try {
+            return await store.acquire(key, { signal });
+        }
+        catch (error) {
+            if (error === signal.reason)
+                return undefined;
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=skip-if-busy-mode.js.map

package/dist/mutex/acquire-modes/skip-if-busy-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skip-if-busy-mode.js","sourceRoot":"","sources":["../../../src/mutex/acquire-modes/skip-if-busy-mode.ts"],"names":[],"mappings":"AASA,gGAAgG;AAChG,MAAM,OAAO,cAAc;IAChB,OAAO,GAAG,OAAgB,CAAC;IAC3B,WAAW,CAAS;IAE7B,YAAY,EAAE,UAAU,GAAG,CAAC,KAAwB,EAAE;QACpD,IAAI,CAAC,CAAC,UAAU,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;YACvD,MAAM,IAAI,UAAU,CAClB,gEAAgE,UAAU,GAAG,CAC9E,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;IAChC,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,KAAgB,EAAE,GAAW;QACzC,6EAA6E;QAC7E,MAAM,KAAK,GAAG,MAAM,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QAC1C,IAAI,KAAK,IAAI,IAAI,CAAC,WAAW,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAElD,MAAM,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACrD,IAAI,CAAC;YACH,OAAO,MAAM,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;QAC9C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,KAAK,MAAM,CAAC,MAAM;gBAAE,OAAO,SAAS,CAAC;YAC9C,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;CACF"}

package/dist/mutex/acquire-modes/wait-mode.d.ts

@@ -0,0 +1,9 @@
+import type { AcquireMode } from '../acquire-mode.ts';
+import type { Lease } from '../lease.ts';
+import type { LockStore } from '../lock-store.ts';
+/** Waits until the key is granted, so the task always runs. */
+export declare class WaitMode implements AcquireMode<'always'> {
+    readonly outcome: "always";
+    acquire(store: LockStore, key: string): Promise<Lease>;
+}
+//# sourceMappingURL=wait-mode.d.ts.map

package/dist/mutex/acquire-modes/wait-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-mode.d.ts","sourceRoot":"","sources":["../../../src/mutex/acquire-modes/wait-mode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,+DAA+D;AAC/D,qBAAa,QAAS,YAAW,WAAW,CAAC,QAAQ,CAAC;IACpD,QAAQ,CAAC,OAAO,EAAG,QAAQ,CAAU;IAErC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;CAGvD"}

package/dist/mutex/acquire-modes/wait-mode.js

@@ -0,0 +1,8 @@
+/** Waits until the key is granted, so the task always runs. */
+export class WaitMode {
+    outcome = 'always';
+    acquire(store, key) {
+        return store.acquire(key);
+    }
+}
+//# sourceMappingURL=wait-mode.js.map

package/dist/mutex/acquire-modes/wait-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-mode.js","sourceRoot":"","sources":["../../../src/mutex/acquire-modes/wait-mode.ts"],"names":[],"mappings":"AAIA,+DAA+D;AAC/D,MAAM,OAAO,QAAQ;IACV,OAAO,GAAG,QAAiB,CAAC;IAErC,OAAO,CAAC,KAAgB,EAAE,GAAW;QACnC,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC5B,CAAC;CACF"}

package/dist/mutex/key.d.ts

@@ -0,0 +1,22 @@
+import type { AcquireMode, Outcome, OutcomeResults } from './acquire-mode.ts';
+import type { Lease } from './lease.ts';
+import type { Mutex } from './mutex.ts';
+/**
+ * A key with the acquire mode that its callers use unless one call says
+ * otherwise. Build it with `mutex.key(name, { mode })`. `O` is the outcome of
+ * that mode.
+ */
+export declare class Key<O extends Outcome> {
+    #private;
+    readonly name: string;
+    constructor(mutex: Mutex, name: string, mode: AcquireMode<O>);
+    /** Runs `task` with the key's own acquire mode. */
+    run<T>(task: (lease: Lease) => Promise<T>, options?: {
+        mode?: undefined;
+    }): Promise<OutcomeResults<T>[O]>;
+    /** Runs `task` with `mode` instead of the key's own acquire mode. */
+    run<T, P extends Outcome>(task: (lease: Lease) => Promise<T>, options: {
+        mode: AcquireMode<P>;
+    }): Promise<OutcomeResults<T>[P]>;
+}
+//# sourceMappingURL=key.d.ts.map

package/dist/mutex/key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../../src/mutex/key.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC;;;;GAIG;AACH,qBAAa,GAAG,CAAC,CAAC,SAAS,OAAO;;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAIV,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC;IAM5D,mDAAmD;IACnD,GAAG,CAAC,CAAC,EACH,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,EAClC,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,SAAS,CAAA;KAAE,GAC7B,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAChC,qEAAqE;IACrE,GAAG,CAAC,CAAC,EAAE,CAAC,SAAS,OAAO,EACtB,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,EAClC,OAAO,EAAE;QAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;KAAE,GAChC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CASjC"}

package/dist/mutex/key.js

@@ -0,0 +1,21 @@
+/**
+ * A key with the acquire mode that its callers use unless one call says
+ * otherwise. Build it with `mutex.key(name, { mode })`. `O` is the outcome of
+ * that mode.
+ */
+export class Key {
+    name;
+    #mutex;
+    #mode;
+    constructor(mutex, name, mode) {
+        this.#mutex = mutex;
+        this.name = name;
+        this.#mode = mode;
+    }
+    run(task, { mode } = {}) {
+        return mode === undefined
+            ? this.#mutex.acquire(this.name, task, { mode: this.#mode })
+            : this.#mutex.acquire(this.name, task, { mode });
+    }
+}
+//# sourceMappingURL=key.js.map

package/dist/mutex/key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.js","sourceRoot":"","sources":["../../src/mutex/key.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,MAAM,OAAO,GAAG;IACL,IAAI,CAAS;IACb,MAAM,CAAQ;IACd,KAAK,CAAiB;IAE/B,YAAY,KAAY,EAAE,IAAY,EAAE,IAAoB;QAC1D,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACpB,CAAC;IAYD,GAAG,CACD,IAAkC,EAClC,EAAE,IAAI,KAA4C,EAAE;QAEpD,OAAO,IAAI,KAAK,SAAS;YACvB,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;YAC5D,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;IACrD,CAAC;CACF"}

package/dist/mutex/lease.d.ts

@@ -0,0 +1,9 @@
+import type { FencingToken } from '../fencing/fencing-token.ts';
+import type { TokenSource } from '../fencing/token-source.ts';
+/** Proof of holding a key: pass `token` to fenced resources; dispose to release. */
+export interface Lease extends AsyncDisposable {
+    readonly token: FencingToken;
+}
+/** Mints the token for a lock that is already held, releasing the lock if minting fails. */
+export declare function leaseFor(key: string, held: AsyncDisposable, tokens: TokenSource): Promise<Lease>;
+//# sourceMappingURL=lease.d.ts.map

package/dist/mutex/lease.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lease.d.ts","sourceRoot":"","sources":["../../src/mutex/lease.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D,oFAAoF;AACpF,MAAM,WAAW,KAAM,SAAQ,eAAe;IAC5C,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;CAC9B;AAED,4FAA4F;AAC5F,wBAAsB,QAAQ,CAC5B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,eAAe,EACrB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,KAAK,CAAC,CAQhB"}

package/dist/mutex/lease.js

@@ -0,0 +1,12 @@
+/** Mints the token for a lock that is already held, releasing the lock if minting fails. */
+export async function leaseFor(key, held, tokens) {
+    try {
+        const token = await tokens.next(key);
+        return { token, [Symbol.asyncDispose]: () => held[Symbol.asyncDispose]() };
+    }
+    catch (error) {
+        await held[Symbol.asyncDispose]();
+        throw error;
+    }
+}
+//# sourceMappingURL=lease.js.map

package/dist/mutex/lease.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lease.js","sourceRoot":"","sources":["../../src/mutex/lease.ts"],"names":[],"mappings":"AAQA,4FAA4F;AAC5F,MAAM,CAAC,KAAK,UAAU,QAAQ,CAC5B,GAAW,EACX,IAAqB,EACrB,MAAmB;IAEnB,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACrC,OAAO,EAAE,KAAK,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC;IAC7E,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC;QAClC,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/mutex/lock-lost-error.d.ts

@@ -0,0 +1,6 @@
+/** The key may have been granted to another holder while this lease was still in use. */
+export declare class LockLostError extends Error {
+    readonly key: string;
+    constructor(key: string);
+}
+//# sourceMappingURL=lock-lost-error.d.ts.map