@lickle/lock 0.0.1-alpha.0 → 0.0.1-alpha.2

package/dist/cjs/core/guard.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileLockGuard = exports.LockGuard = void 0;
+const types_js_1 = require("./types.js");
+/**
+ * Guard that holds a lock without owning the file handle.
+ * Releasing the guard unlocks the file but does not close it.
+ *
+ * @example
+ * const guard = await lock(handle, Lock.Exclusive)
+ * try { /* work *\/ } finally { await guard.drop() }
+ */
+class LockGuard {
+    locking;
+    range;
+    _dropped;
+    /** The file descriptor number. */
+    fd;
+    constructor(locking, handle, range) {
+        this.locking = locking;
+        this.range = range;
+        this.fd = (0, types_js_1.resolveFd)(handle);
+    }
+    /** True if the lock has been released. */
+    get dropped() {
+        return !!this._dropped;
+    }
+    /** Release the lock. Safe to call multiple times. */
+    drop() {
+        if (!this._dropped)
+            this._dropped = this.locking.unlock(this.fd, this.range);
+        return this._dropped;
+    }
+    [Symbol.asyncDispose]() {
+        return this.drop();
+    }
+}
+exports.LockGuard = LockGuard;
+/**
+ * RAII guard that holds a file lock. Unlocks and closes the file on drop.
+ * Supports `await using` via `Symbol.asyncDispose`.
+ *
+ * @example
+ * await using guard = await exclusive('/tmp/my.lock')
+ * // lock is released when guard goes out of scope
+ *
+ * @example
+ * const guard = await exclusive('/tmp/my.lock')
+ * try { /* work *\/ } finally { await guard.drop() }
+ */
+class FileLockGuard {
+    guard;
+    hndl;
+    _dropped;
+    /** The file descriptor number. */
+    fd;
+    constructor(guard, hndl) {
+        this.guard = guard;
+        this.hndl = hndl;
+        this.fd = hndl.fd;
+    }
+    /** The underlying file handle. Throws if the guard has been dropped. */
+    get handle() {
+        if (this._dropped)
+            throw new Error('FileGuard has been dropped');
+        return this.hndl;
+    }
+    /** True if the lock has been released. */
+    get dropped() {
+        return !!this._dropped;
+    }
+    /** Release the lock and close the file. Safe to call multiple times. */
+    drop() {
+        if (!this._dropped) {
+            this._dropped = (async () => {
+                try {
+                    await this.guard.drop();
+                }
+                finally {
+                    await this.hndl.close();
+                }
+            })();
+        }
+        return this._dropped;
+    }
+    [Symbol.asyncDispose]() {
+        return this.drop();
+    }
+}
+exports.FileLockGuard = FileLockGuard;
+//# sourceMappingURL=guard.js.map

package/dist/cjs/core/guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard.js","sourceRoot":"","sources":["../../../lib/core/guard.ts"],"names":[],"mappings":";;;AAAA,yCAAyG;AAEzG;;;;;;;GAOG;AACH,MAAa,SAAS;IAMV;IAEA;IAPF,QAAQ,CAA2B;IAC3C,kCAAkC;IAClB,EAAE,CAAQ;IAE1B,YACU,OAAe,EACvB,MAAS,EACD,KAAiB;QAFjB,YAAO,GAAP,OAAO,CAAQ;QAEf,UAAK,GAAL,KAAK,CAAY;QAEzB,IAAI,CAAC,EAAE,GAAG,IAAA,oBAAS,EAAC,MAAM,CAAC,CAAA;IAC7B,CAAC;IAED,0CAA0C;IAC1C,IAAI,OAAO;QACT,OAAO,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAA;IACxB,CAAC;IAED,qDAAqD;IACrD,IAAI;QACF,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,CAAA;QAC5E,OAAO,IAAI,CAAC,QAAQ,CAAA;IACtB,CAAC;IAED,CAAC,MAAM,CAAC,YAAY,CAAC;QACnB,OAAO,IAAI,CAAC,IAAI,EAAE,CAAA;IACpB,CAAC;CACF;AA3BD,8BA2BC;AAED;;;;;;;;;;;GAWG;AACH,MAAa,aAAa;IAMd;IACA;IANF,QAAQ,CAA2B;IAC3C,kCAAkC;IAClB,EAAE,CAAQ;IAE1B,YACU,KAAmB,EACnB,IAAO;QADP,UAAK,GAAL,KAAK,CAAc;QACnB,SAAI,GAAJ,IAAI,CAAG;QAEf,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAA;IACnB,CAAC;IAED,wEAAwE;IACxE,IAAI,MAAM;QACR,IAAI,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAA;QAChE,OAAO,IAAI,CAAC,IAAI,CAAA;IAClB,CAAC;IAED,0CAA0C;IAC1C,IAAI,OAAO;QACT,OAAO,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAA;IACxB,CAAC;IAED,wEAAwE;IACxE,IAAI;QACF,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,IAAI,CAAC,QAAQ,GAAG,CAAC,KAAK,IAAI,EAAE;gBAC1B,IAAI,CAAC;oBACH,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAA;gBACzB,CAAC;wBAAS,CAAC;oBACT,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAA;gBACzB,CAAC;YACH,CAAC,CAAC,EAAE,CAAA;QACN,CAAC;QACD,OAAO,IAAI,CAAC,QAAQ,CAAA;IACtB,CAAC;IAED,CAAC,MAAM,CAAC,YAAY,CAAC;QACnB,OAAO,IAAI,CAAC,IAAI,EAAE,CAAA;IACpB,CAAC;CACF;AAxCD,sCAwCC"}

