@zukhruf/mutex 0.0.0-stage → 0.2.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"lock-lost-error.d.ts","sourceRoot":"","sources":["../../src/mutex/lock-lost-error.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;gBAET,GAAG,EAAE,MAAM;CAOxB"}

package/dist/mutex/lock-lost-error.js

@@ -0,0 +1,10 @@
+/** The key may have been granted to another holder while this lease was still in use. */
+export class LockLostError extends Error {
+    key;
+    constructor(key) {
+        super(`Lost the lock on ${JSON.stringify(key)}: another holder may have been granted it.`);
+        this.name = 'LockLostError';
+        this.key = key;
+    }
+}
+//# sourceMappingURL=lock-lost-error.js.map

package/dist/mutex/lock-lost-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-lost-error.js","sourceRoot":"","sources":["../../src/mutex/lock-lost-error.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,MAAM,OAAO,aAAc,SAAQ,KAAK;IAC7B,GAAG,CAAS;IAErB,YAAY,GAAW;QACrB,KAAK,CACH,oBAAoB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,4CAA4C,CACpF,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;QAC5B,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;CACF"}

package/dist/mutex/lock-store.d.ts

@@ -0,0 +1,13 @@
+import type { Lease } from './lease.ts';
+export interface AcquireOptions {
+    /** Stops waiting when it aborts; the call then rejects with `signal.reason`. */
+    signal?: AbortSignal | undefined;
+}
+/** Where a mutex keeps its locks; each implementation decides who can share them. */
+export interface LockStore {
+    /** Resolves once `key` is exclusively held. */
+    acquire(key: string, options?: AcquireOptions): Promise<Lease>;
+    /** Holds `key` only if that is possible without waiting for another holder. */
+    tryAcquire(key: string): Promise<Lease | undefined>;
+}
+//# sourceMappingURL=lock-store.d.ts.map

package/dist/mutex/lock-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-store.d.ts","sourceRoot":"","sources":["../../src/mutex/lock-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,WAAW,cAAc;IAC7B,gFAAgF;IAChF,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;CAClC;AAED,qFAAqF;AACrF,MAAM,WAAW,SAAS;IACxB,+CAA+C;IAC/C,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC/D,+EAA+E;IAC/E,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;CACrD"}

package/dist/mutex/lock-store.js

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

package/dist/mutex/lock-store.js.map

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

package/dist/mutex/mutex.d.ts

@@ -0,0 +1,25 @@
+import type { AcquireMode, Outcome, OutcomeResults } from './acquire-mode.ts';
+import { Key } from './key.ts';
+import type { Lease } from './lease.ts';
+import type { LockStore } from './lock-store.ts';
+export declare class Mutex {
+    #private;
+    constructor(store: LockStore);
+    /** Runs `task` while holding `key`, and waits while the key is busy. */
+    acquire<T>(key: string, task: (lease: Lease) => Promise<T>, options?: {
+        mode?: undefined;
+    }): Promise<T>;
+    /** Runs `task` while holding `key`. The acquire mode decides what happens while the key is busy. */
+    acquire<T, O extends Outcome>(key: string, task: (lease: Lease) => Promise<T>, options: {
+        mode: AcquireMode<O>;
+    }): Promise<OutcomeResults<T>[O]>;
+    /** A key whose callers wait, unless one call says otherwise. */
+    key(name: string, options?: {
+        mode?: undefined;
+    }): Key<'always'>;
+    /** A key whose callers use `mode`, unless one call says otherwise. */
+    key<O extends Outcome>(name: string, options: {
+        mode: AcquireMode<O>;
+    }): Key<O>;
+}
+//# sourceMappingURL=mutex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mutex.d.ts","sourceRoot":"","sources":["../../src/mutex/mutex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE9E,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAoBjD,qBAAa,KAAK;;gBAGJ,KAAK,EAAE,SAAS;IAI5B,wEAAwE;IACxE,OAAO,CAAC,CAAC,EACP,GAAG,EAAE,MAAM,EACX,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;IACb,oGAAoG;IACpG,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,OAAO,EAC1B,GAAG,EAAE,MAAM,EACX,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;IAWhC,gEAAgE;IAChE,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,SAAS,CAAA;KAAE,GAAG,GAAG,CAAC,QAAQ,CAAC;IAChE,sEAAsE;IACtE,GAAG,CAAC,CAAC,SAAS,OAAO,EACnB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE;QAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;KAAE,GAChC,GAAG,CAAC,CAAC,CAAC;CAuBV"}

