@openclaw/fs-safe 0.14.0 → 0.16.0

package/dist/file-lock-sync-root-acquire.js

@@ -0,0 +1,370 @@
+import fs from "node:fs";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { captureRootSyncAcquireOptions } from "./file-lock-sync-root-options.js";
+import { defaultSyncShouldReclaim, foreignSyncHeldLock, getSyncLockAdmissions, syncLockTimeout } from "./file-lock-sync-admission.js";
+import { computeSidecarLockDelayMs, isTransientLockFileDenial, maxTransientLockDenials, } from "./sidecar-lock-policy.js";
+import { serializeSidecarLockPayload, } from "./sidecar-lock-reclaim.js";
+import { createSuppressedError } from "./suppressed-error.js";
+import { sleepSync } from "./timing.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+import { admitFileLockSyncRootPath, assertFileLockSyncRootPathsCurrent, captureFileLockSyncRootAuthority, normalizeFileLockSyncTargetWithRoot, } from "./file-lock-sync-root.js";
+import { cleanupCreatedRootSyncLock, FileLockSyncRootArbitrationCollision, tryReuseCurrentRootSyncHeldLock, } from "./file-lock-sync-root-arbitration.js";
+import { fileLockSyncRootSnapshotStillCurrent, } from "./file-lock-sync-root-io.js";
+import { createFileLockSyncRootDirectory, createFileLockSyncRootFile, fileLockSyncRootGuardExists, fileLockSyncRootDirectoryReceiptStillCurrent, refreshFileLockSyncRootFileReceipt, removeFileLockSyncRootDirectory, removeFileLockSyncRootFile, } from "./file-lock-sync-root-mutation.js";
+import { createRootSyncHeldLockHandle, ensureRootSyncExitCleanupRegistered, getRootSyncHeldLocks, readRootSidecarSnapshotSync, } from "./file-lock-sync-root-held.js";
+export function acquireFileLockSyncWithRoot(targetPath, inputOptions, lockRoot) {
+    // The public dispatcher already read lockRoot exactly once. Validate and
+    // snapshot that genuine Root before any remaining option or retry getter can
+    // mutate its defaults or retained policy inputs.
+    const authority = captureFileLockSyncRootAuthority(lockRoot);
+    const options = captureRootSyncAcquireOptions(inputOptions);
+    ensureRootSyncExitCleanupRegistered();
+    assertNoWindowsPathAlias(targetPath);
+    if (options.lockPath !== undefined)
+        assertNoWindowsPathAlias(options.lockPath);
+    const resolvedTargetPath = path.resolve(targetPath);
+    const normalizedTargetPath = normalizeFileLockSyncTargetWithRoot(authority, resolvedTargetPath);
+    const requestedLockPath = path.resolve(options.lockPath ?? `${normalizedTargetPath}.lock`);
+    const lockRootPath = admitFileLockSyncRootPath(authority, requestedLockPath);
+    // A followed final alias and its admitted canonical spelling name the same
+    // sidecar. Derive their arbitration guard from that shared admitted path,
+    // then independently admit the derived mutation target under Root policy.
+    const reclaimRootPath = admitFileLockSyncRootPath(authority, `${lockRootPath.path}.reclaim`);
+    const guardedPaths = Object.freeze([lockRootPath, reclaimRootPath]);
+    const lockPath = lockRootPath.path;
+    const heldLocks = getRootSyncHeldLocks();
+    const currentTargetHolder = () => heldLocks.get(normalizedTargetPath) ??
+        foreignSyncHeldLock("root", normalizedTargetPath);
+    const admissions = getSyncLockAdmissions();
+    const admissionToken = {};
+    let ownsAdmission = false;
+    const assertAdmission = () => {
+        if (admissions.get(normalizedTargetPath) !== admissionToken) {
+            throw syncLockTimeout(lockPath, normalizedTargetPath);
+        }
+    };
+    const releaseAdmission = () => {
+        if (ownsAdmission && admissions.get(normalizedTargetPath) === admissionToken) {
+            admissions.delete(normalizedTargetPath);
+        }
+        ownsAdmission = false;
+    };
+    const arbitration = Object.freeze({
+        authority,
+        heldLocks,
+        lockRootPath,
+        normalizedTargetPath,
+        reentrantOwner: options.reentrantOwner,
+    });
+    if (heldLocks.has(normalizedTargetPath) && !foreignSyncHeldLock("root", normalizedTargetPath)) {
+        assertFileLockSyncRootPathsCurrent(guardedPaths, true, true);
+        const initiallyReusable = tryReuseCurrentRootSyncHeldLock(arbitration);
+        if (initiallyReusable)
+            return initiallyReusable;
+    }
+    const startedAt = Date.now();
+    let attempt = 0;
+    let transientDenials = 0;
+    let ownedReclaimGuard;
+    let reclaimCleanupAttempted = false;
+    const reuseCurrentHeld = () => ownedReclaimGuard ? undefined : tryReuseCurrentRootSyncHeldLock(arbitration);
+    const waitForRetry = () => {
+        releaseAdmission();
+        const elapsed = Date.now() - startedAt;
+        const timedOut = options.timeoutMs !== undefined && elapsed >= options.timeoutMs;
+        if (timedOut || (options.retry.retries !== undefined && attempt >= options.retry.retries)) {
+            throw syncLockTimeout(lockPath, normalizedTargetPath);
+        }
+        const remaining = options.timeoutMs === undefined || options.timeoutMs === Number.POSITIVE_INFINITY
+            ? Number.POSITIVE_INFINITY
+            : Math.max(0, options.timeoutMs - elapsed);
+        sleepSync(Math.min(computeSidecarLockDelayMs(options.retry, attempt), remaining));
+        attempt += 1;
+    };
+    const retryLockFileDenial = (error) => {
+        if (!isTransientLockFileDenial(error, lockPath) ||
+            ++transientDenials > maxTransientLockDenials)
+            return false;
+        try {
+            waitForRetry();
+        }
+        catch (waitError) {
+            if (waitError.code === "file_lock_timeout")
+                throw error;
+            throw waitError;
+        }
+        return true;
+    };
+    const releaseReclaimGuard = () => {
+        const receipt = ownedReclaimGuard;
+        if (!receipt)
+            return;
+        reclaimCleanupAttempted = true;
+        if (!removeFileLockSyncRootDirectory(reclaimRootPath, receipt)) {
+            throw new FsSafeError("path-mismatch", "owned sidecar reclaim guard changed before release");
+        }
+        ownedReclaimGuard = undefined;
+        reclaimCleanupAttempted = false;
+    };
+    const assertOwnedReclaimGuardCurrent = () => {
+        const receipt = ownedReclaimGuard;
+        if (!receipt || !fileLockSyncRootDirectoryReceiptStillCurrent(reclaimRootPath, receipt)) {
+            throw new FsSafeError("path-mismatch", "owned sidecar reclaim guard changed during acquisition");
+        }
+    };
+    try {
+        while (true) {
+            if (!ownsAdmission) {
+                if (admissions.has(normalizedTargetPath))
+                    throw syncLockTimeout(lockPath, normalizedTargetPath);
+                admissions.set(normalizedTargetPath, admissionToken);
+                ownsAdmission = true;
+            }
+            assertAdmission();
+            assertFileLockSyncRootPathsCurrent(guardedPaths, true, true);
+            assertAdmission();
+            if (ownedReclaimGuard)
+                assertOwnedReclaimGuardCurrent();
+            if (!ownedReclaimGuard && fileLockSyncRootGuardExists(reclaimRootPath, true)) {
+                waitForRetry();
+                continue;
+            }
+            if (currentTargetHolder() !== undefined) {
+                const reused = reuseCurrentHeld();
+                if (reused)
+                    return reused;
+            }
+            const payload = Reflect.apply(options.payload, options.optionsReceiver, []);
+            assertAdmission();
+            const { raw, ownershipToken } = serializeSidecarLockPayload(payload);
+            assertAdmission();
+            if (ownedReclaimGuard)
+                assertOwnedReclaimGuardCurrent();
+            if (currentTargetHolder() !== undefined) {
+                const reused = reuseCurrentHeld();
+                if (reused)
+                    return reused;
+                waitForRetry();
+                continue;
+            }
+            let fd;
+            let rootReceipt;
+            let unpublishedTimer;
+            let lockFileCreateOpenFailure;
+            try {
+                const created = createFileLockSyncRootFile(lockRootPath, 0o600, {
+                    assertBeforeOpen: () => {
+                        assertAdmission();
+                        if (ownedReclaimGuard)
+                            assertOwnedReclaimGuardCurrent();
+                        if (currentTargetHolder() !== undefined)
+                            throw new FileLockSyncRootArbitrationCollision();
+                    },
+                    onOpenFailure: (error) => {
+                        lockFileCreateOpenFailure = { error };
+                    },
+                });
+                fd = created.fd;
+                rootReceipt = created.receipt;
+                fs.writeFileSync(fd, raw, "utf8");
+                fs.fsyncSync(fd);
+                const snapshot = {
+                    raw,
+                    payload,
+                    ownershipToken,
+                };
+                if (ownedReclaimGuard)
+                    releaseReclaimGuard();
+                rootReceipt = refreshFileLockSyncRootFileReceipt(lockRootPath, rootReceipt);
+                const createdHeld = {
+                    fd,
+                    lockPath,
+                    normalizedTargetPath,
+                    parsePayload: options.parsePayload,
+                    refCount: 1,
+                    reentrantOwner: options.reentrantOwner,
+                    releaseState: "active",
+                    revision: 0,
+                    rootAuthority: authority,
+                    rootPath: lockRootPath,
+                    rootReceipt,
+                    snapshot,
+                };
+                const returnedHandle = createRootSyncHeldLockHandle(createdHeld);
+                if (options.onCompromised && (options.compromiseCheckIntervalMs ?? 0) > 0) {
+                    const timer = setInterval(() => {
+                        let stillHeld;
+                        try {
+                            stillHeld = returnedHandle.verifyStillHeld();
+                        }
+                        catch {
+                            stillHeld = false;
+                        }
+                        if (!stillHeld && createdHeld.timer) {
+                            clearInterval(createdHeld.timer);
+                            createdHeld.timer = undefined;
+                            Reflect.apply(options.onCompromised, options.optionsReceiver, [{ lockPath, normalizedTargetPath }]);
+                        }
+                    }, options.compromiseCheckIntervalMs);
+                    unpublishedTimer = timer;
+                    createdHeld.timer = timer;
+                    timer.unref();
+                }
+                if (currentTargetHolder() !== undefined) {
+                    throw new FileLockSyncRootArbitrationCollision();
+                }
+                assertAdmission();
+                heldLocks.set(normalizedTargetPath, createdHeld);
+                fd = undefined;
+                unpublishedTimer = undefined;
+                return returnedHandle;
+            }
+            catch (error) {
+                if (fd !== undefined && rootReceipt) {
+                    const cleanupFd = fd;
+                    const cleanupReceipt = rootReceipt;
+                    const cleanupTimer = unpublishedTimer;
+                    fd = undefined;
+                    rootReceipt = undefined;
+                    unpublishedTimer = undefined;
+                    try {
+                        cleanupCreatedRootSyncLock(lockRootPath, cleanupFd, cleanupReceipt, cleanupTimer);
+                    }
+                    catch (cleanupError) {
+                        throw createSuppressedError(error, cleanupError, "file lock acquisition and Root cleanup both failed");
+                    }
+                }
+                if (error instanceof FileLockSyncRootArbitrationCollision) {
+                    const reused = reuseCurrentHeld();
+                    if (reused)
+                        return reused;
+                    waitForRetry();
+                    continue;
+                }
+                const fromLockFileOpen = lockFileCreateOpenFailure !== undefined &&
+                    lockFileCreateOpenFailure.error === error;
+                if (fromLockFileOpen && retryLockFileDenial(error))
+                    continue;
+                if (!fromLockFileOpen || error.code !== "EEXIST")
+                    throw error;
+                if (ownedReclaimGuard) {
+                    releaseReclaimGuard();
+                    const reused = reuseCurrentHeld();
+                    if (reused)
+                        return reused;
+                    waitForRetry();
+                    continue;
+                }
+                if (currentTargetHolder() !== undefined) {
+                    const reused = reuseCurrentHeld();
+                    if (reused)
+                        return reused;
+                    waitForRetry();
+                    continue;
+                }
+                let lockFileOpenDenied = false;
+                let current;
+                try {
+                    current = readRootSidecarSnapshotSync(lockRootPath, options.parsePayload, (openError) => {
+                        lockFileOpenDenied = isTransientLockFileDenial(openError, lockPath);
+                    });
+                }
+                catch (readError) {
+                    if (lockFileOpenDenied && retryLockFileDenial(readError))
+                        continue;
+                    throw readError;
+                }
+                if (currentTargetHolder() !== undefined) {
+                    const reused = reuseCurrentHeld();
+                    if (reused)
+                        return reused;
+                    waitForRetry();
+                    continue;
+                }
+                assertAdmission();
+                if (!current) {
+                    waitForRetry();
+                    continue;
+                }
+                const snapshot = current.snapshot;
+                const nowMs = Date.now();
+                let reclaim;
+                if (options.shouldReclaim) {
+                    reclaim = Reflect.apply(options.shouldReclaim, options.optionsReceiver, [{
+                            lockPath,
+                            normalizedTargetPath,
+                            payload: snapshot.payload,
+                            staleMs: options.staleMs,
+                            nowMs,
+                            heldByThisProcess: false,
+                        }]);
+                    assertAdmission();
+                    if (!fileLockSyncRootSnapshotStillCurrent(lockRootPath, current)) {
+                        throw new FsSafeError("path-mismatch", "sidecar changed during reclaim policy callback");
+                    }
+                }
+                else {
+                    reclaim = defaultSyncShouldReclaim(snapshot, options.staleMs, nowMs);
+                }
+                if (reclaim) {
+                    if (options.staleRecovery === "remove-if-unchanged" &&
+                        snapshot.raw !== undefined &&
+                        options.shouldRemoveStaleLock) {
+                        const guard = createFileLockSyncRootDirectory(reclaimRootPath);
+                        if (!guard) {
+                            waitForRetry();
+                            continue;
+                        }
+                        ownedReclaimGuard = guard;
+                        reclaimCleanupAttempted = false;
+                        const approved = Reflect.apply(options.shouldRemoveStaleLock, options.optionsReceiver, [{
+                                lockPath,
+                                normalizedTargetPath,
+                                raw: snapshot.raw,
+                                payload: snapshot.payload,
+                            }]);
+                        assertAdmission();
+                        assertOwnedReclaimGuardCurrent();
+                        if (approved) {
+                            const removed = removeFileLockSyncRootFile(lockRootPath, current.receipt, snapshot, () => {
+                                assertAdmission();
+                                assertOwnedReclaimGuardCurrent();
+                                if (currentTargetHolder() !== undefined)
+                                    throw new FileLockSyncRootArbitrationCollision();
+                            });
+                            if (!removed) {
+                                throw new FsSafeError("path-mismatch", "stale sidecar changed before removal");
+                            }
+                            continue;
+                        }
+                        if (!fileLockSyncRootSnapshotStillCurrent(lockRootPath, current)) {
+                            throw new FsSafeError("path-mismatch", "sidecar changed during stale-removal policy callback");
+                        }
+                        releaseReclaimGuard();
+                    }
+                    throw Object.assign(new Error(`file lock stale for ${normalizedTargetPath}`), {
+                        code: "file_lock_stale",
+                        lockPath,
+                        normalizedTargetPath,
+                    });
+                }
+                waitForRetry();
+            }
+        }
+    }
+    catch (error) {
+        if (ownedReclaimGuard && !reclaimCleanupAttempted) {
+            try {
+                releaseReclaimGuard();
+            }
+            catch (cleanupError) {
+                throw createSuppressedError(error, cleanupError, "file lock acquisition and reclaim cleanup both failed");
+            }
+        }
+        throw error;
+    }
+    finally {
+        releaseAdmission();
+    }
+}