package/dist/cjs/core/index.d.ts

@@ -0,0 +1,8 @@
+import { Locker, type Fs } from './types.js';
+export { type Fs as Backend, type LockRange, type PollOptions, Lock, type FileDescriptor, type FileHandle, type Locker, type Fs, } from './types.js';
+export * from './locking.js';
+export * from './guard.js';
+export * from './node.js';
+export declare const defaultFs: () => Fs<import("node:fs/promises").FileHandle>;
+export declare const defaultLocking: () => Locker;
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/core/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,MAAM,YAAY,CAAA;AAG5C,OAAO,EACL,KAAK,EAAE,IAAI,OAAO,EAClB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,IAAI,EACJ,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,MAAM,EACX,KAAK,EAAE,GACR,MAAM,YAAY,CAAA;AACnB,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AAIzB,eAAO,MAAM,SAAS,iDAGrB,CAAA;AAID,eAAO,MAAM,cAAc,cAG1B,CAAA"}

package/dist/cjs/core/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultLocking = exports.defaultFs = exports.Lock = void 0;
+const node_js_1 = require("./node.js");
+const locking_js_1 = require("./locking.js");
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "Lock", { enumerable: true, get: function () { return types_js_1.Lock; } });
+__exportStar(require("./locking.js"), exports);
+__exportStar(require("./guard.js"), exports);
+__exportStar(require("./node.js"), exports);
+/** Lazily create and return the shared default Node.js filesystem singleton. */
+let _defaultFs;
+const defaultFs = () => {
+    if (!_defaultFs)
+        _defaultFs = (0, node_js_1.createNodeFs)();
+    return _defaultFs;
+};
+exports.defaultFs = defaultFs;
+/** Lazily create and return the shared default native locker singleton. */
+let _defaultLocking;
+const defaultLocking = () => {
+    if (!_defaultLocking)
+        _defaultLocking = (0, locking_js_1.createLocker)(new node_js_1.NodeLockHooks());
+    return _defaultLocking;
+};
+exports.defaultLocking = defaultLocking;
+//# sourceMappingURL=index.js.map

package/dist/cjs/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../lib/core/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,uCAA4E;AAE5E,6CAA2C;AAE3C,uCASmB;AALjB,gGAAA,IAAI,OAAA;AAMN,+CAA4B;AAC5B,6CAA0B;AAC1B,4CAAyB;AAEzB,gFAAgF;AAChF,IAAI,UAA0C,CAAA;AACvC,MAAM,SAAS,GAAG,GAAG,EAAE;IAC5B,IAAI,CAAC,UAAU;QAAE,UAAU,GAAG,IAAA,sBAAY,GAAE,CAAA;IAC5C,OAAO,UAAU,CAAA;AACnB,CAAC,CAAA;AAHY,QAAA,SAAS,aAGrB;AAED,2EAA2E;AAC3E,IAAI,eAAmC,CAAA;AAChC,MAAM,cAAc,GAAG,GAAG,EAAE;IACjC,IAAI,CAAC,eAAe;QAAE,eAAe,GAAG,IAAA,yBAAY,EAAC,IAAI,uBAAa,EAAE,CAAC,CAAA;IACzE,OAAO,eAAe,CAAA;AACxB,CAAC,CAAA;AAHY,QAAA,cAAc,kBAG1B"}