package/dist/mutex/mutex.js

@@ -0,0 +1,41 @@
+import { WaitMode } from "./acquire-modes/wait-mode.js";
+import { Key } from "./key.js";
+const wait = new WaitMode();
+const ran = (value) => ({
+    always: value,
+    maybe: { acquired: true, value },
+});
+// Only a mode that may give up can end without a lease. A mode whose outcome
+// is 'always' and gives up breaks its contract, so reading its result throws.
+const gaveUp = (key) => ({
+    get always() {
+        throw new Error(`An acquire mode whose outcome is 'always' gave up on key "${key}".`);
+    },
+    maybe: { acquired: false },
+});
+export class Mutex {
+    #store;
+    constructor(store) {
+        this.#store = store;
+    }
+    acquire(key, task, { mode } = {}) {
+        return mode === undefined
+            ? this.#run(key, task, wait)
+            : this.#run(key, task, mode);
+    }
+    key(name, { mode } = {}) {
+        return mode === undefined
+            ? new Key(this, name, wait)
+            : new Key(this, name, mode);
+    }
+    // `mode.outcome` has the type O, so TypeScript checks each result below
+    // against OutcomeResults<T>[O] and needs no type assertion.
+    async #run(key, task, mode) {
+        const lease = await mode.acquire(this.#store, key);
+        if (!lease)
+            return gaveUp(key)[mode.outcome];
+        await using held = lease;
+        return ran(await task(held))[mode.outcome];
+    }
+}
+//# sourceMappingURL=mutex.js.map

package/dist/mutex/mutex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutex.js","sourceRoot":"","sources":["../../src/mutex/mutex.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACxD,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAI/B,MAAM,IAAI,GAAG,IAAI,QAAQ,EAAE,CAAC;AAE5B,MAAM,GAAG,GAAG,CAAI,KAAQ,EAAqB,EAAE,CAAC,CAAC;IAC/C,MAAM,EAAE,KAAK;IACb,KAAK,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE;CACjC,CAAC,CAAC;AAEH,6EAA6E;AAC7E,8EAA8E;AAC9E,MAAM,MAAM,GAAG,CAAI,GAAW,EAAqB,EAAE,CAAC,CAAC;IACrD,IAAI,MAAM;QACR,MAAM,IAAI,KAAK,CACb,6DAA6D,GAAG,IAAI,CACrE,CAAC;IACJ,CAAC;IACD,KAAK,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE;CAC3B,CAAC,CAAC;AAEH,MAAM,OAAO,KAAK;IACP,MAAM,CAAY;IAE3B,YAAY,KAAgB;QAC1B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAcD,OAAO,CACL,GAAW,EACX,IAAkC,EAClC,EAAE,IAAI,KAA4C,EAAE;QAEpD,OAAO,IAAI,KAAK,SAAS;YACvB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC;YAC5B,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IACjC,CAAC;IASD,GAAG,CACD,IAAY,EACZ,EAAE,IAAI,KAA4C,EAAE;QAEpD,OAAO,IAAI,KAAK,SAAS;YACvB,CAAC,CAAC,IAAI,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;YAC3B,CAAC,CAAC,IAAI,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;IAChC,CAAC;IAED,wEAAwE;IACxE,4DAA4D;IAC5D,KAAK,CAAC,IAAI,CACR,GAAW,EACX,IAAkC,EAClC,IAAoB;QAEpB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QACnD,IAAI,CAAC,KAAK;YAAE,OAAO,MAAM,CAAI,GAAG,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAEhD,YAAY,IAAI,GAAG,KAAK,CAAC;QACzB,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7C,CAAC;CACF"}

package/dist/shared/fs/atomic-write.d.ts

@@ -0,0 +1,3 @@
+/** Replaces `path` in one step, so readers see the old or the new content, never a partial write. */
+export declare function atomicWrite(path: string, content: string): Promise<void>;
+//# sourceMappingURL=atomic-write.d.ts.map

package/dist/shared/fs/atomic-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-write.d.ts","sourceRoot":"","sources":["../../../src/shared/fs/atomic-write.ts"],"names":[],"mappings":"AASA,qGAAqG;AACrG,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,iBAI9D"}

