@zukhruf/mutex 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ezzabuzaid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,156 @@
-# Temporary Holding Version
+# @zukhruf/mutex
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A mutex for Node.js with interchangeable lock stores. You select who shares the locks: one object, the threads of one process, a parent process and its children, or all processes on one host. The code that uses the mutex stays the same. Each lease has a fencing token, so a resource can refuse the late writes of a holder that lost its key.
+
+The words in these documents have one meaning each. See the glossary in [CONTEXT.md](./CONTEXT.md).
+
+## The problem
+
+Two requests ask for the last item at the same time. Each request reads the stock, waits for the database, and then writes the stock. Both requests read `1`, so both sell the item.
+
+```ts
+if (stock > 0) {
+  // both requests see 1
+  await saveReservation(); // the other request runs here
+  stock -= 1; // both requests write
+}
+```
+
+A mutex lets one holder at a time run this code for a key:
+
+```ts
+import { MemoryStore, Mutex } from '@zukhruf/mutex';
+
+const mutex = new Mutex(new MemoryStore());
+
+const reserved = await mutex.acquire('product:42', async () => {
+  if (stock === 0) return false;
+  await saveReservation();
+  stock -= 1;
+  return true;
+});
+```
+
+The full program is in the recipe [Stop two requests from selling the last item](./docs/recipes/reserve-the-last-item.md).
+
+## Select a lock store
+
+First find who writes to the resource. Then select the lock store with that [reach](./docs/concepts/reach.md).
+
+| Lock store                                                       | Reach                   | Order                                   | A holder stops                  | Needs                       |
+| ---------------------------------------------------------------- | ----------------------- | --------------------------------------- | ------------------------------- | --------------------------- |
+| [MemoryStore](./docs/stores/memory-store.md)                     | One object              | First come, first served                | The locks stop with the process | Nothing                     |
+| [ThreadStore](./docs/stores/thread-store.md)                     | One process (threads)   | First come, first served                | Released when the worker exits  | `adopt(worker)`             |
+| [IpcStore](./docs/stores/ipc-store.md)                           | Parent and its children | First come, first served                | Released in approximately 2 ms  | `fork()` and `adopt(child)` |
+| [TicketQueueFileStore](./docs/stores/ticket-queue-file-store.md) | One host                | First come, first served                | Released after a process check  | A shared directory          |
+| [LockFileStore](./docs/stores/lock-file-store.md)                | One host                | No order                                | Released after a process check  | A shared directory          |
+| [SqliteStore](./docs/stores/sqlite-store.md)                     | One host                | First come, first served in one process | Released by the kernel          | A shared directory          |
+| [SocketStore](./docs/stores/socket-store.md)                     | One host                | First come, first served                | Released in approximately 2 ms  | A shared directory          |
+
+If you are not sure:
+
+- **One process:** use `MemoryStore`.
+- **Several processes on one host:** use `SqliteStore`.
+
+## Acquire modes
+
+A key is exclusive for every caller. The acquire mode decides only what one caller does while the key is busy: wait (the default), or skip.
+
+```ts
+import { Modes } from '@zukhruf/mutex';
+
+const report = mutex.key('report:daily', { mode: Modes.skipIfBusy() });
+
+const tick = await report.run(buildReport); // a cron tick skips if a report runs
+if (!tick.acquired) return;
+
+const fresh = await report.run(buildReport, { mode: Modes.wait() }); // an admin waits, then runs
+await mutex.acquire('product:42', reserve, {
+  mode: Modes.skipIfBusy({ waitAtMost: 500 }),
+});
+```
+
+A mode that can skip returns `{ acquired: true, value } | { acquired: false }`, and TypeScript makes you check `acquired`. See [Acquire modes](./docs/concepts/acquire-modes.md).
+
+## Fencing tokens
+
+A holder can lose its key and not know it, for example when its process freezes. Each lease has a fencing token that increases with each grant. Send the token with each write, and let the resource refuse lower tokens:
+
+```ts
+await mutex.acquire('product:42', async (lease) => {
+  await database.run(
+    `UPDATE stock SET quantity = quantity - 1, fence = ?
+		 WHERE product = ? AND fence <= ? AND quantity > 0`,
+    [lease.token.value, 'product:42', lease.token.value],
+  );
+});
+```
+
+See [Fencing tokens](./docs/concepts/fencing-tokens.md) and the recipe [Protect a database from stale holders](./docs/recipes/fence-a-database.md).
+
+## Documentation
+
+**Concepts**
+
+- [Reach](./docs/concepts/reach.md): who can share a lock, and how to select it.
+- [Acquire modes](./docs/concepts/acquire-modes.md): wait or skip while a key is busy.
+- [Fencing tokens](./docs/concepts/fencing-tokens.md): how a resource refuses a stale holder.
+- [Leader election](./docs/concepts/leader-election.md): how `SocketStore` selects its coordinator.
+- [Failure modes](./docs/concepts/failure-modes.md): what each lock store does when something stops.
+
+**Lock stores**: one page for each lock store, with What, Why, When, When not, How it works, Failure modes, Options, and Evidence. See the table above.
+
+**Recipes**: one use case each, with a full program that you can run.
+
+1. [Stop two requests from selling the last item](./docs/recipes/reserve-the-last-item.md)
+2. [Several app instances on one host](./docs/recipes/several-instances-on-one-host.md)
+3. [A worker pool that you start](./docs/recipes/worker-pool.md)
+4. [Worker threads that share a lock](./docs/recipes/worker-threads.md)
+5. [Protect a database from stale holders](./docs/recipes/fence-a-database.md)
+6. [Survive a crashed holder](./docs/recipes/survive-a-crashed-holder.md)
+7. [Run a job in only one process](./docs/recipes/singleton-job-with-leader-election.md)
+8. [Write your own lock store](./docs/recipes/write-your-own-lock-store.md)
+9. [Skip a job that is already running](./docs/recipes/skip-a-job-that-is-already-running.md)
+
+**Decisions**: the [architecture decision records](./docs/adr) tell why the design is as it is.
+
+## Use it
+
+This project is an experiment. You need Node.js 26.9 or later.
+
+```sh
+npm install @zukhruf/mutex
+```
+
+```ts
+import { Mutex, SqliteStore } from '@zukhruf/mutex';
+import { LeaderElection } from '@zukhruf/mutex/leader-election';
+```
+
+## Development
+
+This package is part of the [zukhruf](../../README.md) workspace. Run the commands from the workspace root.
+
+```sh
+npm install
+npx nx run mutex:test        # builds, then runs all tests in src/
+npx nx run mutex:typecheck   # formats, lints, then type checks
+npx nx run mutex:build       # compiles src/ to dist/
+```
+
+The tests run from `src/`, not from `dist/`: they start workers and child processes from `.ts` files.
+
+```
+src/
+  mutex/             Mutex, Key, acquire modes, Lease, LockStore, LockLostError
+  fencing/           fencing tokens and token sources
+  lock-stores/       one folder for each lock store
+    remote/          the coordinator and client that ThreadStore, IpcStore and SocketStore share
+  leader-election/   leader election (separate entry point, not part of the mutex)
+  shared/            small file system and SQLite helpers
+  testing/           test helpers and the matrix of lock stores (not published)
+docs/
+  concepts/  stores/  recipes/  adr/
+```
+
+The tests run each lock store through the same scenarios: single process, many threads, many processes, a killed holder, and a failover. Mutation tests broke the mechanisms on purpose, and a test found each break. A test that breaks something stops the run at once (`--test-force-exit`), so a broken release fails in seconds and does not hang.