package/dist/cjs/core/locking.d.ts

@@ -0,0 +1,23 @@
+import { type FileDescriptor, type Locker } from './types.js';
+/**
+ * Lifecycle hooks called when locks are acquired and released.
+ * Used by backends to track active locks for cleanup on exit or signals.
+ */
+export interface LockHooks {
+    /** Called after a lock is successfully acquired. */
+    register: (fd: FileDescriptor) => Promise<void>;
+    /** Called when a lock is released (even if unlock itself fails). */
+    unregister: (fd: FileDescriptor) => Promise<void>;
+}
+/**
+ * Create a {@link Locker} backed by native OS locks.
+ *
+ * Whole-file locks use `flock(2)` on Unix and `LockFileEx` on Windows.
+ * Range locks use `fcntl(2)` OFD locks on Linux, POSIX record locks on
+ * macOS/BSD, and ranged `LockFileEx` on Windows.
+ *
+ * If `hooks` are provided they are called after lock acquisition and on
+ * release, allowing backends to track active locks for cleanup.
+ */
+export declare const createLocker: (hooks?: LockHooks) => Locker;
+//# sourceMappingURL=locking.d.ts.map

package/dist/cjs/core/locking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locking.d.ts","sourceRoot":"","sources":["../../../lib/core/locking.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,cAAc,EAAE,KAAK,MAAM,EAAmB,MAAM,YAAY,CAAA;AAGhH;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,oDAAoD;IACpD,QAAQ,EAAE,CAAC,EAAE,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/C,oEAAoE;IACpE,UAAU,EAAE,CAAC,EAAE,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAClD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,GAAI,QAAQ,SAAS,KAAG,MAqC/C,CAAA"}

package/dist/cjs/core/locking.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocker = void 0;
+const types_js_1 = require("./types.js");
+const native = __importStar(require("#native"));
+/**
+ * Create a {@link Locker} backed by native OS locks.
+ *
+ * Whole-file locks use `flock(2)` on Unix and `LockFileEx` on Windows.
+ * Range locks use `fcntl(2)` OFD locks on Linux, POSIX record locks on
+ * macOS/BSD, and ranged `LockFileEx` on Windows.
+ *
+ * If `hooks` are provided they are called after lock acquisition and on
+ * release, allowing backends to track active locks for cleanup.
+ */
+const createLocker = (hooks) => ({
+    async lock(fd, type, range, options) {
+        const d = (0, types_js_1.resolveFd)(fd);
+        await native.lock(d, toNativeLock(type), range, options);
+        try {
+            await hooks?.register(d);
+        }
+        catch (err) {
+            try {
+                native.lockSync(d, native.Lock.Unlock, range);
+            }
+            catch { }
+            throw err;
+        }
+    },
+    async tryLock(fd, type, range) {
+        const d = (0, types_js_1.resolveFd)(fd);
+        const locked = await native.tryLock(d, toNativeLock(type), range);
+        if (!locked)
+            return false;
+        try {
+            await hooks?.register(d);
+            return true;
+        }
+        catch (err) {
+            try {
+                native.lockSync(d, native.Lock.Unlock, range);
+            }
+            catch { }
+            throw err;
+        }
+    },
+    async unlock(fd, range) {
+        const d = (0, types_js_1.resolveFd)(fd);
+        try {
+            native.lockSync(d, native.Lock.Unlock, range);
+        }
+        finally {
+            await hooks?.unregister(d);
+        }
+    },
+});
+exports.createLocker = createLocker;
+const toNativeLock = (type) => (type === types_js_1.Lock.Exclusive ? native.Lock.Exclusive : native.Lock.Shared);
+//# sourceMappingURL=locking.js.map