package/dist/shared/fs/atomic-write.js

@@ -0,0 +1,34 @@
+import { randomUUID } from 'node:crypto';
+import { rename, writeFile } from 'node:fs/promises';
+import { setTimeout as delay } from 'node:timers/promises';
+import { isErrno } from "./errno.js";
+/** How long to retry a rename that Windows refuses while another handle has the target open. */
+const WINDOWS_RENAME_PATIENCE = 1000;
+/** Replaces `path` in one step, so readers see the old or the new content, never a partial write. */
+export async function atomicWrite(path, content) {
+    const draft = `${path}.${randomUUID()}.tmp`;
+    await writeFile(draft, content);
+    await replaceWith(draft, path);
+}
+/**
+ * On Windows, a rename over a file fails while another process has that file
+ * open, for example a waiter that reads it at that moment. The refusal is
+ * brief, so the rename is tried again; it stays the single commit point.
+ */
+async function replaceWith(draft, path) {
+    const started = performance.now();
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await rename(draft, path);
+        }
+        catch (error) {
+            const refusedForNow = process.platform === 'win32' &&
+                ['EPERM', 'EACCES', 'EBUSY'].some((code) => isErrno(error, code));
+            if (!refusedForNow ||
+                performance.now() - started > WINDOWS_RENAME_PATIENCE)
+                throw error;
+            await delay(Math.min(5 * 2 ** attempt, 100));
+        }
+    }
+}
+//# sourceMappingURL=atomic-write.js.map

package/dist/shared/fs/atomic-write.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-write.js","sourceRoot":"","sources":["../../../src/shared/fs/atomic-write.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,UAAU,IAAI,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,gGAAgG;AAChG,MAAM,uBAAuB,GAAG,IAAI,CAAC;AAErC,qGAAqG;AACrG,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,IAAY,EAAE,OAAe;IAC7D,MAAM,KAAK,GAAG,GAAG,IAAI,IAAI,UAAU,EAAE,MAAM,CAAC;IAC5C,MAAM,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAChC,MAAM,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AACjC,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,WAAW,CAAC,KAAa,EAAE,IAAY;IACpD,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;IAClC,KAAK,IAAI,OAAO,GAAG,CAAC,GAAI,OAAO,EAAE,EAAE,CAAC;QAClC,IAAI,CAAC;YACH,OAAO,MAAM,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACnC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,aAAa,GACjB,OAAO,CAAC,QAAQ,KAAK,OAAO;gBAC5B,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;YACpE,IACE,CAAC,aAAa;gBACd,WAAW,CAAC,GAAG,EAAE,GAAG,OAAO,GAAG,uBAAuB;gBAErD,MAAM,KAAK,CAAC;YACd,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/shared/fs/create-exclusive.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates `path` holding `content` unless it already exists. Linking a fully
+ * written file makes creation atomic, so the file is never seen empty.
+ */
+export declare function createExclusive(path: string, content: string): Promise<boolean>;
+//# sourceMappingURL=create-exclusive.d.ts.map

package/dist/shared/fs/create-exclusive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-exclusive.d.ts","sourceRoot":"","sources":["../../../src/shared/fs/create-exclusive.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,oBAYlE"}

package/dist/shared/fs/create-exclusive.js

@@ -0,0 +1,24 @@
+import { randomUUID } from 'node:crypto';
+import { link, unlink, writeFile } from 'node:fs/promises';
+import { isErrno } from "./errno.js";
+/**
+ * Creates `path` holding `content` unless it already exists. Linking a fully
+ * written file makes creation atomic, so the file is never seen empty.
+ */
+export async function createExclusive(path, content) {
+    const draft = `${path}.${randomUUID()}.tmp`;
+    await writeFile(draft, content);
+    try {
+        await link(draft, path);
+        return true;
+    }
+    catch (error) {
+        if (isErrno(error, 'EEXIST'))
+            return false;
+        throw error;
+    }
+    finally {
+        await unlink(draft);
+    }
+}
+//# sourceMappingURL=create-exclusive.js.map