package/dist/file-lock-sync-root-arbitration.d.ts

@@ -0,0 +1,18 @@
+import { FsSafeError } from "./errors.js";
+import type { FileLockSyncHandle } from "./file-lock-sync.js";
+import { type FileLockSyncRootAuthority, type FileLockSyncRootPath } from "./file-lock-sync-root.js";
+import type { FileLockSyncRootFileReceipt } from "./file-lock-sync-root-io.js";
+import { type RootSyncHeldLock } from "./file-lock-sync-root-held.js";
+export declare class FileLockSyncRootArbitrationCollision extends FsSafeError {
+    constructor();
+}
+export type FileLockSyncRootArbitration = Readonly<{
+    authority: FileLockSyncRootAuthority;
+    heldLocks: Map<string, RootSyncHeldLock>;
+    lockRootPath: FileLockSyncRootPath;
+    normalizedTargetPath: string;
+    reentrantOwner?: string;
+}>;
+export declare function tryReuseCurrentRootSyncHeldLock(arbitration: FileLockSyncRootArbitration): FileLockSyncHandle | undefined;
+export declare function cleanupCreatedRootSyncLock(lockRootPath: FileLockSyncRootPath, fd: number, receipt: FileLockSyncRootFileReceipt, timer?: NodeJS.Timeout): void;
+//# sourceMappingURL=file-lock-sync-root-arbitration.d.ts.map