package/dist/cjs/core/locking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locking.js","sourceRoot":"","sources":["../../../lib/core/locking.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAAgH;AAChH,gDAAiC;AAajC;;;;;;;;;GASG;AACI,MAAM,YAAY,GAAG,CAAC,KAAiB,EAAU,EAAE,CAAC,CAAC;IAC1D,KAAK,CAAC,IAAI,CAAC,EAAkB,EAAE,IAAU,EAAE,KAAiB,EAAE,OAAqB;QACjF,MAAM,CAAC,GAAG,IAAA,oBAAS,EAAC,EAAE,CAAC,CAAA;QACvB,MAAM,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAA;QACxD,IAAI,CAAC;YACH,MAAM,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAA;QAC1B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC;gBACH,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;YAC/C,CAAC;YAAC,MAAM,CAAC,CAAA,CAAC;YACV,MAAM,GAAG,CAAA;QACX,CAAC;IACH,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,EAAkB,EAAE,IAAU,EAAE,KAAiB;QAC7D,MAAM,CAAC,GAAG,IAAA,oBAAS,EAAC,EAAE,CAAC,CAAA;QACvB,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,CAAA;QACjE,IAAI,CAAC,MAAM;YAAE,OAAO,KAAK,CAAA;QACzB,IAAI,CAAC;YACH,MAAM,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAA;YACxB,OAAO,IAAI,CAAA;QACb,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC;gBACH,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;YAC/C,CAAC;YAAC,MAAM,CAAC,CAAA,CAAC;YACV,MAAM,GAAG,CAAA;QACX,CAAC;IACH,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,EAAkB,EAAE,KAAiB;QAChD,MAAM,CAAC,GAAG,IAAA,oBAAS,EAAC,EAAE,CAAC,CAAA;QACvB,IAAI,CAAC;YACH,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;QAC/C,CAAC;gBAAS,CAAC;YACT,MAAM,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;QAC5B,CAAC;IACH,CAAC;CACF,CAAC,CAAA;AArCW,QAAA,YAAY,gBAqCvB;AAEF,MAAM,YAAY,GAAG,CAAC,IAAU,EAAe,EAAE,CAAC,CAAC,IAAI,KAAK,eAAI,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA"}

package/dist/cjs/core/node.d.ts

@@ -0,0 +1,19 @@
+import fs from 'node:fs';
+import { type Fs, FileDescriptor } from './types.js';
+import { type LockHooks } from './locking.js';
+/** Node.js file handle type alias. */
+export type NodeFileHandle = fs.promises.FileHandle;
+/** Create a Node.js filesystem that opens files with appropriate flags for the lock type. */
+export declare const createNodeFs: () => Fs<NodeFileHandle>;
+/**
+ * Track active locks by file descriptor and ensure they are released on process exit.
+ */
+export declare class NodeLockHooks implements LockHooks {
+    private _active;
+    register(fd: FileDescriptor): Promise<void>;
+    unregister(fd: FileDescriptor): Promise<void>;
+    private _listen;
+    private _unlisten;
+    private _onExit;
+}
+//# sourceMappingURL=node.d.ts.map

package/dist/cjs/core/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../lib/core/node.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,SAAS,CAAA;AAExB,OAAO,EAAE,KAAK,EAAE,EAAQ,cAAc,EAAa,MAAM,YAAY,CAAA;AACrE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C,sCAAsC;AACtC,MAAM,MAAM,cAAc,GAAG,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAA;AAEnD,6FAA6F;AAC7F,eAAO,MAAM,YAAY,QAAO,EAAE,CAAC,cAAc,CAQhD,CAAA;AAED;;GAEG;AACH,qBAAa,aAAc,YAAW,SAAS;IAC7C,OAAO,CAAC,OAAO,CAA4B;IAErC,QAAQ,CAAC,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAM3C,UAAU,CAAC,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAWnD,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,OAAO,CASd;CACF"}