package/dist/shared/fs/create-exclusive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-exclusive.js","sourceRoot":"","sources":["../../../src/shared/fs/create-exclusive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE3D,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,IAAY,EAAE,OAAe;IACjE,MAAM,KAAK,GAAG,GAAG,IAAI,IAAI,UAAU,EAAE,MAAM,CAAC;IAC5C,MAAM,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAChC,IAAI,CAAC;QACH,MAAM,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC;YAAE,OAAO,KAAK,CAAC;QAC3C,MAAM,KAAK,CAAC;IACd,CAAC;YAAS,CAAC;QACT,MAAM,MAAM,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;AACH,CAAC"}

package/dist/shared/fs/errno.d.ts

@@ -0,0 +1,2 @@
+export declare function isErrno(error: unknown, code: string): boolean;
+//# sourceMappingURL=errno.d.ts.map

package/dist/shared/fs/errno.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errno.d.ts","sourceRoot":"","sources":["../../../src/shared/fs/errno.ts"],"names":[],"mappings":"AAAA,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7D"}

package/dist/shared/fs/errno.js

@@ -0,0 +1,4 @@
+export function isErrno(error, code) {
+    return error instanceof Error && 'code' in error && error.code === code;
+}
+//# sourceMappingURL=errno.js.map

package/dist/shared/fs/errno.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errno.js","sourceRoot":"","sources":["../../../src/shared/fs/errno.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,OAAO,CAAC,KAAc,EAAE,IAAY;IAClD,OAAO,KAAK,YAAY,KAAK,IAAI,MAAM,IAAI,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC;AAC1E,CAAC"}

package/dist/shared/fs/safe-file-name.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Maps any key to a single path segment. Encoding every dot means a key can
+ * never be `.` or `..`, and suffixes such as `.lock` can never collide with a key.
+ * On a case-insensitive file system, keys that differ only by case share a
+ * name, which over-locks but never under-locks.
+ */
+export declare function safeFileName(key: string): string;
+//# sourceMappingURL=safe-file-name.d.ts.map

package/dist/shared/fs/safe-file-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-file-name.d.ts","sourceRoot":"","sources":["../../../src/shared/fs/safe-file-name.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/dist/shared/fs/safe-file-name.js

@@ -0,0 +1,10 @@
+/**
+ * Maps any key to a single path segment. Encoding every dot means a key can
+ * never be `.` or `..`, and suffixes such as `.lock` can never collide with a key.
+ * On a case-insensitive file system, keys that differ only by case share a
+ * name, which over-locks but never under-locks.
+ */
+export function safeFileName(key) {
+    return encodeURIComponent(key).replaceAll('.', '%2E');
+}
+//# sourceMappingURL=safe-file-name.js.map

package/dist/shared/fs/safe-file-name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-file-name.js","sourceRoot":"","sources":["../../../src/shared/fs/safe-file-name.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,GAAW;IACtC,OAAO,kBAAkB,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;AACxD,CAAC"}

package/dist/shared/is-record.d.ts

@@ -0,0 +1,3 @@
+/** Narrows a parsed or received value to an object whose fields can be checked one by one. */
+export declare const isRecord: (value: unknown) => value is Readonly<Record<string, unknown>>;
+//# sourceMappingURL=is-record.d.ts.map

package/dist/shared/is-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-record.d.ts","sourceRoot":"","sources":["../../src/shared/is-record.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,eAAO,MAAM,QAAQ,GACnB,OAAO,OAAO,KACb,KAAK,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACC,CAAC"}

package/dist/shared/is-record.js

@@ -0,0 +1,3 @@
+/** Narrows a parsed or received value to an object whose fields can be checked one by one. */
+export const isRecord = (value) => typeof value === 'object' && value !== null;
+//# sourceMappingURL=is-record.js.map

package/dist/shared/is-record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-record.js","sourceRoot":"","sources":["../../src/shared/is-record.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,KAAc,EAC8B,EAAE,CAC9C,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC"}

package/dist/shared/sqlite/is-busy.d.ts

@@ -0,0 +1,3 @@
+/** Whether `error` means another connection holds a conflicting lock right now. */
+export declare function isBusy(error: unknown): boolean;
+//# sourceMappingURL=is-busy.d.ts.map

package/dist/shared/sqlite/is-busy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-busy.d.ts","sourceRoot":"","sources":["../../../src/shared/sqlite/is-busy.ts"],"names":[],"mappings":"AAEA,mFAAmF;AACnF,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAQ9C"}