package/dist/file-lock-sync-root-arbitration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-lock-sync-root-arbitration.d.ts","sourceRoot":"","sources":["../src/file-lock-sync-root-arbitration.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,EAC1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AAG/E,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,+BAA+B,CAAC;AAEvC,qBAAa,oCAAqC,SAAQ,WAAW;IACnE,cAEC;CACF;AAED,MAAM,MAAM,2BAA2B,GAAG,QAAQ,CAAC;IACjD,SAAS,EAAE,yBAAyB,CAAC;IACrC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACzC,YAAY,EAAE,oBAAoB,CAAC;IACnC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC,CAAC;AAMH,wBAAgB,+BAA+B,CAC7C,WAAW,EAAE,2BAA2B,GACvC,kBAAkB,GAAG,SAAS,CAsBhC;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,oBAAoB,EAClC,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,2BAA2B,EACpC,KAAK,CAAC,EAAE,MAAM,CAAC,OAAO,GACrB,IAAI,CAyBN"}

package/dist/file-lock-sync-root-arbitration.js

@@ -0,0 +1,66 @@
+import fs from "node:fs";
+import { foreignSyncHeldLock } from "./file-lock-sync-admission.js";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import {} from "./file-lock-sync-root.js";
+import { removeFileLockSyncRootFile } from "./file-lock-sync-root-mutation.js";
+import { createSuppressedError } from "./suppressed-error.js";
+import { createRootSyncHeldLockHandle, verifyRootSyncHeldLock, } from "./file-lock-sync-root-held.js";
+export class FileLockSyncRootArbitrationCollision extends FsSafeError {
+    constructor() {
+        super("path-mismatch", "file lock arbitration changed during local creation");
+    }
+}
+function sameRootLockPath(left, right) {
+    return left.relativePath === right.relativePath && path.relative(left.path, right.path) === "";
+}
+export function tryReuseCurrentRootSyncHeldLock(arbitration) {
+    const held = arbitration.heldLocks.get(arbitration.normalizedTargetPath);
+    const reusable = held && !foreignSyncHeldLock("root", arbitration.normalizedTargetPath) &&
+        arbitration.reentrantOwner !== undefined &&
+        held.reentrantOwner !== undefined &&
+        arbitration.reentrantOwner === held.reentrantOwner &&
+        arbitration.authority.adapter === held.rootAuthority.adapter &&
+        sameRootLockPath(arbitration.lockRootPath, held.rootPath) &&
+        held.releaseState !== "released";
+    if (!reusable)
+        return undefined;
+    if (!verifyRootSyncHeldLock(held)) {
+        throw new FsSafeError("path-mismatch", "held sidecar lock changed before reentrant reuse");
+    }
+    // Verification can invoke a custom parser. Re-fetch the exact entry before
+    // granting a reference, while retaining supported releasing/exit states.
+    if (arbitration.heldLocks.get(arbitration.normalizedTargetPath) !== held ||
+        held.releaseState === "released" || foreignSyncHeldLock("root", arbitration.normalizedTargetPath)) {
+        throw new FsSafeError("path-mismatch", "held sidecar lock changed during reentrant reuse");
+    }
+    held.refCount += 1;
+    held.revision += 1;
+    return createRootSyncHeldLockHandle(held);
+}
+export function cleanupCreatedRootSyncLock(lockRootPath, fd, receipt, timer) {
+    let timerCleanupFailed = false;
+    let timerCleanupError;
+    try {
+        if (timer)
+            clearInterval(timer);
+    }
+    catch (error) {
+        timerCleanupFailed = true;
+        timerCleanupError = error;
+    }
+    try {
+        fs.closeSync(fd);
+        if (!removeFileLockSyncRootFile(lockRootPath, receipt)) {
+            throw new FsSafeError("path-mismatch", "created sidecar lock changed before cleanup");
+        }
+    }
+    catch (fileCleanupError) {
+        if (timerCleanupFailed) {
+            throw createSuppressedError(timerCleanupError, fileCleanupError, "unpublished lock timer and file cleanup both failed");
+        }
+        throw fileCleanupError;
+    }
+    if (timerCleanupFailed)
+        throw timerCleanupError;
+}