package/dist/cjs/core/node.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeLockHooks = exports.createNodeFs = void 0;
+const node_worker_threads_1 = require("node:worker_threads");
+const node_fs_1 = __importDefault(require("node:fs"));
+const types_js_1 = require("./types.js");
+/** Create a Node.js filesystem that opens files with appropriate flags for the lock type. */
+const createNodeFs = () => {
+    return {
+        async open(file, type) {
+            const flags = type === types_js_1.Lock.Exclusive ? node_fs_1.default.constants.O_CREAT | node_fs_1.default.constants.O_RDWR : node_fs_1.default.constants.O_RDONLY;
+            const handle = await node_fs_1.default.promises.open(file, flags);
+            return handle;
+        },
+    };
+};
+exports.createNodeFs = createNodeFs;
+/**
+ * Track active locks by file descriptor and ensure they are released on process exit.
+ */
+class NodeLockHooks {
+    _active = new Map();
+    async register(fd) {
+        if (this._active.size === 0)
+            this._listen();
+        const d = (0, types_js_1.resolveFd)(fd);
+        this._active.set(d, (this._active.get(d) ?? 0) + 1);
+    }
+    async unregister(fd) {
+        const d = (0, types_js_1.resolveFd)(fd);
+        const count = this._active.get(d);
+        if (count !== undefined) {
+            if (count <= 1)
+                this._active.delete(d);
+            else
+                this._active.set(d, count - 1);
+        }
+        if (this._active.size === 0)
+            this._unlisten();
+    }
+    _listen() {
+        if (node_worker_threads_1.isMainThread)
+            process.on('exit', this._onExit);
+        else
+            node_worker_threads_1.parentPort?.on('close', this._onExit);
+    }
+    _unlisten() {
+        if (node_worker_threads_1.isMainThread)
+            process.off('exit', this._onExit);
+        else
+            node_worker_threads_1.parentPort?.off('close', this._onExit);
+    }
+    _onExit = () => {
+        for (const fd of Array.from(this._active.keys()).reverse()) {
+            try {
+                node_fs_1.default.closeSync(fd);
+            }
+            catch {
+                // EBADF expected if already closed
+            }
+        }
+        this._active.clear();
+    };
+}
+exports.NodeLockHooks = NodeLockHooks;
+//# sourceMappingURL=node.js.map

package/dist/cjs/core/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../lib/core/node.ts"],"names":[],"mappings":";;;;;;AAAA,6DAA8D;AAC9D,sDAAwB;AAExB,yCAAqE;AAMrE,6FAA6F;AACtF,MAAM,YAAY,GAAG,GAAuB,EAAE;IACnD,OAAO;QACL,KAAK,CAAC,IAAI,CAAC,IAAY,EAAE,IAAU;YACjC,MAAM,KAAK,GAAG,IAAI,KAAK,eAAI,CAAC,SAAS,CAAC,CAAC,CAAC,iBAAE,CAAC,SAAS,CAAC,OAAO,GAAG,iBAAE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,iBAAE,CAAC,SAAS,CAAC,QAAQ,CAAA;YAC1G,MAAM,MAAM,GAAG,MAAM,iBAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;YAClD,OAAO,MAAM,CAAA;QACf,CAAC;KACF,CAAA;AACH,CAAC,CAAA;AARY,QAAA,YAAY,gBAQxB;AAED;;GAEG;AACH,MAAa,aAAa;IAChB,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAA;IAE3C,KAAK,CAAC,QAAQ,CAAC,EAAkB;QAC/B,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC;YAAE,IAAI,CAAC,OAAO,EAAE,CAAA;QAC3C,MAAM,CAAC,GAAG,IAAA,oBAAS,EAAC,EAAE,CAAC,CAAA;QACvB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;IACrD,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,EAAkB;QACjC,MAAM,CAAC,GAAG,IAAA,oBAAS,EAAC,EAAE,CAAC,CAAA;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;QACjC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,IAAI,KAAK,IAAI,CAAC;gBAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;;gBACjC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,CAAA;QACrC,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC;YAAE,IAAI,CAAC,SAAS,EAAE,CAAA;IAC/C,CAAC;IAEO,OAAO;QACb,IAAI,kCAAY;YAAE,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;;YAC7C,gCAAU,EAAE,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;IAC5C,CAAC;IAEO,SAAS;QACf,IAAI,kCAAY;YAAE,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;;YAC9C,gCAAU,EAAE,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;IAC7C,CAAC;IAEO,OAAO,GAAG,GAAS,EAAE;QAC3B,KAAK,MAAM,EAAE,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC;YAC3D,IAAI,CAAC;gBACH,iBAAE,CAAC,SAAS,CAAC,EAAE,CAAC,CAAA;YAClB,CAAC;YAAC,MAAM,CAAC;gBACP,mCAAmC;YACrC,CAAC;QACH,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAA;IACtB,CAAC,CAAA;CACF;AAxCD,sCAwCC"}

package/dist/cjs/core/types.d.ts

