@zukhruf/mutex 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,14 @@
+import type { DatabaseSync } from 'node:sqlite';
+/**
+ * One term as leader. It lasts until `resign` or until the process dies, when
+ * the kernel releases the claim and another campaigner can win.
+ */
+export declare class Leadership implements AsyncDisposable {
+    #private;
+    /** Grows with every term, so a newer leader can always outrank an older one. */
+    readonly epoch: bigint;
+    constructor(epoch: bigint, claim: DatabaseSync);
+    resign(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+//# sourceMappingURL=leadership.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"leadership.d.ts","sourceRoot":"","sources":["../../src/leader-election/leadership.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;GAGG;AACH,qBAAa,UAAW,YAAW,eAAe;;IAChD,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAGX,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY;IAKxC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAM7B,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;CAGvC"}

package/dist/leader-election/leadership.js

@@ -0,0 +1,23 @@
+/**
+ * One term as leader. It lasts until `resign` or until the process dies, when
+ * the kernel releases the claim and another campaigner can win.
+ */
+export class Leadership {
+    /** Grows with every term, so a newer leader can always outrank an older one. */
+    epoch;
+    #claim;
+    constructor(epoch, claim) {
+        this.epoch = epoch;
+        this.#claim = claim;
+    }
+    async resign() {
+        if (!this.#claim.isOpen)
+            return;
+        this.#claim.exec('ROLLBACK');
+        this.#claim.close();
+    }
+    [Symbol.asyncDispose]() {
+        return this.resign();
+    }
+}
+//# sourceMappingURL=leadership.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"leadership.js","sourceRoot":"","sources":["../../src/leader-election/leadership.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,OAAO,UAAU;IACrB,gFAAgF;IACvE,KAAK,CAAS;IACd,MAAM,CAAe;IAE9B,YAAY,KAAa,EAAE,KAAmB;QAC5C,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,MAAM;QACV,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM;YAAE,OAAO;QAChC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAED,CAAC,MAAM,CAAC,YAAY,CAAC;QACnB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;IACvB,CAAC;CACF"}

package/dist/lock-stores/file-system/file-lock-store.d.ts

@@ -0,0 +1,35 @@
+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 FileLockStoreOptions {
+    /** Milliseconds a waiter sleeps between attempts. */
+    pollInterval?: number;
+    /** Defaults to durable per-key counter files beside the locks. */
+    tokens?: TokenSource;
+}
+export interface PollOptions {
+    /** Stops between attempts when it aborts; the poll then rejects with `signal.reason`. */
+    signal?: AbortSignal | undefined;
+    /** Whether the wait between attempts keeps the process alive. */
+    keepAlive?: boolean;
+}
+/** Shares one lock directory between processes: each key maps to `<directory>/<key>.lock`. */
+export declare abstract class FileLockStore implements LockStore {
+    #private;
+    constructor(directory: string, { pollInterval, tokens, }?: FileLockStoreOptions);
+    acquire(key: string, { signal }?: AcquireOptions): Promise<Lease>;
+    tryAcquire(key: string): Promise<Lease | undefined>;
+    /** Holds the lock at `path`, waiting for other holders, until `signal` aborts. */
+    protected abstract lock(path: string, signal: AbortSignal | undefined): Promise<AsyncDisposable>;
+    /** Holds the lock at `path` only if no other holder has it now. */
+    protected abstract tryLock(path: string): Promise<AsyncDisposable | undefined>;
+    protected poll<T>(attempt: () => Promise<T | undefined>, { signal, keepAlive }?: PollOptions): Promise<T>;
+    /**
+     * Serializes evicting a dead holder. Without it, two waiters that saw the
+     * same dead holder could each remove a lock the other had just taken.
+     * A process dying inside `task` leaves `<path>.reclaim` behind, which then
+     * has to be removed by hand.
+     */
+    protected withReclaimLock(path: string, task: () => Promise<void>): Promise<void>;
+}
+//# sourceMappingURL=file-lock-store.d.ts.map

package/dist/lock-stores/file-system/file-lock-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-lock-store.d.ts","sourceRoot":"","sources":["../../../src/lock-stores/file-system/file-lock-store.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,KAAK,KAAK,EAAY,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAK3E,MAAM,WAAW,oBAAoB;IACnC,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kEAAkE;IAClE,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,yFAAyF;IACzF,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IACjC,iEAAiE;IACjE,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,8FAA8F;AAC9F,8BAAsB,aAAc,YAAW,SAAS;;gBAMpD,SAAS,EAAE,MAAM,EACjB,EACE,YAAiB,EACjB,MAAuC,GACxC,GAAE,oBAAyB;IAOxB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,GAAE,cAAmB,GAAG,OAAO,CAAC,KAAK,CAAC;IAMrE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC;IAKzD,kFAAkF;IAClF,SAAS,CAAC,QAAQ,CAAC,IAAI,CACrB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,eAAe,CAAC;IAE3B,mEAAmE;IACnE,SAAS,CAAC,QAAQ,CAAC,OAAO,CACxB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;cAEvB,IAAI,CAAC,CAAC,EACpB,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,EACrC,EAAE,MAAM,EAAE,SAAgB,EAAE,GAAE,WAAgB,GAC7C,OAAO,CAAC,CAAC,CAAC;IAab;;;;;OAKG;cACa,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC;CAcxE"}

package/dist/lock-stores/file-system/file-lock-store.js

@@ -0,0 +1,64 @@
+import { mkdir, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { FileTokenSource } from "../../fencing/file-token-source.js";
+import { leaseFor } from "../../mutex/lease.js";
+import { createExclusive } from "../../shared/fs/create-exclusive.js";
+import { safeFileName } from "../../shared/fs/safe-file-name.js";
+import { Owner } from "./owner.js";
+/** Shares one lock directory between processes: each key maps to `<directory>/<key>.lock`. */
+export class FileLockStore {
+    #directory;
+    #pollInterval;
+    #tokens;
+    constructor(directory, { pollInterval = 10, tokens = new FileTokenSource(directory), } = {}) {
+        this.#directory = directory;
+        this.#pollInterval = pollInterval;
+        this.#tokens = tokens;
+    }
+    async acquire(key, { signal } = {}) {
+        signal?.throwIfAborted();
+        const held = await this.lock(await this.#pathFor(key), signal);
+        return leaseFor(key, held, this.#tokens);
+    }
+    async tryAcquire(key) {
+        const held = await this.tryLock(await this.#pathFor(key));
+        return held && leaseFor(key, held, this.#tokens);
+    }
+    async poll(attempt, { signal, keepAlive = true } = {}) {
+        for (;;) {
+            const result = await attempt();
+            if (result !== undefined)
+                return result;
+            try {
+                await delay(this.#pollInterval, undefined, { signal, ref: keepAlive });
+            }
+            catch (error) {
+                signal?.throwIfAborted();
+                throw error;
+            }
+        }
+    }
+    /**
+     * Serializes evicting a dead holder. Without it, two waiters that saw the
+     * same dead holder could each remove a lock the other had just taken.
+     * A process dying inside `task` leaves `<path>.reclaim` behind, which then
+     * has to be removed by hand.
+     */
+    async withReclaimLock(path, task) {
+        const reclaim = `${path}.reclaim`;
+        if (!(await createExclusive(reclaim, Owner.current().serialize())))
+            return;
+        try {
+            await task();
+        }
+        finally {
+            await unlink(reclaim);
+        }
+    }
+    async #pathFor(key) {
+        await mkdir(this.#directory, { recursive: true });
+        return join(this.#directory, `${safeFileName(key)}.lock`);
+    }
+}
+//# sourceMappingURL=file-lock-store.js.map

package/dist/lock-stores/file-system/file-lock-store.js.map

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

package/dist/lock-stores/file-system/lock-file-store.d.ts

@@ -0,0 +1,11 @@
+import { FileLockStore } from './file-lock-store.ts';
+/**
+ * Whoever creates the lock file holds the key; releasing deletes it. Waiters
+ * retry in no particular order, so this store is not FIFO.
+ */
+export declare class LockFileStore extends FileLockStore {
+    #private;
+    protected lock(path: string, signal: AbortSignal | undefined): Promise<AsyncDisposable>;
+    protected tryLock(path: string): Promise<AsyncDisposable | undefined>;
+}
+//# sourceMappingURL=lock-file-store.d.ts.map

package/dist/lock-stores/file-system/lock-file-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-file-store.d.ts","sourceRoot":"","sources":["../../../src/lock-stores/file-system/lock-file-store.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGrD;;;GAGG;AACH,qBAAa,aAAc,SAAQ,aAAa;;IAC9C,SAAS,CAAC,IAAI,CACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,eAAe,CAAC;cAKX,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;CAsB5E"}

package/dist/lock-stores/file-system/lock-file-store.js

@@ -0,0 +1,44 @@
+import { readFile, unlink } from 'node:fs/promises';
+import { createExclusive } from "../../shared/fs/create-exclusive.js";
+import { isErrno } from "../../shared/fs/errno.js";
+import { FileLockStore } from "./file-lock-store.js";
+import { Owner } from "./owner.js";
+/**
+ * Whoever creates the lock file holds the key; releasing deletes it. Waiters
+ * retry in no particular order, so this store is not FIFO.
+ */
+export class LockFileStore extends FileLockStore {
+    lock(path, signal) {
+        const me = Owner.current();
+        return this.poll(() => this.#attempt(path, me), { signal });
+    }
+    async tryLock(path) {
+        const me = Owner.current();
+        // An attempt that finds a dead holder removes it, so one more attempt can then succeed.
+        return (await this.#attempt(path, me)) ?? this.#attempt(path, me);
+    }
+    async #attempt(path, me) {
+        if (await createExclusive(path, me.serialize())) {
+            return { [Symbol.asyncDispose]: () => unlink(path) };
+        }
+        const holder = await readHolder(path);
+        if (holder && !holder.isAlive()) {
+            await this.withReclaimLock(path, async () => {
+                if ((await readHolder(path))?.id === holder.id)
+                    await unlink(path);
+            });
+        }
+        return undefined;
+    }
+}
+async function readHolder(path) {
+    try {
+        return Owner.parse(await readFile(path, 'utf8'));
+    }
+    catch (error) {
+        if (isErrno(error, 'ENOENT'))
+            return undefined;
+        throw error;
+    }
+}
+//# sourceMappingURL=lock-file-store.js.map

package/dist/lock-stores/file-system/lock-file-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-file-store.js","sourceRoot":"","sources":["../../../src/lock-stores/file-system/lock-file-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AACtE,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC;;;GAGG;AACH,MAAM,OAAO,aAAc,SAAQ,aAAa;IACpC,IAAI,CACZ,IAAY,EACZ,MAA+B;QAE/B,MAAM,EAAE,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;QAC3B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;IAC9D,CAAC;IAES,KAAK,CAAC,OAAO,CAAC,IAAY;QAClC,MAAM,EAAE,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;QAC3B,wFAAwF;QACxF,OAAO,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IACpE,CAAC;IAED,KAAK,CAAC,QAAQ,CACZ,IAAY,EACZ,EAAS;QAET,IAAI,MAAM,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC,SAAS,EAAE,CAAC,EAAE,CAAC;YAChD,OAAO,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QACvD,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,CAAC;YAChC,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,KAAK,IAAI,EAAE;gBAC1C,IAAI,CAAC,MAAM,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,KAAK,MAAM,CAAC,EAAE;oBAAE,MAAM,MAAM,CAAC,IAAI,CAAC,CAAC;YACrE,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;CACF;AAED,KAAK,UAAU,UAAU,CAAC,IAAY;IACpC,IAAI,CAAC;QACH,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC;YAAE,OAAO,SAAS,CAAC;QAC/C,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/lock-stores/file-system/owner.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Identifies one lock request and the process that made it, so waiters can
+ * evict a holder whose process died. A reused pid only delays recovery; it
+ * never breaks exclusion. Holders on another host are never evicted.
+ */
+export declare class Owner {
+    readonly pid: number;
+    readonly host: string;
+    readonly id: string;
+    constructor(pid: number, host: string, id: string);
+    static current(): Owner;
+    static parse(serialized: string): Owner;
+    serialize(): string;
+    isAlive(): boolean;
+}
+//# sourceMappingURL=owner.d.ts.map

package/dist/lock-stores/file-system/owner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"owner.d.ts","sourceRoot":"","sources":["../../../src/lock-stores/file-system/owner.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,qBAAa,KAAK;IAChB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;gBAER,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAMjD,MAAM,CAAC,OAAO,IAAI,KAAK;IAIvB,MAAM,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK;IAavC,SAAS,IAAI,MAAM;IAInB,OAAO,IAAI,OAAO;CASnB"}

package/dist/lock-stores/file-system/owner.js

@@ -0,0 +1,47 @@
+import { randomUUID } from 'node:crypto';
+import { hostname } from 'node:os';
+import { isErrno } from "../../shared/fs/errno.js";
+import { isRecord } from "../../shared/is-record.js";
+/**
+ * Identifies one lock request and the process that made it, so waiters can
+ * evict a holder whose process died. A reused pid only delays recovery; it
+ * never breaks exclusion. Holders on another host are never evicted.
+ */
+export class Owner {
+    pid;
+    host;
+    id;
+    constructor(pid, host, id) {
+        this.pid = pid;
+        this.host = host;
+        this.id = id;
+    }
+    static current() {
+        return new Owner(process.pid, hostname(), randomUUID());
+    }
+    static parse(serialized) {
+        const parsed = JSON.parse(serialized);
+        if (!isRecord(parsed) ||
+            typeof parsed.pid !== 'number' ||
+            typeof parsed.host !== 'string' ||
+            typeof parsed.id !== 'string') {
+            throw new SyntaxError(`Not a lock owner: ${serialized}`);
+        }
+        return new Owner(parsed.pid, parsed.host, parsed.id);
+    }
+    serialize() {
+        return JSON.stringify({ pid: this.pid, host: this.host, id: this.id });
+    }
+    isAlive() {
+        if (this.host !== hostname())
+            return true;
+        try {
+            process.kill(this.pid, 0);
+            return true;
+        }
+        catch (error) {
+            return !isErrno(error, 'ESRCH');
+        }
+    }
+}
+//# sourceMappingURL=owner.js.map

package/dist/lock-stores/file-system/owner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"owner.js","sourceRoot":"","sources":["../../../src/lock-stores/file-system/owner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAErD;;;;GAIG;AACH,MAAM,OAAO,KAAK;IACP,GAAG,CAAS;IACZ,IAAI,CAAS;IACb,EAAE,CAAS;IAEpB,YAAY,GAAW,EAAE,IAAY,EAAE,EAAU;QAC/C,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACf,CAAC;IAED,MAAM,CAAC,OAAO;QACZ,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,UAAkB;QAC7B,MAAM,MAAM,GAAY,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC/C,IACE,CAAC,QAAQ,CAAC,MAAM,CAAC;YACjB,OAAO,MAAM,CAAC,GAAG,KAAK,QAAQ;YAC9B,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ;YAC/B,OAAO,MAAM,CAAC,EAAE,KAAK,QAAQ,EAC7B,CAAC;YACD,MAAM,IAAI,WAAW,CAAC,qBAAqB,UAAU,EAAE,CAAC,CAAC;QAC3D,CAAC;QACD,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;IACvD,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;IACzE,CAAC;IAED,OAAO;QACL,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE;YAAE,OAAO,IAAI,CAAC;QAC1C,IAAI,CAAC;YACH,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;YAC1B,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;CACF"}

package/dist/lock-stores/file-system/ticket-queue-file-store.d.ts

@@ -0,0 +1,16 @@
+import { FileLockStore } from './file-lock-store.ts';
+/**
+ * FIFO queue in one file: each waiter appends its ticket line and holds the
+ * lock once its ticket is first.
+ *
+ * Appends are atomic (O_APPEND), and the file is only ever replaced by the
+ * live head releasing or by the reclaim-lock holder evicting a dead head, so
+ * two rewrites never race. A rewrite racing an append can drop that ticket;
+ * its waiter notices and appends it again.
+ */
+export declare class TicketQueueFileStore extends FileLockStore {
+    #private;
+    protected lock(path: string, signal: AbortSignal | undefined): Promise<AsyncDisposable>;
+    protected tryLock(path: string): Promise<AsyncDisposable | undefined>;
+}
+//# sourceMappingURL=ticket-queue-file-store.d.ts.map

package/dist/lock-stores/file-system/ticket-queue-file-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ticket-queue-file-store.d.ts","sourceRoot":"","sources":["../../../src/lock-stores/file-system/ticket-queue-file-store.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGrD;;;;;;;;GAQG;AACH,qBAAa,oBAAqB,SAAQ,aAAa;;cACrC,IAAI,CAClB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,eAAe,CAAC;cAWX,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;CA6D5E"}

package/dist/lock-stores/file-system/ticket-queue-file-store.js

@@ -0,0 +1,111 @@
+import { appendFile, readFile } from 'node:fs/promises';
+import { atomicWrite } from "../../shared/fs/atomic-write.js";
+import { isErrno } from "../../shared/fs/errno.js";
+import { FileLockStore } from "./file-lock-store.js";
+import { Owner } from "./owner.js";
+/**
+ * FIFO queue in one file: each waiter appends its ticket line and holds the
+ * lock once its ticket is first.
+ *
+ * Appends are atomic (O_APPEND), and the file is only ever replaced by the
+ * live head releasing or by the reclaim-lock holder evicting a dead head, so
+ * two rewrites never race. A rewrite racing an append can drop that ticket;
+ * its waiter notices and appends it again.
+ */
+export class TicketQueueFileStore extends FileLockStore {
+    async lock(path, signal) {
+        const me = Owner.current();
+        await enqueue(path, me);
+        try {
+            return await this.poll(() => this.#attempt(path, me), { signal });
+        }
+        catch (error) {
+            this.#leaveWhenFirst(path, me);
+            throw error;
+        }
+    }
+    async tryLock(path) {
+        const [head] = await readTickets(path);
+        await this.#evictIfDead(path, head);
+        if ((await readTickets(path)).length > 0)
+            return undefined;
+        const me = Owner.current();
+        await enqueue(path, me);
+        const [first] = await readTickets(path);
+        if (first?.id === me.id)
+            return holding(path, me);
+        // Another waiter appended at the same moment and is first.
+        this.#leaveWhenFirst(path, me);
+        return undefined;
+    }
+    async #evictIfDead(path, head) {
+        if (head && !head.isAlive()) {
+            await this.withReclaimLock(path, () => evictDeadHead(path));
+        }
+    }
+    async #attempt(path, me) {
+        const tickets = await readTickets(path);
+        if (!tickets.some((ticket) => ticket.id === me.id)) {
+            await enqueue(path, me);
+            return undefined;
+        }
+        const [head] = tickets;
+        if (head?.id === me.id)
+            return holding(path, me);
+        await this.#evictIfDead(path, head);
+        return undefined;
+    }
+    /**
+     * A waiter that gives up cannot remove its ticket: only the head may
+     * rewrite the queue. So its ticket stays in line, and this removes it when
+     * it reaches the head. The wait does not keep the process alive; if the
+     * process stops first, waiters evict the ticket as a dead head.
+     */
+    #leaveWhenFirst(path, me) {
+        this.poll(async () => {
+            const tickets = await readTickets(path);
+            if (!tickets.some((ticket) => ticket.id === me.id))
+                return true;
+            const [head] = tickets;
+            if (head?.id === me.id) {
+                await removeTicket(path, me);
+                return true;
+            }
+            await this.#evictIfDead(path, head);
+            return undefined;
+        }, { keepAlive: false }).catch(() => {
+            // The directory is gone, so the ticket is gone too.
+        });
+    }
+}
+function holding(path, me) {
+    return { [Symbol.asyncDispose]: () => removeTicket(path, me) };
+}
+async function removeTicket(path, me) {
+    const remaining = await readTickets(path);
+    await replace(path, remaining.filter((ticket) => ticket.id !== me.id));
+}
+async function evictDeadHead(path) {
+    const [head, ...rest] = await readTickets(path);
+    if (head && !head.isAlive())
+        await replace(path, rest);
+}
+async function enqueue(path, owner) {
+    await appendFile(path, `${owner.serialize()}\n`);
+}
+async function readTickets(path) {
+    try {
+        const content = await readFile(path, 'utf8');
+        // The last segment is empty or a ticket still being appended.
+        return content.split('\n').slice(0, -1).map(Owner.parse);
+    }
+    catch (error) {
+        if (isErrno(error, 'ENOENT'))
+            return [];
+        throw error;
+    }
+}
+async function replace(path, tickets) {
+    await atomicWrite(path, tickets.map((ticket) => `${ticket.serialize()}\n`).join(''));
+}
+//# sourceMappingURL=ticket-queue-file-store.js.map

package/dist/lock-stores/file-system/ticket-queue-file-store.js.map

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

package/dist/lock-stores/ipc/child-process-connection.d.ts

@@ -0,0 +1,18 @@
+import type { ChildProcess } from 'node:child_process';
+import type { Connection, ConnectionHandlers } from '../remote/connection.ts';
+import { type LockRequest, type LockResponse } from '../remote/protocol.ts';
+/**
+ * The parent's end of the IPC channel to one child. The kernel closes the
+ * channel when the child dies, so `disconnect` reports even a SIGKILL.
+ */
+export declare class ChildProcessConnection implements Connection<LockResponse, LockRequest> {
+    #private;
+    constructor(child: ChildProcess);
+    send(response: LockResponse): Promise<void>;
+    listen({ message, close }: ConnectionHandlers<LockRequest>): void;
+    /** The running child already keeps the parent alive. */
+    ref(): void;
+    unref(): void;
+    close(): void;
+}
+//# sourceMappingURL=child-process-connection.d.ts.map

package/dist/lock-stores/ipc/child-process-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-process-connection.d.ts","sourceRoot":"","sources":["../../../src/lock-stores/ipc/child-process-connection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,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;;;GAGG;AACH,qBAAa,sBAAuB,YAAW,UAAU,CACvD,YAAY,EACZ,WAAW,CACZ;;gBAIa,KAAK,EAAE,YAAY;IAI/B,IAAI,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAY3C,MAAM,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,kBAAkB,CAAC,WAAW,CAAC;IAiB1D,wDAAwD;IACxD,GAAG;IAEH,KAAK;IAEL,KAAK;CAGN"}

package/dist/lock-stores/ipc/child-process-connection.js

@@ -0,0 +1,46 @@
+import { unwrap, wrap } from "../remote/envelope.js";
+import { isLockRequest, } from "../remote/protocol.js";
+/**
+ * The parent's end of the IPC channel to one child. The kernel closes the
+ * channel when the child dies, so `disconnect` reports even a SIGKILL.
+ */
+export class ChildProcessConnection {
+    #child;
+    #detach = () => { };
+    constructor(child) {
+        this.#child = child;
+    }
+    send(response) {
+        return new Promise((resolve, reject) => {
+            if (!this.#child.connected) {
+                reject(new Error('The child process has disconnected.'));
+                return;
+            }
+            this.#child.send(wrap(response), (error) => error ? reject(error) : resolve());
+        });
+    }
+    listen({ message, close }) {
+        const onMessage = (envelope) => {
+            const request = unwrap(envelope);
+            if (isLockRequest(request))
+                message(request);
+        };
+        const onDisconnect = () => {
+            this.close();
+            close();
+        };
+        this.#child.on('message', onMessage);
+        this.#child.once('disconnect', onDisconnect);
+        this.#detach = () => {
+            this.#child.off('message', onMessage);
+            this.#child.off('disconnect', onDisconnect);
+        };
+    }
+    /** The running child already keeps the parent alive. */
+    ref() { }
+    unref() { }
+    close() {
+        this.#detach();
+    }
+}
+//# sourceMappingURL=child-process-connection.js.map

package/dist/lock-stores/ipc/child-process-connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-process-connection.js","sourceRoot":"","sources":["../../../src/lock-stores/ipc/child-process-connection.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAGL,aAAa,GACd,MAAM,uBAAuB,CAAC;AAE/B;;;GAGG;AACH,MAAM,OAAO,sBAAsB;IAIxB,MAAM,CAAe;IAC9B,OAAO,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;IAEnB,YAAY,KAAmB;QAC7B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED,IAAI,CAAC,QAAsB;QACzB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;gBAC3B,MAAM,CAAC,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC,CAAC;gBACzD,OAAO;YACT,CAAC;YACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CACzC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAClC,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,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,YAAY,GAAG,GAAG,EAAE;YACxB,IAAI,CAAC,KAAK,EAAE,CAAC;YACb,KAAK,EAAE,CAAC;QACV,CAAC,CAAC;QACF,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QACrC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;QAC7C,IAAI,CAAC,OAAO,GAAG,GAAG,EAAE;YAClB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;YACtC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;QAC9C,CAAC,CAAC;IACJ,CAAC;IAED,wDAAwD;IACxD,GAAG,KAAI,CAAC;IAER,KAAK,KAAI,CAAC;IAEV,KAAK;QACH,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;CACF"}

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

@@ -0,0 +1,24 @@
+import type { ChildProcess } from 'node:child_process';
+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 IpcLockCoordinatorOptions {
+    /** Defaults to an in-memory counter, which lives as long as this process. */
+    tokens?: TokenSource;
+}
+/**
+ * The parent side of IPC locking: grants keys to this process and to every
+ * child it adopts, which use `IpcStore`. Its reach is one process tree.
+ */
+export declare class IpcLockCoordinator implements LockStore {
+    #private;
+    constructor({ tokens, }?: IpcLockCoordinatorOptions);
+    acquire(key: string, options?: AcquireOptions): Promise<Lease>;
+    tryAcquire(key: string): Promise<Lease | undefined>;
+    /**
+     * Serves `child`, which must have an IPC channel. When the child exits,
+     * everything it held or waited for is released.
+     */
+    adopt(child: ChildProcess): void;
+}
+//# sourceMappingURL=ipc-lock-coordinator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ipc-lock-coordinator.d.ts","sourceRoot":"","sources":["../../../src/lock-stores/ipc/ipc-lock-coordinator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvD,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,yBAAyB;IACxC,6EAA6E;IAC7E,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;GAGG;AACH,qBAAa,kBAAmB,YAAW,SAAS;;gBAGtC,EACV,MAAiC,GAClC,GAAE,yBAA8B;IAIjC,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;;;OAGG;IACH,KAAK,CAAC,KAAK,EAAE,YAAY;CAG1B"}

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

@@ -0,0 +1,27 @@
+import { CounterTokenSource } from "../../fencing/counter-token-source.js";
+import { LockCoordinator } from "../remote/lock-coordinator.js";
+import { ChildProcessConnection } from "./child-process-connection.js";
+/**
+ * The parent side of IPC locking: grants keys to this process and to every
+ * child it adopts, which use `IpcStore`. Its reach is one process tree.
+ */
+export class IpcLockCoordinator {
+    #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 `child`, which must have an IPC channel. When the child exits,
+     * everything it held or waited for is released.
+     */
+    adopt(child) {
+        this.#coordinator.serve(new ChildProcessConnection(child));
+    }
+}
+//# sourceMappingURL=ipc-lock-coordinator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ipc-lock-coordinator.js","sourceRoot":"","sources":["../../../src/lock-stores/ipc/ipc-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,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAOvE;;;GAGG;AACH,MAAM,OAAO,kBAAkB;IACpB,YAAY,CAAkB;IAEvC,YAAY,EACV,MAAM,GAAG,IAAI,kBAAkB,EAAE,MACJ,EAAE;QAC/B,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;;;OAGG;IACH,KAAK,CAAC,KAAmB;QACvB,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,sBAAsB,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7D,CAAC;CACF"}

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

@@ -0,0 +1,15 @@
+import type { Lease } from '../../mutex/lease.ts';
+import type { AcquireOptions, LockStore } from '../../mutex/lock-store.ts';
+/**
+ * The child-process side of `IpcLockCoordinator`: asks the parent for keys over
+ * the IPC channel. If the parent dies, waiting acquires reject with
+ * `CoordinatorUnavailableError`; held keys stay exclusive, because no
+ * coordinator is left to grant them to anyone else.
+ */
+export declare class IpcStore implements LockStore {
+    #private;
+    constructor();
+    acquire(key: string, options?: AcquireOptions): Promise<Lease>;
+    tryAcquire(key: string): Promise<Lease | undefined>;
+}
+//# sourceMappingURL=ipc-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ipc-store.d.ts","sourceRoot":"","sources":["../../../src/lock-stores/ipc/ipc-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAgB3E;;;;;GAKG;AACH,qBAAa,QAAS,YAAW,SAAS;;;IAYxC,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/ipc/ipc-store.js

@@ -0,0 +1,34 @@
+import { RemoteLockClient } from "../remote/remote-lock-client.js";
+import { ProcessChannelConnection } from "./process-channel-connection.js";
+/** The channel to the parent cannot be re-established, so it is handed out once. */
+class ProcessChannelConnector {
+    #handedOut = false;
+    async connect() {
+        if (this.#handedOut || !process.connected)
+            return undefined;
+        this.#handedOut = true;
+        return new ProcessChannelConnection();
+    }
+}
+/**
+ * The child-process side of `IpcLockCoordinator`: asks the parent for keys over
+ * the IPC channel. If the parent dies, waiting acquires reject with
+ * `CoordinatorUnavailableError`; held keys stay exclusive, because no
+ * coordinator is left to grant them to anyone else.
+ */
+export class IpcStore {
+    #client;
+    constructor() {
+        if (!process.send) {
+            throw new Error('IpcStore needs an IPC channel to its parent; start this process with fork() or an "ipc" stdio entry.');
+        }
+        this.#client = new RemoteLockClient(new ProcessChannelConnector());
+    }
+    acquire(key, options) {
+        return this.#client.acquire(key, options);
+    }
+    tryAcquire(key) {
+        return this.#client.tryAcquire(key);
+    }
+}
+//# sourceMappingURL=ipc-store.js.map