package/dist/fencing/counter-token-source.d.ts

@@ -0,0 +1,11 @@
+import { FencingToken } from './fencing-token.ts';
+import type { TokenSource } from './token-source.ts';
+/**
+ * Counts in memory, so tokens restart when the process does. Only fence
+ * resources that do not outlive the process with it.
+ */
+export declare class CounterTokenSource implements TokenSource {
+    #private;
+    next(_key: string): Promise<FencingToken>;
+}
+//# sourceMappingURL=counter-token-source.d.ts.map

package/dist/fencing/counter-token-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"counter-token-source.d.ts","sourceRoot":"","sources":["../../src/fencing/counter-token-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;GAGG;AACH,qBAAa,kBAAmB,YAAW,WAAW;;IAG9C,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;CAIhD"}

package/dist/fencing/counter-token-source.js

@@ -0,0 +1,13 @@
+import { FencingToken } from "./fencing-token.js";
+/**
+ * Counts in memory, so tokens restart when the process does. Only fence
+ * resources that do not outlive the process with it.
+ */
+export class CounterTokenSource {
+    #last = 0n;
+    async next(_key) {
+        this.#last++;
+        return new FencingToken(this.#last);
+    }
+}
+//# sourceMappingURL=counter-token-source.js.map

package/dist/fencing/counter-token-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"counter-token-source.js","sourceRoot":"","sources":["../../src/fencing/counter-token-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD;;;GAGG;AACH,MAAM,OAAO,kBAAkB;IAC7B,KAAK,GAAG,EAAE,CAAC;IAEX,KAAK,CAAC,IAAI,CAAC,IAAY;QACrB,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;CACF"}

package/dist/fencing/epoch-token-source.d.ts

@@ -0,0 +1,13 @@
+import { FencingToken } from './fencing-token.ts';
+import type { TokenSource } from './token-source.ts';
+/**
+ * Packs `epoch << 32 | sequence`, so every token minted in a newer epoch beats
+ * every token from an older one: a new leader outranks all of its
+ * predecessor's grants. The result fits a signed 64-bit integer.
+ */
+export declare class EpochTokenSource implements TokenSource {
+    #private;
+    constructor(epoch: bigint);
+    next(_key: string): Promise<FencingToken>;
+}
+//# sourceMappingURL=epoch-token-source.d.ts.map

package/dist/fencing/epoch-token-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"epoch-token-source.d.ts","sourceRoot":"","sources":["../../src/fencing/epoch-token-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAMrD;;;;GAIG;AACH,qBAAa,gBAAiB,YAAW,WAAW;;gBAItC,KAAK,EAAE,MAAM;IAOnB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;CAOhD"}

package/dist/fencing/epoch-token-source.js

@@ -0,0 +1,27 @@
+import { FencingToken } from "./fencing-token.js";
+const SEQUENCE_BITS = 32n;
+const EPOCH_LIMIT = 1n << 31n;
+const SEQUENCE_LIMIT = 1n << SEQUENCE_BITS;
+/**
+ * Packs `epoch << 32 | sequence`, so every token minted in a newer epoch beats
+ * every token from an older one: a new leader outranks all of its
+ * predecessor's grants. The result fits a signed 64-bit integer.
+ */
+export class EpochTokenSource {
+    #epoch;
+    #sequence = 0n;
+    constructor(epoch) {
+        if (epoch < 0n || epoch >= EPOCH_LIMIT) {
+            throw new RangeError(`Epoch ${epoch} is outside [0, ${EPOCH_LIMIT}).`);
+        }
+        this.#epoch = epoch;
+    }
+    async next(_key) {
+        this.#sequence++;
+        if (this.#sequence >= SEQUENCE_LIMIT) {
+            throw new RangeError(`Epoch ${this.#epoch} has no tokens left.`);
+        }
+        return new FencingToken((this.#epoch << SEQUENCE_BITS) | this.#sequence);
+    }
+}
+//# sourceMappingURL=epoch-token-source.js.map

package/dist/fencing/epoch-token-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"epoch-token-source.js","sourceRoot":"","sources":["../../src/fencing/epoch-token-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,MAAM,aAAa,GAAG,GAAG,CAAC;AAC1B,MAAM,WAAW,GAAG,EAAE,IAAI,GAAG,CAAC;AAC9B,MAAM,cAAc,GAAG,EAAE,IAAI,aAAa,CAAC;AAE3C;;;;GAIG;AACH,MAAM,OAAO,gBAAgB;IAClB,MAAM,CAAS;IACxB,SAAS,GAAG,EAAE,CAAC;IAEf,YAAY,KAAa;QACvB,IAAI,KAAK,GAAG,EAAE,IAAI,KAAK,IAAI,WAAW,EAAE,CAAC;YACvC,MAAM,IAAI,UAAU,CAAC,SAAS,KAAK,mBAAmB,WAAW,IAAI,CAAC,CAAC;QACzE,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,IAAY;QACrB,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,IAAI,CAAC,SAAS,IAAI,cAAc,EAAE,CAAC;YACrC,MAAM,IAAI,UAAU,CAAC,SAAS,IAAI,CAAC,MAAM,sBAAsB,CAAC,CAAC;QACnE,CAAC;QACD,OAAO,IAAI,YAAY,CAAC,CAAC,IAAI,CAAC,MAAM,IAAI,aAAa,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;IAC3E,CAAC;CACF"}

package/dist/fencing/fencing-token.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Grows with every grant of a lock. A resource that rejects writes carrying a
+ * token older than the newest it has seen ignores holders that were superseded
+ * without knowing it (frozen, partitioned, or outlived by a failover).
+ */
+export declare class FencingToken {
+    readonly value: bigint;
+    constructor(value: bigint);
+    isNewerThan(other: FencingToken): boolean;
+    toString(): string;
+}
+//# sourceMappingURL=fencing-token.d.ts.map

package/dist/fencing/fencing-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fencing-token.d.ts","sourceRoot":"","sources":["../../src/fencing/fencing-token.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,YAAY;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEX,KAAK,EAAE,MAAM;IAIzB,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO;IAIzC,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/fencing/fencing-token.js

@@ -0,0 +1,18 @@
+/**
+ * Grows with every grant of a lock. A resource that rejects writes carrying a
+ * token older than the newest it has seen ignores holders that were superseded
+ * without knowing it (frozen, partitioned, or outlived by a failover).
+ */
+export class FencingToken {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    isNewerThan(other) {
+        return this.value > other.value;
+    }
+    toString() {
+        return this.value.toString();
+    }
+}
+//# sourceMappingURL=fencing-token.js.map

package/dist/fencing/fencing-token.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fencing-token.js","sourceRoot":"","sources":["../../src/fencing/fencing-token.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,OAAO,YAAY;IACd,KAAK,CAAS;IAEvB,YAAY,KAAa;QACvB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED,WAAW,CAAC,KAAmB;QAC7B,OAAO,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IAClC,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;IAC/B,CAAC;CACF"}

package/dist/fencing/file-token-source.d.ts

@@ -0,0 +1,13 @@
+import { FencingToken } from './fencing-token.ts';
+import type { TokenSource } from './token-source.ts';
+/**
+ * Keeps one counter file per key in `directory`, so tokens keep growing across
+ * process restarts and can fence durable resources. Relies on the caller holding
+ * the key's lock: read, increment and replace are not atomic on their own.
+ */
+export declare class FileTokenSource implements TokenSource {
+    #private;
+    constructor(directory: string);
+    next(key: string): Promise<FencingToken>;
+}
+//# sourceMappingURL=file-token-source.d.ts.map

package/dist/fencing/file-token-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-token-source.d.ts","sourceRoot":"","sources":["../../src/fencing/file-token-source.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;GAIG;AACH,qBAAa,eAAgB,YAAW,WAAW;;gBAGrC,SAAS,EAAE,MAAM;IAIvB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;CAO/C"}

package/dist/fencing/file-token-source.js

@@ -0,0 +1,35 @@
+import { mkdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { atomicWrite } from "../shared/fs/atomic-write.js";
+import { isErrno } from "../shared/fs/errno.js";
+import { safeFileName } from "../shared/fs/safe-file-name.js";
+import { FencingToken } from "./fencing-token.js";
+/**
+ * Keeps one counter file per key in `directory`, so tokens keep growing across
+ * process restarts and can fence durable resources. Relies on the caller holding
+ * the key's lock: read, increment and replace are not atomic on their own.
+ */
+export class FileTokenSource {
+    #directory;
+    constructor(directory) {
+        this.#directory = directory;
+    }
+    async next(key) {
+        await mkdir(this.#directory, { recursive: true });
+        const path = join(this.#directory, `${safeFileName(key)}.fence`);
+        const token = (await readCounter(path)) + 1n;
+        await atomicWrite(path, token.toString());
+        return new FencingToken(token);
+    }
+}
+async function readCounter(path) {
+    try {
+        return BigInt(await readFile(path, 'utf8'));
+    }
+    catch (error) {
+        if (isErrno(error, 'ENOENT'))
+            return 0n;
+        throw error;
+    }
+}
+//# sourceMappingURL=file-token-source.js.map

package/dist/fencing/file-token-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-token-source.js","sourceRoot":"","sources":["../../src/fencing/file-token-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD;;;;GAIG;AACH,MAAM,OAAO,eAAe;IACjB,UAAU,CAAS;IAE5B,YAAY,SAAiB;QAC3B,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;IAC9B,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,GAAW;QACpB,MAAM,KAAK,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAClD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,GAAG,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACjE,MAAM,KAAK,GAAG,CAAC,MAAM,WAAW,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC;QAC7C,MAAM,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC1C,OAAO,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;CACF;AAED,KAAK,UAAU,WAAW,CAAC,IAAY;IACrC,IAAI,CAAC;QACH,OAAO,MAAM,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC;YAAE,OAAO,EAAE,CAAC;QACxC,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/fencing/monotonic-clock-token-source.d.ts

@@ -0,0 +1,12 @@
+import { FencingToken } from './fencing-token.ts';
+import type { TokenSource } from './token-source.ts';
+/**
+ * Reads the process-wide monotonic clock, which every worker thread shares, so
+ * grants serialized by a lock read strictly later times without shared memory.
+ * Tokens restart when the process does.
+ */
+export declare class MonotonicClockTokenSource implements TokenSource {
+    #private;
+    next(_key: string): Promise<FencingToken>;
+}
+//# sourceMappingURL=monotonic-clock-token-source.d.ts.map

package/dist/fencing/monotonic-clock-token-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monotonic-clock-token-source.d.ts","sourceRoot":"","sources":["../../src/fencing/monotonic-clock-token-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;GAIG;AACH,qBAAa,yBAA0B,YAAW,WAAW;;IAGrD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;CAKhD"}

package/dist/fencing/monotonic-clock-token-source.js

@@ -0,0 +1,15 @@
+import { FencingToken } from "./fencing-token.js";
+/**
+ * Reads the process-wide monotonic clock, which every worker thread shares, so
+ * grants serialized by a lock read strictly later times without shared memory.
+ * Tokens restart when the process does.
+ */
+export class MonotonicClockTokenSource {
+    #last = 0n;
+    async next(_key) {
+        const now = process.hrtime.bigint();
+        this.#last = now > this.#last ? now : this.#last + 1n;
+        return new FencingToken(this.#last);
+    }
+}
+//# sourceMappingURL=monotonic-clock-token-source.js.map

package/dist/fencing/monotonic-clock-token-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"monotonic-clock-token-source.js","sourceRoot":"","sources":["../../src/fencing/monotonic-clock-token-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD;;;;GAIG;AACH,MAAM,OAAO,yBAAyB;IACpC,KAAK,GAAG,EAAE,CAAC;IAEX,KAAK,CAAC,IAAI,CAAC,IAAY;QACrB,MAAM,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QACpC,IAAI,CAAC,KAAK,GAAG,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;QACtD,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;CACF"}

package/dist/fencing/token-source.d.ts

@@ -0,0 +1,9 @@
+import type { FencingToken } from './fencing-token.ts';
+/**
+ * Mints fencing tokens. Callers hold the key's lock while calling `next`, so
+ * minting for one key is never concurrent and each token is newer than the last.
+ */
+export interface TokenSource {
+    next(key: string): Promise<FencingToken>;
+}
+//# sourceMappingURL=token-source.d.ts.map

package/dist/fencing/token-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-source.d.ts","sourceRoot":"","sources":["../../src/fencing/token-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CAC1C"}

package/dist/fencing/token-source.js

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

package/dist/fencing/token-source.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+export { Mutex } from './mutex/mutex.ts';
+export { Key } from './mutex/key.ts';
+export { leaseFor, type Lease } from './mutex/lease.ts';
+export type { AcquireOptions, LockStore } from './mutex/lock-store.ts';
+export { LockLostError } from './mutex/lock-lost-error.ts';
+export type { Acquired, AcquireMode, ModeResult, NotAcquired, Outcome, OutcomeResults, } from './mutex/acquire-mode.ts';
+export { Modes } from './mutex/acquire-modes/modes.ts';
+export { WaitMode } from './mutex/acquire-modes/wait-mode.ts';
+export { SkipIfBusyMode, type SkipIfBusyOptions, } from './mutex/acquire-modes/skip-if-busy-mode.ts';
+export { FencingToken } from './fencing/fencing-token.ts';
+export type { TokenSource } from './fencing/token-source.ts';
+export { CounterTokenSource } from './fencing/counter-token-source.ts';
+export { FileTokenSource } from './fencing/file-token-source.ts';
+export { MonotonicClockTokenSource } from './fencing/monotonic-clock-token-source.ts';
+export { EpochTokenSource } from './fencing/epoch-token-source.ts';
+export { MemoryStore, type MemoryStoreOptions, } from './lock-stores/memory/memory-store.ts';
+export { ThreadLockCoordinator, type ThreadLockCoordinatorOptions, } from './lock-stores/thread/thread-lock-coordinator.ts';
+export { ThreadStore } from './lock-stores/thread/thread-store.ts';
+export { IpcLockCoordinator, type IpcLockCoordinatorOptions, } from './lock-stores/ipc/ipc-lock-coordinator.ts';
+export { IpcStore } from './lock-stores/ipc/ipc-store.ts';
+export { CoordinatorUnavailableError } from './lock-stores/remote/coordinator-unavailable-error.ts';
+export { FileLockStore, type FileLockStoreOptions, } from './lock-stores/file-system/file-lock-store.ts';
+export { TicketQueueFileStore } from './lock-stores/file-system/ticket-queue-file-store.ts';
+export { LockFileStore } from './lock-stores/file-system/lock-file-store.ts';
+export { SqliteStore } from './lock-stores/sqlite/sqlite-store.ts';
+export { SocketStore, type SocketRole, type SocketStoreOptions, } from './lock-stores/socket/socket-store.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACxD,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,YAAY,EACV,QAAQ,EACR,WAAW,EACX,UAAU,EACV,WAAW,EACX,OAAO,EACP,cAAc,GACf,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAC9D,OAAO,EACL,cAAc,EACd,KAAK,iBAAiB,GACvB,MAAM,4CAA4C,CAAC;AAEpD,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,YAAY,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AACtF,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEnE,OAAO,EACL,WAAW,EACX,KAAK,kBAAkB,GACxB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EACL,qBAAqB,EACrB,KAAK,4BAA4B,GAClC,MAAM,iDAAiD,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EACL,kBAAkB,EAClB,KAAK,yBAAyB,GAC/B,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAC1D,OAAO,EAAE,2BAA2B,EAAE,MAAM,uDAAuD,CAAC;AACpG,OAAO,EACL,aAAa,EACb,KAAK,oBAAoB,GAC1B,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sDAAsD,CAAC;AAC5F,OAAO,EAAE,aAAa,EAAE,MAAM,8CAA8C,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EACL,WAAW,EACX,KAAK,UAAU,EACf,KAAK,kBAAkB,GACxB,MAAM,sCAAsC,CAAC"}

package/dist/index.js

@@ -0,0 +1,24 @@
+export { Mutex } from "./mutex/mutex.js";
+export { Key } from "./mutex/key.js";
+export { leaseFor } from "./mutex/lease.js";
+export { LockLostError } from "./mutex/lock-lost-error.js";
+export { Modes } from "./mutex/acquire-modes/modes.js";
+export { WaitMode } from "./mutex/acquire-modes/wait-mode.js";
+export { SkipIfBusyMode, } from "./mutex/acquire-modes/skip-if-busy-mode.js";
+export { FencingToken } from "./fencing/fencing-token.js";
+export { CounterTokenSource } from "./fencing/counter-token-source.js";
+export { FileTokenSource } from "./fencing/file-token-source.js";
+export { MonotonicClockTokenSource } from "./fencing/monotonic-clock-token-source.js";
+export { EpochTokenSource } from "./fencing/epoch-token-source.js";
+export { MemoryStore, } from "./lock-stores/memory/memory-store.js";
+export { ThreadLockCoordinator, } from "./lock-stores/thread/thread-lock-coordinator.js";
+export { ThreadStore } from "./lock-stores/thread/thread-store.js";
+export { IpcLockCoordinator, } from "./lock-stores/ipc/ipc-lock-coordinator.js";
+export { IpcStore } from "./lock-stores/ipc/ipc-store.js";
+export { CoordinatorUnavailableError } from "./lock-stores/remote/coordinator-unavailable-error.js";
+export { FileLockStore, } from "./lock-stores/file-system/file-lock-store.js";
+export { TicketQueueFileStore } from "./lock-stores/file-system/ticket-queue-file-store.js";
+export { LockFileStore } from "./lock-stores/file-system/lock-file-store.js";
+export { SqliteStore } from "./lock-stores/sqlite/sqlite-store.js";
+export { SocketStore, } from "./lock-stores/socket/socket-store.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAc,MAAM,kBAAkB,CAAC;AAExD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAS3D,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAC9D,OAAO,EACL,cAAc,GAEf,MAAM,4CAA4C,CAAC;AAEpD,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AACtF,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEnE,OAAO,EACL,WAAW,GAEZ,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EACL,qBAAqB,GAEtB,MAAM,iDAAiD,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EACL,kBAAkB,GAEnB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAC1D,OAAO,EAAE,2BAA2B,EAAE,MAAM,uDAAuD,CAAC;AACpG,OAAO,EACL,aAAa,GAEd,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sDAAsD,CAAC;AAC5F,OAAO,EAAE,aAAa,EAAE,MAAM,8CAA8C,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EACL,WAAW,GAGZ,MAAM,sCAAsC,CAAC"}

package/dist/leader-election/index.d.ts

@@ -0,0 +1,3 @@
+export { LeaderElection, type CampaignOptions, type LeaderElectionOptions, } from './leader-election.ts';
+export { Leadership } from './leadership.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/leader-election/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/leader-election/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,qBAAqB,GAC3B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/leader-election/index.js

@@ -0,0 +1,3 @@
+export { LeaderElection, } from "./leader-election.js";
+export { Leadership } from "./leadership.js";
+//# sourceMappingURL=index.js.map

package/dist/leader-election/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/leader-election/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,GAGf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/leader-election/leader-election.d.ts

@@ -0,0 +1,23 @@
+import { Leadership } from './leadership.ts';
+export interface LeaderElectionOptions {
+    /** Milliseconds between attempts while another process leads. */
+    pollInterval?: number;
+}
+export interface CampaignOptions {
+    /** Milliseconds to keep trying before conceding to the current leader. */
+    timeout?: number;
+}
+/**
+ * Elects one leader among the processes sharing `directory`. The claim is an
+ * exclusive SQLite transaction on `leader.lock`, held for the whole term, so the
+ * kernel ends the term if the leader dies. Each term gets a higher epoch than
+ * every term before it, recorded in `leader.epoch`. Never delete `leader.lock`
+ * while campaigners run: a new file would let a second leader win.
+ */
+export declare class LeaderElection {
+    #private;
+    constructor(directory: string, { pollInterval }?: LeaderElectionOptions);
+    /** Resolves with the new term, or `undefined` if another process still leads after `timeout`. */
+    campaign({ timeout }?: CampaignOptions): Promise<Leadership | undefined>;
+}
+//# sourceMappingURL=leader-election.d.ts.map

package/dist/leader-election/leader-election.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leader-election.d.ts","sourceRoot":"","sources":["../../src/leader-election/leader-election.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,MAAM,WAAW,qBAAqB;IACpC,iEAAiE;IACjE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,0EAA0E;IAC1E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,qBAAa,cAAc;;gBAKvB,SAAS,EAAE,MAAM,EACjB,EAAE,YAAiB,EAAE,GAAE,qBAA0B;IAMnD,iGAAiG;IAC3F,QAAQ,CAAC,EAAE,OAAW,EAAE,GAAE,eAAoB,GAAG,OAAO,CAC5D,UAAU,GAAG,SAAS,CACvB;CAwCF"}

package/dist/leader-election/leader-election.js

@@ -0,0 +1,77 @@
+import { mkdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { setTimeout as delay } from 'node:timers/promises';
+import { atomicWrite } from "../shared/fs/atomic-write.js";
+import { isErrno } from "../shared/fs/errno.js";
+import { isBusy } from "../shared/sqlite/is-busy.js";
+import { Leadership } from "./leadership.js";
+/**
+ * Elects one leader among the processes sharing `directory`. The claim is an
+ * exclusive SQLite transaction on `leader.lock`, held for the whole term, so the
+ * kernel ends the term if the leader dies. Each term gets a higher epoch than
+ * every term before it, recorded in `leader.epoch`. Never delete `leader.lock`
+ * while campaigners run: a new file would let a second leader win.
+ */
+export class LeaderElection {
+    #directory;
+    #pollInterval;
+    constructor(directory, { pollInterval = 10 } = {}) {
+        this.#directory = directory;
+        this.#pollInterval = pollInterval;
+    }
+    /** Resolves with the new term, or `undefined` if another process still leads after `timeout`. */
+    async campaign({ timeout = 0 } = {}) {
+        await mkdir(this.#directory, { recursive: true });
+        // A busy timeout above zero would block this process's event loop while it
+        // waits, so the claim is retried here instead.
+        const claim = new DatabaseSync(join(this.#directory, 'leader.lock'), {
+            timeout: 0,
+        });
+        const deadline = performance.now() + timeout;
+        try {
+            for (;;) {
+                if (this.#tryClaim(claim))
+                    return new Leadership(await this.#nextEpoch(), claim);
+                if (performance.now() >= deadline)
+                    break;
+                await delay(this.#pollInterval);
+            }
+        }
+        catch (error) {
+            claim.close();
+            throw error;
+        }
+        claim.close();
+        return undefined;
+    }
+    #tryClaim(claim) {
+        try {
+            claim.exec('BEGIN EXCLUSIVE');
+            return true;
+        }
+        catch (error) {
+            if (isBusy(error))
+                return false;
+            throw error;
+        }
+    }
+    /** Safe without further locking: only the claim holder gets here. */
+    async #nextEpoch() {
+        const path = join(this.#directory, 'leader.epoch');
+        const epoch = (await readEpoch(path)) + 1n;
+        await atomicWrite(path, epoch.toString());
+        return epoch;
+    }
+}
+async function readEpoch(path) {
+    try {
+        return BigInt(await readFile(path, 'utf8'));
+    }
+    catch (error) {
+        if (isErrno(error, 'ENOENT'))
+            return 0n;
+        throw error;
+    }
+}
+//# sourceMappingURL=leader-election.js.map

package/dist/leader-election/leader-election.js.map

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