@@ -0,0 +1,49 @@
+/** Filesystem abstraction for opening lock files. */
+export interface Fs<H extends FileHandle> {
+    /** Open (or create) the lock file and return a handle. */
+    open(file: string, type: Lock): Promise<H>;
+}
+/** Lock/unlock operations, separated from file opening for composability. */
+export interface Locker {
+    /** Acquire a lock, polling until available or timeout is reached. */
+    lock: (fd: FileDescriptor, type: Lock, range?: LockRange, options?: PollOptions) => Promise<void>;
+    /** Try to acquire a lock without waiting. Return true if acquired. */
+    tryLock: (fd: FileDescriptor, type: Lock, range?: LockRange) => Promise<boolean>;
+    /** Release a previously acquired lock. */
+    unlock: (fd: FileDescriptor, range?: LockRange) => Promise<void>;
+}
+/** Lock mode: exclusive (write) or shared (read). */
+export declare enum Lock {
+    Exclusive = 0,
+    Shared = 1
+}
+/** Options for polling lock acquisition. */
+export interface PollOptions {
+    /** Polling interval in milliseconds. */
+    pollMs?: number;
+    /** Maximum wait time in milliseconds. */
+    timeout?: number;
+    /** Multiplier applied to pollMs after each failed attempt (e.g. 2 = exponential backoff). */
+    backoff?: number;
+}
+/** Byte range within a file to lock. Used for range-level locking. */
+export interface LockRange {
+    /** Starting byte offset. */
+    offset: number;
+    /** Number of bytes to lock. */
+    length: number;
+}
+/** An open file handle with a descriptor and a close method. */
+export interface FileHandle {
+    /** The numeric file descriptor. */
+    fd: number;
+    /** Close the file handle. */
+    close: () => Promise<void>;
+}
+/** File descriptor or file descriptor object. */
+export type FileDescriptor = {
+    fd: number;
+} | number;
+/** @internal */
+export declare const resolveFd: (fd: FileDescriptor) => number;
+//# sourceMappingURL=types.d.ts.map

package/dist/cjs/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../lib/core/types.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,MAAM,WAAW,EAAE,CAAC,CAAC,SAAS,UAAU;IACtC,0DAA0D;IAC1D,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;CAC3C;AAED,6EAA6E;AAC7E,MAAM,WAAW,MAAM;IACrB,qEAAqE;IACrE,IAAI,EAAE,CAAC,EAAE,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACjG,sEAAsE;IACtE,OAAO,EAAE,CAAC,EAAE,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAChF,0CAA0C;IAC1C,MAAM,EAAE,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CACjE;AAED,qDAAqD;AACrD,oBAAY,IAAI;IACd,SAAS,IAAA;IACT,MAAM,IAAA;CACP;AAED,4CAA4C;AAC5C,MAAM,WAAW,WAAW;IAC1B,wCAAwC;IACxC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,6FAA6F;IAC7F,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,sEAAsE;AACtE,MAAM,WAAW,SAAS;IACxB,4BAA4B;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,+BAA+B;IAC/B,MAAM,EAAE,MAAM,CAAA;CACf;AAED,gEAAgE;AAChE,MAAM,WAAW,UAAU;IACzB,mCAAmC;IACnC,EAAE,EAAE,MAAM,CAAA;IACV,6BAA6B;IAC7B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3B;AAED,iDAAiD;AACjD,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAAA;AAEpD,gBAAgB;AAChB,eAAO,MAAM,SAAS,GAAI,IAAI,cAAc,KAAG,MAA+C,CAAA"}

package/dist/cjs/core/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFd = exports.Lock = void 0;
+/** Lock mode: exclusive (write) or shared (read). */
+var Lock;
+(function (Lock) {
+    Lock[Lock["Exclusive"] = 0] = "Exclusive";
+    Lock[Lock["Shared"] = 1] = "Shared";
+})(Lock || (exports.Lock = Lock = {}));
+/** @internal */
+const resolveFd = (fd) => (typeof fd === 'number' ? fd : fd.fd);
+exports.resolveFd = resolveFd;
+//# sourceMappingURL=types.js.map

package/dist/cjs/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../lib/core/types.ts"],"names":[],"mappings":";;;AAgBA,qDAAqD;AACrD,IAAY,IAGX;AAHD,WAAY,IAAI;IACd,yCAAS,CAAA;IACT,mCAAM,CAAA;AACR,CAAC,EAHW,IAAI,oBAAJ,IAAI,QAGf;AA+BD,gBAAgB;AACT,MAAM,SAAS,GAAG,CAAC,EAAkB,EAAU,EAAE,CAAC,CAAC,OAAO,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAA;AAAjF,QAAA,SAAS,aAAwE"}