package/dist/file-lock-sync-root-held.d.ts

@@ -0,0 +1,34 @@
+import type { FileLockSyncHandle } from "./file-lock-sync.js";
+import { type SidecarLockSnapshot } from "./sidecar-lock-reclaim.js";
+import { type FileLockSyncRootAuthority, type FileLockSyncRootPath } from "./file-lock-sync-root.js";
+import { type FileLockSyncRootFileReceipt, type FileLockSyncRootSnapshot } from "./file-lock-sync-root-io.js";
+type RootSyncHeldLockReleaseState = "active" | "releasing" | "exit-cleaning" | "released";
+type RootSyncHeldLockHandleDisposition = {
+    held: RootSyncHeldLock;
+    released: boolean;
+};
+export type RootSyncHeldLock = {
+    deferredExitReleases?: Set<RootSyncHeldLockHandleDisposition>;
+    fd: number | undefined;
+    lockPath: string;
+    normalizedTargetPath: string;
+    parsePayload?: (raw: string) => unknown;
+    refCount: number;
+    reentrantOwner?: string;
+    releaseState: RootSyncHeldLockReleaseState;
+    revision: number;
+    rootAuthority: FileLockSyncRootAuthority;
+    rootPath: FileLockSyncRootPath;
+    rootReceipt: FileLockSyncRootFileReceipt;
+    snapshot: SidecarLockSnapshot;
+    timer?: NodeJS.Timeout;
+};
+export declare function readRootSidecarSnapshotSync(rootPath: FileLockSyncRootPath, parsePayload?: (raw: string) => unknown, onOpenFailure?: (error: unknown) => void, expectedReceipt?: FileLockSyncRootFileReceipt): FileLockSyncRootSnapshot | null;
+export declare function getRootSyncHeldLocks(): Map<string, RootSyncHeldLock>;
+export declare function ensureRootSyncExitCleanupRegistered(): void;
+export declare function verifyRootSyncHeldLock(held: RootSyncHeldLock): boolean;
+export declare function createRootSyncHeldLockHandle(held: RootSyncHeldLock): FileLockSyncHandle;
+export declare function isRootSyncHeldLockHandle(handle: FileLockSyncHandle): boolean;
+export declare function withRootSyncHeldLockHandle<T>(lock: FileLockSyncHandle, fn: () => T): T;
+export {};
+//# sourceMappingURL=file-lock-sync-root-held.d.ts.map