package/dist/shared/sqlite/is-busy.js

@@ -0,0 +1,10 @@
+const SQLITE_BUSY = 5;
+/** Whether `error` means another connection holds a conflicting lock right now. */
+export function isBusy(error) {
+    return (error instanceof Error &&
+        'errcode' in error &&
+        typeof error.errcode === 'number' &&
+        // The low byte is the primary result code, covering SQLITE_BUSY_* variants.
+        (error.errcode & 0xff) === SQLITE_BUSY);
+}
+//# sourceMappingURL=is-busy.js.map

package/dist/shared/sqlite/is-busy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-busy.js","sourceRoot":"","sources":["../../../src/shared/sqlite/is-busy.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,GAAG,CAAC,CAAC;AAEtB,mFAAmF;AACnF,MAAM,UAAU,MAAM,CAAC,KAAc;IACnC,OAAO,CACL,KAAK,YAAY,KAAK;QACtB,SAAS,IAAI,KAAK;QAClB,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ;QACjC,4EAA4E;QAC5E,CAAC,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,KAAK,WAAW,CACvC,CAAC;AACJ,CAAC"}

package/dist/shared/until-aborted.d.ts

@@ -0,0 +1,3 @@
+/** Settles like `promise`, or rejects with `signal.reason` first if `signal` aborts. */
+export declare function untilAborted<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T>;
+//# sourceMappingURL=until-aborted.d.ts.map

package/dist/shared/until-aborted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"until-aborted.d.ts","sourceRoot":"","sources":["../../src/shared/until-aborted.ts"],"names":[],"mappings":"AAAA,wFAAwF;AACxF,wBAAgB,YAAY,CAAC,CAAC,EAC5B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,CAAC,CAAC,CAiBZ"}

package/dist/shared/until-aborted.js

@@ -0,0 +1,19 @@
+/** Settles like `promise`, or rejects with `signal.reason` first if `signal` aborts. */
+export function untilAborted(promise, signal) {
+    if (!signal)
+        return promise;
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(signal.reason);
+        if (signal.aborted)
+            return abort();
+        signal.addEventListener('abort', abort, { once: true });
+        promise.then((value) => {
+            signal.removeEventListener('abort', abort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener('abort', abort);
+            reject(error);
+        });
+    });
+}
+//# sourceMappingURL=until-aborted.js.map

package/dist/shared/until-aborted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"until-aborted.js","sourceRoot":"","sources":["../../src/shared/until-aborted.ts"],"names":[],"mappings":"AAAA,wFAAwF;AACxF,MAAM,UAAU,YAAY,CAC1B,OAAmB,EACnB,MAA+B;IAE/B,IAAI,CAAC,MAAM;QAAE,OAAO,OAAO,CAAC;IAC5B,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACxC,MAAM,KAAK,GAAG,GAAG,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC1C,IAAI,MAAM,CAAC,OAAO;YAAE,OAAO,KAAK,EAAE,CAAC;QACnC,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QACxD,OAAO,CAAC,IAAI,CACV,CAAC,KAAK,EAAE,EAAE;YACR,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;YAC3C,OAAO,CAAC,KAAK,CAAC,CAAC;QACjB,CAAC,EACD,CAAC,KAAc,EAAE,EAAE;YACjB,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;YAC3C,MAAM,CAAC,KAAK,CAAC,CAAC;QAChB,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC"}

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@zukhruf/mutex",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "A mutex with interchangeable lock stores, from one object to every process on a host, with fencing tokens on every lease.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JanuaryLabs/zukhruf",
+    "directory": "packages/mutex"
+  },
+  "bugs": {
+    "url": "https://github.com/JanuaryLabs/zukhruf/issues"
+  },
+  "homepage": "https://github.com/JanuaryLabs/zukhruf/tree/main/packages/mutex#readme",
+  "keywords": [
+    "mutex",
+    "lock",
+    "fencing-token",
+    "leader-election",
+    "inter-process"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=26.9.0"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./leader-election": {
+      "types": "./dist/leader-election/index.d.ts",
+      "import": "./dist/leader-election/index.js",
+      "default": "./dist/leader-election/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/spec/**",
+    "!**/*.tsbuildinfo",
+    "!**/*.test.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "hono": "^4.13.13"
+  }
+}