package/dist/cjs/index.d.ts

@@ -0,0 +1,63 @@
+import { type NodeFileHandle, type LockRange, type PollOptions, type Lock, type FileHandle, type FileDescriptor, type Fs, type Locker, FileLockGuard, LockGuard } from './core/index.js';
+export * from './core/index.js';
+/** Options for specifying a custom locker and/or byte range. */
+export interface LockingOptions {
+    /** Custom locker implementation. Uses the default native locker if omitted. */
+    locking?: Locker;
+    /** Byte range to lock. Locks the entire file if omitted. */
+    range?: LockRange;
+}
+/**
+ * Acquire a lock on an already-open file handle.
+ *
+ * @example
+ * import fs from 'node:fs/promises'
+ * const handle = await fs.open('/tmp/my.lock', 'r+')
+ * await using guard = await lock(handle, Lock.Exclusive)
+ */
+export declare const lock: <H extends FileHandle = NodeFileHandle>(handle: H, type: Lock, options?: LockingOptions & PollOptions) => Promise<LockGuard<H>>;
+/**
+ * Try to acquire a lock on an already-open file handle without waiting.
+ *
+ * @example
+ * import fs from 'node:fs/promises'
+ * const handle = await fs.open('/tmp/my.lock', 'r+')
+ * const guard = await tryLock(handle, Lock.Exclusive)
+ * if (guard) { /* acquired *\/ }
+ */
+export declare const tryLock: <H extends FileDescriptor>(handle: H, type: Lock, options?: LockingOptions & PollOptions) => Promise<LockGuard<H> | undefined>;
+/**
+ * Release a lock on a file descriptor or file handle.
+ *
+ * @example
+ * import fs from 'node:fs/promises'
+ * const handle = await fs.open('/tmp/my.lock', 'r+')
+ * await lock(handle, Lock.Exclusive)
+ * // ... critical section ...
+ * await unlock(handle)
+ */
+export declare const unlock: <H extends FileDescriptor>(handle: H, options?: LockingOptions) => Promise<void>;
+/** Options for open-and-lock functions that manage the file lifecycle. */
+export interface OpenLockOptions<H extends FileHandle> extends LockingOptions {
+    /** Custom filesystem for opening files. Uses the default Node.js fs if omitted. */
+    fs?: Fs<H>;
+}
+/**
+ * Open a file and acquire a lock, polling until available. Closes the file on failure.
+ *
+ * @example
+ * await using guard = await openLock('/tmp/my.lock', Lock.Exclusive)
+ *
+ * @example
+ * await using guard = await openLock('/tmp/my.lock', Lock.Shared, { timeout: 5000 })
+ */
+export declare const openLock: <H extends FileHandle = NodeFileHandle>(file: string, type: Lock, options?: OpenLockOptions<H> & PollOptions) => Promise<FileLockGuard<H>>;
+/**
+ * Open a file and try to acquire a lock without waiting. Closes the file if not acquired.
+ *
+ * @example
+ * const guard = await tryOpenLock('/tmp/my.lock', Lock.Exclusive)
+ * if (guard) { /* acquired *\/ }
+ */
+export declare const tryOpenLock: <H extends FileHandle = NodeFileHandle>(file: string, type: Lock, options?: OpenLockOptions<H>) => Promise<FileLockGuard<H> | undefined>;
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,IAAI,EACT,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,EAAE,EACP,KAAK,MAAM,EACX,aAAa,EACb,SAAS,EAGV,MAAM,iBAAiB,CAAA;AACxB,cAAc,iBAAiB,CAAA;AAE/B,gEAAgE;AAChE,MAAM,WAAW,cAAc;IAC7B,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,4DAA4D;IAC5D,KAAK,CAAC,EAAE,SAAS,CAAA;CAClB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,GAAU,CAAC,SAAS,UAAU,GAAG,cAAc,EAC9D,QAAQ,CAAC,EACT,MAAM,IAAI,EACV,UAAU,cAAc,GAAG,WAAW,KACrC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAItB,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,GAAU,CAAC,SAAS,cAAc,EACpD,QAAQ,CAAC,EACT,MAAM,IAAI,EACV,UAAU,cAAc,GAAG,WAAW,KACrC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAKlC,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,GAAU,CAAC,SAAS,cAAc,EAAE,QAAQ,CAAC,EAAE,UAAU,cAAc,KAAG,OAAO,CAAC,IAAI,CAGxG,CAAA;AAED,0EAA0E;AAC1E,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,cAAc;IAC3E,mFAAmF;IACnF,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAA;CACX;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,GAAU,CAAC,SAAS,UAAU,GAAG,cAAc,EAClE,MAAM,MAAM,EACZ,MAAM,IAAI,EACV,UAAU,eAAe,CAAC,CAAC,CAAC,GAAG,WAAW,KACzC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAS1B,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAU,CAAC,SAAS,UAAU,GAAG,cAAc,EACrE,MAAM,MAAM,EACZ,MAAM,IAAI,EACV,UAAU,eAAe,CAAC,CAAC,CAAC,KAC3B,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS,CAYtC,CAAA"}