package/dist/file-lock-sync-root-held.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-lock-sync-root-held.d.ts","sourceRoot":"","sources":["../src/file-lock-sync-root-held.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,kBAAkB,EACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,EAC1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAIL,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC9B,MAAM,6BAA6B,CAAC;AAQrC,KAAK,4BAA4B,GAAG,QAAQ,GAAG,WAAW,GAAG,eAAe,GAAG,UAAU,CAAC;AAE1F,KAAK,iCAAiC,GAAG;IACvC,IAAI,EAAE,gBAAgB,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAOF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,oBAAoB,CAAC,EAAE,GAAG,CAAC,iCAAiC,CAAC,CAAC;IAC9D,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,4BAA4B,CAAC;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,yBAAyB,CAAC;IACzC,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,WAAW,EAAE,2BAA2B,CAAC;IACzC,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;CACxB,CAAC;AAQF,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,oBAAoB,EAC9B,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,EACvC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,EACxC,eAAe,CAAC,EAAE,2BAA2B,GAC5C,wBAAwB,GAAG,IAAI,CAmCjC;AAED,wBAAgB,oBAAoB,IAAI,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAQpE;AA+KD,wBAAgB,mCAAmC,IAAI,IAAI,CAE1D;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAWtE;AAsHD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,gBAAgB,GAAG,kBAAkB,CAqBvF;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAE5E;AAED,wBAAgB,0BAA0B,CAAC,CAAC,EAC1C,IAAI,EAAE,kBAAkB,EACxB,EAAE,EAAE,MAAM,CAAC,GACV,CAAC,CAoBH"}