package/dist/cjs/index.js

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryOpenLock = exports.openLock = exports.unlock = exports.tryLock = exports.lock = void 0;
+const index_js_1 = require("./core/index.js");
+__exportStar(require("./core/index.js"), exports);
+/**
+ * Acquire a lock on an already-open file handle.
+ *
+ * @example
+ * import fs from 'node:fs/promises'
+ * const handle = await fs.open('/tmp/my.lock', 'r+')
+ * await using guard = await lock(handle, Lock.Exclusive)
+ */
+const lock = async (handle, type, options) => {
+    const { locking = (0, index_js_1.defaultLocking)() } = options ?? {};
+    await locking.lock(handle, type, options?.range, options);
+    return new index_js_1.LockGuard(locking, handle, options?.range);
+};
+exports.lock = lock;
+/**
+ * Try to acquire a lock on an already-open file handle without waiting.
+ *
+ * @example
+ * import fs from 'node:fs/promises'
+ * const handle = await fs.open('/tmp/my.lock', 'r+')
+ * const guard = await tryLock(handle, Lock.Exclusive)
+ * if (guard) { /* acquired *\/ }
+ */
+const tryLock = async (handle, type, options) => {
+    const { locking = (0, index_js_1.defaultLocking)() } = options ?? {};
+    const result = await locking.tryLock(handle, type, options?.range);
+    if (result)
+        return new index_js_1.LockGuard(locking, handle, options?.range);
+    return undefined;
+};
+exports.tryLock = tryLock;
+/**
+ * Release a lock on a file descriptor or file handle.
+ *
+ * @example
+ * import fs from 'node:fs/promises'
+ * const handle = await fs.open('/tmp/my.lock', 'r+')
+ * await lock(handle, Lock.Exclusive)
+ * // ... critical section ...
+ * await unlock(handle)
+ */
+const unlock = async (handle, options) => {
+    const { locking = (0, index_js_1.defaultLocking)() } = options ?? {};
+    await locking.unlock(handle, options?.range);
+};
+exports.unlock = unlock;
+/**
+ * Open a file and acquire a lock, polling until available. Closes the file on failure.
+ *
+ * @example
+ * await using guard = await openLock('/tmp/my.lock', Lock.Exclusive)
+ *
+ * @example
+ * await using guard = await openLock('/tmp/my.lock', Lock.Shared, { timeout: 5000 })
+ */
+const openLock = async (file, type, options) => {
+    const { fs = (0, index_js_1.defaultFs)() } = options ?? {};
+    const handle = await fs.open(file, type);
+    try {
+        return new index_js_1.FileLockGuard(await (0, exports.lock)(handle, type, options), handle);
+    }
+    catch (error) {
+        await handle.close();
+        throw error;
+    }
+};
+exports.openLock = openLock;
+/**
+ * Open a file and try to acquire a lock without waiting. Closes the file if not acquired.
+ *
+ * @example
+ * const guard = await tryOpenLock('/tmp/my.lock', Lock.Exclusive)
+ * if (guard) { /* acquired *\/ }
+ */
+const tryOpenLock = async (file, type, options) => {
+    const { fs = (0, index_js_1.defaultFs)() } = options ?? {};
+    const handle = await fs.open(file, type);
+    try {
+        const result = await (0, exports.tryLock)(handle, type, options);
+        if (result)
+            return new index_js_1.FileLockGuard(result, handle);
+        await handle.close();
+        return undefined;
+    }
+    catch (error) {
+        await handle.close();
+        throw error;
+    }
+};
+exports.tryOpenLock = tryOpenLock;
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

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