@openclaw/fs-safe 0.14.0 → 0.15.0

package/dist/sidecar-lock-stale-admission.js

@@ -0,0 +1,232 @@
+import { defaultSidecarLockShouldReclaim, isTransientLockFileDenial } from "./sidecar-lock-policy.js";
+import { readSidecarLockRawSnapshot, removeStaleSidecarLockIfAllowed, sidecarLockSnapshotStillPresent, tryAcquireSidecarReclaimGuard, } from "./sidecar-lock-reclaim.js";
+import { observeSidecarLockParser, parseSidecarLockSnapshotUnderAdmission, scopedSidecarLockParser, } from "./sidecar-lock-admission-parser.js";
+/** Handle one historical EEXIST attempt while its canonical admission is held. */
+export async function handleStaleSidecarAdmission(params) {
+    const { admission, lockPath, normalizedTargetPath, options } = params;
+    const holderChanged = {};
+    const assertUnheld = () => {
+        params.assertToken();
+        if (params.currentHeld())
+            throw holderChanged;
+    };
+    const retryHolderChange = async (error) => {
+        if (error !== holderChanged)
+            return false;
+        await params.waitForRetry();
+        return true;
+    };
+    const retryChangedBoundary = async () => {
+        try {
+            assertUnheld();
+            return false;
+        }
+        catch (error) {
+            if (await retryHolderChange(error))
+                return true;
+            throw error;
+        }
+    };
+    let rawSnapshot;
+    let lockFileOpenDenied = false;
+    try {
+        rawSnapshot = await admission.run(async () => await readSidecarLockRawSnapshot(lockPath, {
+            lockRoot: params.lockRoot,
+            rejectNonFile: true,
+            discardObservation: "changed",
+            onOpenFailure: (error) => {
+                lockFileOpenDenied = isTransientLockFileDenial(error, lockPath);
+            },
+        }));
+    }
+    catch (error) {
+        if (await retryChangedBoundary())
+            return;
+        if (!lockFileOpenDenied || !params.withinDenialBudget())
+            throw error;
+        await params.retryOrRethrowDenial(error);
+        return;
+    }
+    params.assertToken();
+    if (params.currentHeld()) {
+        await params.waitForRetry();
+        return;
+    }
+    let snapshot;
+    try {
+        observeSidecarLockParser(params.parserState, admission, () => options.parsePayload, assertUnheld);
+        snapshot = parseSidecarLockSnapshotUnderAdmission(rawSnapshot, params.parserState, admission, assertUnheld);
+        assertUnheld();
+    }
+    catch (error) {
+        if (await retryHolderChange(error))
+            return;
+        if (await retryChangedBoundary())
+            return;
+        throw error;
+    }
+    if (!snapshot) {
+        await params.waitForRetry();
+        return;
+    }
+    const staleOptions = params.staleOptionsState;
+    try {
+        if (!staleOptions.shouldReclaimObserved) {
+            assertUnheld();
+            staleOptions.shouldReclaim = admission.run(() => options.shouldReclaim);
+            staleOptions.shouldReclaimObserved = true;
+            assertUnheld();
+        }
+        if (!staleOptions.shouldRemoveObserved) {
+            assertUnheld();
+            staleOptions.shouldRemove = admission.run(() => options.shouldRemoveStaleLock);
+            staleOptions.shouldRemoveObserved = true;
+            assertUnheld();
+        }
+        if (!staleOptions.staleRecoveryObserved) {
+            assertUnheld();
+            staleOptions.staleRecovery = admission.run(() => options.staleRecovery);
+            staleOptions.staleRecoveryObserved = true;
+            assertUnheld();
+        }
+    }
+    catch (error) {
+        if (await retryHolderChange(error))
+            return;
+        if (await retryChangedBoundary())
+            return;
+        throw error;
+    }
+    const shouldReclaim = staleOptions.shouldReclaim ?? defaultSidecarLockShouldReclaim;
+    let reclaim;
+    try {
+        reclaim = await admission.run(async () => {
+            assertUnheld();
+            try {
+                return await Reflect.apply(shouldReclaim, undefined, [{
+                        lockPath,
+                        normalizedTargetPath,
+                        payload: snapshot.payload ?? null,
+                        staleMs: params.staleMs,
+                        nowMs: Date.now(),
+                        heldByThisProcess: false,
+                    }]);
+            }
+            finally {
+                assertUnheld();
+            }
+        });
+        assertUnheld();
+    }
+    catch (error) {
+        if (await retryHolderChange(error))
+            return;
+        if (await retryChangedBoundary())
+            return;
+        throw error;
+    }
+    if (!reclaim) {
+        await params.waitForRetry();
+        return;
+    }
+    let stillPresent;
+    try {
+        stillPresent = await sidecarLockSnapshotStillPresent(lockPath, snapshot, {
+            lockRoot: params.lockRoot,
+            parsePayload: scopedSidecarLockParser(params.parserState, admission, assertUnheld),
+        });
+        assertUnheld();
+    }
+    catch (error) {
+        if (await retryHolderChange(error))
+            return;
+        if (await retryChangedBoundary())
+            return;
+        throw error;
+    }
+    if (!stillPresent) {
+        await params.waitForRetry();
+        return;
+    }
+    if ((staleOptions.staleRecovery ?? "fail-closed") === "remove-if-unchanged") {
+        const acquiredGuard = await admission.run(() => tryAcquireSidecarReclaimGuard(params.reclaimGuards, params.reclaimGuardPath, params.lockRoot));
+        if (acquiredGuard)
+            params.setReclaimGuard(acquiredGuard);
+        params.assertToken();
+        if (params.currentHeld()) {
+            if (acquiredGuard) {
+                await params.releaseReclaimGuard();
+            }
+            await params.waitForRetry();
+            return;
+        }
+        if (!acquiredGuard) {
+            await params.waitForRetry();
+            return;
+        }
+        const shouldRemove = staleOptions.shouldRemove;
+        const assertRemovalAuthorized = assertUnheld;
+        const guardedShouldRemove = shouldRemove && function (staleSnapshot) {
+            return admission.run(async () => {
+                assertRemovalAuthorized();
+                try {
+                    return await Reflect.apply(shouldRemove, this, [staleSnapshot]);
+                }
+                finally {
+                    assertRemovalAuthorized();
+                }
+            });
+        };
+        let removal;
+        try {
+            removal = await removeStaleSidecarLockIfAllowed({
+                lockPath,
+                normalizedTargetPath,
+                snapshot,
+                assertGuardHeld: acquiredGuard.assertHeld && (() => admission.run(async () => {
+                    assertUnheld();
+                    await acquiredGuard.assertHeld();
+                    assertUnheld();
+                })),
+                shouldRemoveStaleLock: guardedShouldRemove,
+                lockRoot: params.lockRoot,
+                parsePayload: scopedSidecarLockParser(params.parserState, admission, assertRemovalAuthorized),
+                assertAuthorized: assertRemovalAuthorized,
+            });
+        }
+        catch (error) {
+            if (error !== holderChanged) {
+                try {
+                    assertRemovalAuthorized();
+                }
+                catch (boundaryError) {
+                    if (boundaryError !== holderChanged)
+                        throw boundaryError;
+                }
+                if (!params.currentHeld())
+                    throw error;
+            }
+            await params.releaseReclaimGuard();
+            await params.waitForRetry();
+            return;
+        }
+        params.assertToken();
+        if (params.currentHeld()) {
+            await params.releaseReclaimGuard();
+            await params.waitForRetry();
+            return;
+        }
+        if (removal === "removed")
+            return;
+        if (removal === "changed") {
+            await params.waitForRetry();
+            return;
+        }
+        await params.releaseReclaimGuard();
+    }
+    throw Object.assign(new Error(`file lock stale for ${normalizedTargetPath}`), {
+        code: "file_lock_stale",
+        lockPath,
+        normalizedTargetPath,
+    });
+}

package/dist/sidecar-lock-target.d.ts

@@ -0,0 +1,8 @@
+import type { Root } from "./root-impl.js";
+export declare function isCwdIndependentAbsolutePath(filePath: string): boolean;
+export declare function resolveSidecarTargetPath(resolved: string, lockRoot?: Root): Promise<string>;
+export declare function resolveSidecarLockPaths(targetPath: string, explicitLockPath: string | undefined, lockRoot: Root | undefined): Promise<{
+    lockPath: string;
+    normalizedTargetPath: string;
+}>;
+//# sourceMappingURL=sidecar-lock-target.d.ts.map

package/dist/sidecar-lock-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sidecar-lock-target.d.ts","sourceRoot":"","sources":["../src/sidecar-lock-target.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAG3C,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAItE;AAED,wBAAsB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAwBjG;AAED,wBAAsB,uBAAuB,CAC3C,UAAU,EAAE,MAAM,EAClB,gBAAgB,EAAE,MAAM,GAAG,SAAS,EACpC,QAAQ,EAAE,IAAI,GAAG,SAAS,GACzB,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,oBAAoB,EAAE,MAAM,CAAA;CAAE,CAAC,CAgB7D"}

package/dist/sidecar-lock-target.js

@@ -0,0 +1,55 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { canonicalPathFromExistingAncestor } from "./absolute-path.js";
+import { realpathSync } from "./realpath.js";
+import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
+import { anchorWindowsDriveRelativePath, assertNoWindowsPathAlias } from "./windows-path-alias.js";
+export function isCwdIndependentAbsolutePath(filePath) {
+    if (!path.isAbsolute(filePath))
+        return false;
+    // A leading separator on Windows is rooted on the process's current drive.
+    return process.platform !== "win32" || path.parse(filePath).root.length > 1;
+}
+export async function resolveSidecarTargetPath(resolved, lockRoot) {
+    assertNoWindowsPathAlias(resolved);
+    const dir = path.dirname(resolved);
+    if (lockRoot) {
+        // The target is an arbitration key, not necessarily inside the lock Root.
+        await lockRoot.resolve(".");
+        const parent = await canonicalPathFromExistingAncestor(dir);
+        await lockRoot.resolve(".");
+        assertNoWindowsPathAlias(parent);
+        const normalized = path.join(parent, path.basename(resolved));
+        assertNoWindowsPathAlias(normalized);
+        return normalized;
+    }
+    await fs.mkdir(recursiveMkdirPath(dir), { recursive: true });
+    let parent;
+    try {
+        parent = realpathSync.native(dir);
+    }
+    catch {
+        return resolved;
+    }
+    assertNoWindowsPathAlias(parent);
+    const normalized = path.join(parent, path.basename(resolved));
+    assertNoWindowsPathAlias(normalized);
+    return normalized;
+}
+export async function resolveSidecarLockPaths(targetPath, explicitLockPath, lockRoot) {
+    const anchoredTargetPath = anchorWindowsDriveRelativePath(targetPath);
+    assertNoWindowsPathAlias(anchoredTargetPath);
+    const resolvedTargetPath = path.resolve(anchoredTargetPath);
+    let resolvedLockPath;
+    if (explicitLockPath !== undefined) {
+        const anchoredLockPath = anchorWindowsDriveRelativePath(explicitLockPath);
+        assertNoWindowsPathAlias(anchoredLockPath);
+        resolvedLockPath = isCwdIndependentAbsolutePath(explicitLockPath)
+            ? explicitLockPath
+            : path.resolve(anchoredLockPath);
+    }
+    const normalizedTargetPath = await resolveSidecarTargetPath(resolvedTargetPath, lockRoot);
+    const lockPath = resolvedLockPath ?? `${normalizedTargetPath}.lock`;
+    assertNoWindowsPathAlias(lockPath);
+    return { lockPath, normalizedTargetPath };
+}

package/dist/sidecar-lock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sidecar-lock.d.ts","sourceRoot":"","sources":["../src/sidecar-lock.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,yBAAyB,EACzB,iBAAiB,EACjB,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,YAAY,EACV,yBAAyB,EACzB,0BAA0B,EAC1B,iBAAiB,EACjB,oBAAoB,EACpB,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,yBAAyB,CAAC;AAmIjC,0FAA0F;AAC1F,wBAAgB,uBAAuB,IAAI,OAAO,CAMjD;AAyFD,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM;cAU3B,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WACpD,yBAAyB,CAAC,QAAQ,CAAC,KAC3C,OAAO,CAAC,iBAAiB,CAAC;eAkBL,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WACxD,yBAAyB,CAAC,QAAQ,CAAC,MACxC,MAAM,OAAO,CAAC,CAAC,CAAC,KACnB,OAAO,CAAC,CAAC,CAAC;iBAqBW,OAAO,CAAC,IAAI,CAAC;iBAQnB,IAAI;uBAIE,oBAAoB,EAAE;EAW/C;AAED,wBAAsB,eAAe,CAAC,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC,EACzC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAMZ"}
+{"version":3,"file":"sidecar-lock.d.ts","sourceRoot":"","sources":["../src/sidecar-lock.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,yBAAyB,EACzB,iBAAiB,EACjB,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,YAAY,EACV,yBAAyB,EACzB,0BAA0B,EAC1B,iBAAiB,EACjB,oBAAoB,EACpB,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,yBAAyB,CAAC;AA2KjC,0FAA0F;AAC1F,wBAAgB,uBAAuB,IAAI,OAAO,CAMjD;AA8HD,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM;cAuB3B,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WACpD,yBAAyB,CAAC,QAAQ,CAAC,KAC3C,OAAO,CAAC,iBAAiB,CAAC;eAaL,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WACxD,yBAAyB,CAAC,QAAQ,CAAC,MACxC,MAAM,OAAO,CAAC,CAAC,CAAC,KACnB,OAAO,CAAC,CAAC,CAAC;iBAqBW,OAAO,CAAC,IAAI,CAAC;iBAQnB,IAAI;uBAIE,oBAAoB,EAAE;EAW/C;AAED,wBAAsB,eAAe,CAAC,CAAC,EAAE,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/E,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC,EACzC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAMZ"}

package/dist/sidecar-lock.js

@@ -8,7 +8,10 @@ import { createSuppressedError } from "./suppressed-error.js";
 const GLOBAL_STATE_KEY = Symbol.for("fsSafe.sidecarLockManagers");
 const GLOBAL_CLEANUP_KEY = Symbol.for("fsSafe.sidecarLockCleanupRegistered");
 const GLOBAL_CLEANUP_HANDLER_KEY = Symbol.for("fsSafe.sidecarLockCleanupHandler");
+const GLOBAL_CLEANUP_REGISTRATION_KEY = Symbol.for("fsSafe.sidecarLockCleanupRegistration");
 const GLOBAL_BEFORE_EXIT_KEY = Symbol.for("fsSafe.sidecarLockBeforeExitCleanup");
+const GLOBAL_BEFORE_EXIT_HANDLER_KEY = Symbol.for("fsSafe.sidecarLockBeforeExitCleanupHandler");
+const GLOBAL_BEFORE_EXIT_REGISTRATION_KEY = Symbol.for("fsSafe.sidecarLockBeforeExitCleanupRegistration");
 // Set by copies whose exit handlers honor retainOnExit. When an older package
 // copy registered the handlers first, this marker stays absent and retained
 // acquisitions must fail closed rather than silently lose the guarantee.
@@ -27,6 +30,7 @@ function resolveManagerState(key) {
         state = {
             cleanupRegistered: false,
             held: new Map(),
+            admissions: new Map(),
             reclaimCleanupRegistered: false,
             reclaimGuards: new Set(),
         };
@@ -34,7 +38,9 @@ function resolveManagerState(key) {
     }
     else {
         // The global manager symbol is shared across package copies and hot reloads.
-        // Backfill state created by fs-safe versions that predate reclaim guards.
+        // Backfill state created by fs-safe versions that predate admission tokens
+        // or reclaim guards without placing an incomplete value in the held map.
+        state.admissions ??= new Map();
         state.reclaimCleanupRegistered ??= false;
         state.reclaimGuards ??= new Set();
     }
@@ -107,21 +113,55 @@ function releaseAllLocksSync(state, options) {
         }
         state.held.delete(normalizedTargetPath);
     }
+    state.admissions?.clear();
     releaseAllReclaimGuardsSync(state);
 }
 function ensureGlobalExitCleanupRegistered() {
     const globalWithCleanup = globalThis;
     if (globalWithCleanup[GLOBAL_CLEANUP_KEY])
         return;
-    globalWithCleanup[GLOBAL_CLEANUP_KEY] = true;
-    globalWithCleanup[GLOBAL_RETAIN_AWARE_KEY] = true;
+    if (globalWithCleanup[GLOBAL_CLEANUP_REGISTRATION_KEY]) {
+        throw new FsSafeError("helper-unavailable", "sidecar lock exit cleanup registration is already in progress");
+    }
+    const registration = {};
     const cleanup = () => {
         for (const state of getGlobalManagers().values()) {
             releaseAllLocksSync(state, { preserveRetained: true });
         }
     };
-    globalWithCleanup[GLOBAL_CLEANUP_HANDLER_KEY] = cleanup;
-    process.on("exit", cleanup);
+    globalWithCleanup[GLOBAL_CLEANUP_REGISTRATION_KEY] = registration;
+    try {
+        process.on("exit", cleanup);
+        globalWithCleanup[GLOBAL_CLEANUP_HANDLER_KEY] = cleanup;
+        globalWithCleanup[GLOBAL_RETAIN_AWARE_KEY] = true;
+        globalWithCleanup[GLOBAL_CLEANUP_KEY] = true;
+    }
+    catch (error) {
+        if (process.listeners("exit").includes(cleanup)) {
+            try {
+                process.off("exit", cleanup);
+            }
+            catch {
+                // Reconcile the marker with the actual listener below.
+            }
+        }
+        if (process.listeners("exit").includes(cleanup)) {
+            globalWithCleanup[GLOBAL_CLEANUP_HANDLER_KEY] = cleanup;
+            globalWithCleanup[GLOBAL_RETAIN_AWARE_KEY] = true;
+            globalWithCleanup[GLOBAL_CLEANUP_KEY] = true;
+        }
+        else {
+            if (globalWithCleanup[GLOBAL_CLEANUP_HANDLER_KEY] === cleanup) {
+                delete globalWithCleanup[GLOBAL_CLEANUP_HANDLER_KEY];
+            }
+        }
+        throw error;
+    }
+    finally {
+        if (globalWithCleanup[GLOBAL_CLEANUP_REGISTRATION_KEY] === registration) {
+            delete globalWithCleanup[GLOBAL_CLEANUP_REGISTRATION_KEY];
+        }
+    }
 }
 /** True when a retain-unaware package copy registered the process-exit handlers first. */
 export function exitCleanupCannotRetain() {
@@ -133,10 +173,13 @@ function ensureGlobalBeforeExitCleanupRegistered() {
     if (globalWithCleanup[GLOBAL_BEFORE_EXIT_KEY]) {
         return globalWithCleanup[GLOBAL_BEFORE_EXIT_KEY];
     }
+    if (globalWithCleanup[GLOBAL_BEFORE_EXIT_REGISTRATION_KEY]) {
+        throw new FsSafeError("helper-unavailable", "sidecar lock before-exit cleanup registration is already in progress");
+    }
     // Independent of the exit registration, which an older package copy may own.
     const lifecycle = { armed: false };
-    globalWithCleanup[GLOBAL_BEFORE_EXIT_KEY] = lifecycle;
-    process.on("beforeExit", () => {
+    const registration = {};
+    const cleanup = () => {
         if (!lifecycle.armed)
             return;
         // Cleanup itself schedules I/O; retry only after another acquisition.
@@ -148,8 +191,42 @@ function ensureGlobalBeforeExitCleanupRegistered() {
                 }
             }
         }
-    });
-    return lifecycle;
+    };
+    globalWithCleanup[GLOBAL_BEFORE_EXIT_REGISTRATION_KEY] = registration;
+    try {
+        process.on("beforeExit", cleanup);
+        globalWithCleanup[GLOBAL_BEFORE_EXIT_HANDLER_KEY] = cleanup;
+        globalWithCleanup[GLOBAL_BEFORE_EXIT_KEY] = lifecycle;
+        return lifecycle;
+    }
+    catch (error) {
+        if (process.listeners("beforeExit").includes(cleanup)) {
+            try {
+                process.off("beforeExit", cleanup);
+            }
+            catch {
+                // Reconcile the marker with the actual listener below.
+            }
+        }
+        if (process.listeners("beforeExit").includes(cleanup)) {
+            globalWithCleanup[GLOBAL_BEFORE_EXIT_HANDLER_KEY] = cleanup;
+            globalWithCleanup[GLOBAL_BEFORE_EXIT_KEY] = lifecycle;
+        }
+        else {
+            if (globalWithCleanup[GLOBAL_BEFORE_EXIT_HANDLER_KEY] === cleanup) {
+                delete globalWithCleanup[GLOBAL_BEFORE_EXIT_HANDLER_KEY];
+            }
+            if (globalWithCleanup[GLOBAL_BEFORE_EXIT_KEY] === lifecycle) {
+                delete globalWithCleanup[GLOBAL_BEFORE_EXIT_KEY];
+            }
+        }
+        throw error;
+    }
+    finally {
+        if (globalWithCleanup[GLOBAL_BEFORE_EXIT_REGISTRATION_KEY] === registration) {
+            delete globalWithCleanup[GLOBAL_BEFORE_EXIT_REGISTRATION_KEY];
+        }
+    }
 }
 async function releaseHeldLock(state, normalizedTargetPath, held, options = {}) {
     const current = state.held.get(normalizedTargetPath);
@@ -194,7 +271,6 @@ async function releaseHeldLock(state, normalizedTargetPath, held, options = {})
     }
 }
 function handleForHeldLock(state, normalizedTargetPath, held) {
-    ensureGlobalBeforeExitCleanupRegistered().armed = true;
     return createHeldSidecarLockHandle({
         normalizedTargetPath,
         held,
@@ -204,21 +280,29 @@ function handleForHeldLock(state, normalizedTargetPath, held) {
 export function createSidecarLockManager(key) {
     const state = resolveManagerState(key);
     function ensureExitCleanupRegistered() {
+        ensureGlobalExitCleanupRegistered();
+        const lifecycle = ensureGlobalBeforeExitCleanupRegistered();
         state.cleanupRegistered = true;
         state.reclaimCleanupRegistered = true;
-        ensureGlobalExitCleanupRegistered();
-        ensureGlobalBeforeExitCleanupRegistered().armed = true;
+        return lifecycle;
+    }
+    function armExitCleanup(lifecycle) {
+        lifecycle.armed = true;
+    }
+    function assertRetainOnExitSupported(retainOnExit) {
+        if (retainOnExit !== true || !exitCleanupCannotRetain())
+            return;
+        throw new FsSafeError("helper-unavailable", "retainOnExit requires this process's exit handlers to be retain-aware; an older package copy registered them first");
     }
     async function acquire(options) {
-        if (options.retainOnExit === true && exitCleanupCannotRetain()) {
-            throw new FsSafeError("helper-unavailable", "retainOnExit requires this process's exit handlers to be retain-aware; an older package copy registered them first");
-        }
         return await acquireSidecarLock(options, {
             held: state.held,
+            admissions: state.admissions,
             reclaimGuards: state.reclaimGuards,
             ensureExitCleanupRegistered,
+            armExitCleanup,
+            assertRetainOnExitSupported,
             handleForHeldLock: (normalizedTargetPath, held) => handleForHeldLock(state, normalizedTargetPath, held),
-            releaseHeldLock: async (normalizedTargetPath, held, releaseOptions) => await releaseHeldLock(state, normalizedTargetPath, held, releaseOptions),
         });
     }
     async function withLock(options, fn) {

package/dist/temp-workspace-descriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"temp-workspace-descriptor.d.ts","sourceRoot":"","sources":["../src/temp-workspace-descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,SAAS,CAAC;AAU7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAMhF,OAAO,EAML,KAAK,yBAAyB,EAC/B,MAAM,8BAA8B,CAAC;AAEtC,KAAK,yBAAyB,GAAG,MAAM,GAAG,QAAQ,CAAC;AASnD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,yBAAyB,CAAC;IAClC,OAAO,EAAE,QAAQ,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,QAAQ,CAAC;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAClD,CAAC,CAAC;CACJ,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAmDpD,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,0BAA0B,GACpC,iBAAiB,CA8BnB;AAED,+EAA+E;AAC/E,qBAAa,0BAA0B;;IAWrC,OAAO,eAqBN;IAED,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,GAAG,0BAA0B,CAcjF;IAED,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG;QACjC,QAAQ,EAAE,0BAA0B,CAAC;QACrC,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC;KAC1B,CAoBA;IAED,qBAAqB,IAAI,IAAI,CAE5B;IAUD,iBAAiB,CACf,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,IAAI,EAAE,MAAM,GACX,yBAAyB,CAsB3B;IAoEK,cAAc,CAClB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,YAAY,EAAE,MAAM,IAAI,GACvB,OAAO,CAAC,IAAI,CAAC,CAgCf;IAED,kBAAkB,CAChB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,YAAY,EAAE,MAAM,IAAI,GACvB,IAAI,CAsBN;IAED,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED,cAAc,IAAI,OAAO,CAmDxB;IAED,QAAQ,CAAC,gBAAgB,EAAE,OAAO,GAAG;QACnC,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,EAAE,QAAQ,CAAC;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QACjD,SAAS,EAAE,sBAAsB,GAAG,SAAS,CAAC;KAC/C,CAiCA;IAED,KAAK,IAAI,IAAI,CAOZ;CACF"}
+{"version":3,"file":"temp-workspace-descriptor.d.ts","sourceRoot":"","sources":["../src/temp-workspace-descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,SAAS,CAAC;AAU7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAMhF,OAAO,EAML,KAAK,yBAAyB,EAC/B,MAAM,8BAA8B,CAAC;AAEtC,KAAK,yBAAyB,GAAG,MAAM,GAAG,QAAQ,CAAC;AASnD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,yBAAyB,CAAC;IAClC,OAAO,EAAE,QAAQ,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,QAAQ,CAAC;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAClD,CAAC,CAAC;CACJ,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAmDpD,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,0BAA0B,GACpC,iBAAiB,CA8BnB;AAED,+EAA+E;AAC/E,qBAAa,0BAA0B;;IAWrC,OAAO,eAqBN;IAED,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,GAAG,0BAA0B,CAcjF;IAED,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG;QACjC,QAAQ,EAAE,0BAA0B,CAAC;QACrC,IAAI,EAAE,MAAM,CAAC,WAAW,CAAC;KAC1B,CAoBA;IAED,qBAAqB,IAAI,IAAI,CAE5B;IAUD,iBAAiB,CACf,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,IAAI,EAAE,MAAM,GACX,yBAAyB,CAsB3B;IAgEK,cAAc,CAClB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,YAAY,EAAE,MAAM,IAAI,GACvB,OAAO,CAAC,IAAI,CAAC,CAgCf;IAED,kBAAkB,CAChB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,YAAY,EAAE,MAAM,IAAI,GACvB,IAAI,CAsBN;IAED,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED,cAAc,IAAI,OAAO,CA2CxB;IAED,QAAQ,CAAC,gBAAgB,EAAE,OAAO,GAAG;QACnC,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,EAAE,QAAQ,CAAC;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QACjD,SAAS,EAAE,sBAAsB,GAAG,SAAS,CAAC;KAC/C,CA0BA;IAED,KAAK,IAAI,IAAI,CAOZ;CACF"}

package/dist/temp-workspace-descriptor.js

@@ -185,18 +185,15 @@ export class TempWorkspaceRetainedChild {
         return descriptor;
     }
     async #assertProcAuthority(fd, ownerUid) {
-        if ((await fs.statfs("/proc/self/fd", { bigint: true })).type !== 0x9fa0n) {
-            throw new FsSafeError("path-mismatch", "directory mode requires a trusted procfs fd namespace");
-        }
-        const procPath = `/proc/self/fd/${fd}`;
-        const opened = inspectFileIdentitySync(() => fsSync.fstatSync(fd, { bigint: true }), this.#identity);
-        const followed = inspectFileIdentitySync(() => fsSync.statSync(procPath, { bigint: true }), this.#identity);
-        assertOwnedDirectory(opened, followed);
-        assertTempWorkspaceChildState(opened, ownerUid);
-        assertTempWorkspaceChildState(followed, ownerUid);
+        const filesystem = await fs.statfs("/proc/self/fd", { bigint: true });
+        this.#assertProcDescriptorAuthority(fd, ownerUid, filesystem.type);
     }
     #assertProcAuthoritySync(fd, ownerUid) {
-        if (fsSync.statfsSync("/proc/self/fd", { bigint: true }).type !== 0x9fa0n) {
+        const filesystem = fsSync.statfsSync("/proc/self/fd", { bigint: true });
+        this.#assertProcDescriptorAuthority(fd, ownerUid, filesystem.type);
+    }
+    #assertProcDescriptorAuthority(fd, ownerUid, filesystemType) {
+        if (filesystemType !== 0x9fa0n) {
             throw new FsSafeError("path-mismatch", "directory mode requires a trusted procfs fd namespace");
         }
         const procPath = `/proc/self/fd/${fd}`;
@@ -309,13 +306,7 @@ export class TempWorkspaceRetainedChild {
         catch (error) {
             // The readable replacement has not been installed. Give it exactly one
             // close attempt and leave neither indeterminate descriptor owned here.
-            try {
-                fsSync.closeSync(fd);
-            }
-            catch (closeError) {
-                throw new AggregateError([error, closeError], "temp workspace child descriptor replacement close failed");
-            }
-            throw error;
+            closeAfterAdmissionFailure(fd, error, "temp workspace child descriptor replacement close failed");
         }
         this.#fd = fd;
         this.#access = "read";
@@ -334,16 +325,7 @@ export class TempWorkspaceRetainedChild {
         const fd = this.#fd;
         this.#fd = undefined;
         if (retainDescriptor && !this.canEnumerate) {
-            try {
-                fsSync.closeSync(fd);
-            }
-            catch (closeError) {
-                throw new AggregateError([
-                    new FsSafeError("helper-unavailable", "temp workspace cleanup requires a readable child descriptor"),
-                    closeError,
-                ], "temp workspace child descriptor rejection and close failed");
-            }
-            throw new FsSafeError("helper-unavailable", "temp workspace cleanup requires a readable child descriptor");
+            closeAfterAdmissionFailure(fd, new FsSafeError("helper-unavailable", "temp workspace cleanup requires a readable child descriptor"), "temp workspace child descriptor rejection and close failed");
         }
         if (!retainDescriptor) {
             fsSync.closeSync(fd);

package/dist/temp-workspace-owner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"temp-workspace-owner.d.ts","sourceRoot":"","sources":["../src/temp-workspace-owner.ts"],"names":[],"mappings":"AAOA,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAEnE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAChF,OAAO,EAEL,0BAA0B,EAE1B,KAAK,iBAAiB,EACvB,MAAM,gCAAgC,CAAC;AAGxC,MAAM,MAAM,0BAA0B,GAAG,SAAS,GAAG,SAAS,GAAG,mBAAmB,GAAG,eAAe,CAAC;AACvG,MAAM,MAAM,0BAA0B,GAAG,YAAY,GAAG,iBAAiB,CAAC;AAsB1E,qBAAa,8BAA8B;;IACzC,QAAQ,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAM/C,YACE,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,0BAA0B,EAClC,SAAS,EAAE,0BAA0B,EACrC,OAAO,EAAE,MAAM,EAuEhB;IAED,IAAI,kBAAkB,IAAI,OAAO,CAGhC;IAED,oBAAoB,IAAI,IAAI,CAiB3B;IAUD,oBAAoB,CAAC,YAAY,EAAE,OAAO,GAAG,OAAO,CAenD;IAED,aAAa,IAAI,IAAI,CAEpB;IAED,qBAAqB,IAAI,IAAI,CAE5B;IAED,KAAK,IAAI,IAAI,CAIZ;CACF;AAED,qBAAa,yBAAyB;;IAWpC,YACE,QAAQ,EAAE,0BAA0B,EACpC,UAAU,EAAE,8BAA8B,EAC1C,gBAAgB,EAAE,OAAO,EAO1B;IAkLD,OAAO,IAAI,OAAO,CAAC,0BAA0B,CAAC,CAM7C;IAED,WAAW,IAAI,0BAA0B,CAexC;CACF"}
+{"version":3,"file":"temp-workspace-owner.d.ts","sourceRoot":"","sources":["../src/temp-workspace-owner.ts"],"names":[],"mappings":"AAOA,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAEnE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAChF,OAAO,EAEL,0BAA0B,EAE1B,KAAK,iBAAiB,EACvB,MAAM,gCAAgC,CAAC;AAGxC,MAAM,MAAM,0BAA0B,GAAG,SAAS,GAAG,SAAS,GAAG,mBAAmB,GAAG,eAAe,CAAC;AACvG,MAAM,MAAM,0BAA0B,GAAG,YAAY,GAAG,iBAAiB,CAAC;AAuB1E,qBAAa,8BAA8B;;IACzC,QAAQ,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAM/C,YACE,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,0BAA0B,EAClC,SAAS,EAAE,0BAA0B,EACrC,OAAO,EAAE,MAAM,EAuEhB;IAED,IAAI,kBAAkB,IAAI,OAAO,CAGhC;IAED,oBAAoB,IAAI,IAAI,CAiB3B;IAUD,oBAAoB,CAAC,YAAY,EAAE,OAAO,GAAG,OAAO,CAenD;IAED,aAAa,IAAI,IAAI,CAEpB;IAED,qBAAqB,IAAI,IAAI,CAE5B;IAED,KAAK,IAAI,IAAI,CAIZ;CACF;AAED,qBAAa,yBAAyB;;IAWpC,YACE,QAAQ,EAAE,0BAA0B,EACpC,UAAU,EAAE,8BAA8B,EAC1C,gBAAgB,EAAE,OAAO,EAO1B;IAkLD,OAAO,IAAI,OAAO,CAAC,0BAA0B,CAAC,CAM7C;IAED,WAAW,IAAI,0BAA0B,CAexC;CACF"}

package/dist/temp-workspace-owner.js

@@ -294,22 +294,22 @@ export class TempWorkspaceCleanupOwner {
                 await beforeNativeRemoval(quarantine.path);
             return this.#mapRemoval(await this.#capability.binding.removeOwnedTree(this.#capability.parent.fd, quarantine.name, this.#directory.fd));
         }
-        let removalError;
+        let removalFailure;
         try {
             this.#assertQuarantine(quarantine);
             try {
                 await fs.rm(quarantine.path, { recursive: true, force: true });
             }
             catch (error) {
-                removalError = error;
+                removalFailure = { error };
                 throw error;
             }
             this.#capability.assertCurrent();
             return "removed";
         }
         catch (error) {
-            if (error === removalError)
-                throw error;
+            if (removalFailure !== undefined)
+                throw removalFailure.error;
             return "indeterminate";
         }
     }
@@ -318,22 +318,22 @@ export class TempWorkspaceCleanupOwner {
             getFsSafeTestHooks()?.beforeTempWorkspaceNativeRemovalSync?.(quarantine.path);
             return this.#mapRemoval(this.#capability.binding.removeOwnedTreeSync(this.#capability.parent.fd, quarantine.name, this.#directory.fd));
         }
-        let removalError;
+        let removalFailure;
         try {
             this.#assertQuarantine(quarantine);
             try {
                 fsSync.rmSync(quarantine.path, { recursive: true, force: true });
             }
             catch (error) {
-                removalError = error;
+                removalFailure = { error };
                 throw error;
             }
             this.#capability.assertCurrent();
             return "removed";
         }
         catch (error) {
-            if (error === removalError)
-                throw error;
+            if (removalFailure !== undefined)
+                throw removalFailure.error;
             return "indeterminate";
         }
     }

package/dist/walk.d.ts

@@ -16,6 +16,10 @@ export type WalkDirectoryOptions = {
     include?: (entry: WalkDirectoryEntry) => boolean;
     descend?: (entry: WalkDirectoryEntry) => boolean;
 };
+export type AsyncWalkDirectoryOptions = Omit<WalkDirectoryOptions, "include" | "descend"> & {
+    include?: (entry: WalkDirectoryEntry) => boolean | Promise<boolean>;
+    descend?: (entry: WalkDirectoryEntry) => boolean | Promise<boolean>;
+};
 export type WalkDirectoryFailure = {
     path: string;
     relativePath: string;
@@ -32,6 +36,6 @@ type WalkDirectoryResultWithFailures = WalkDirectoryResult & {
     failedDirs: WalkDirectoryFailure[];
 };
 export declare function walkDirectorySync(rootDir: string, options?: WalkDirectoryOptions): WalkDirectoryResultWithFailures;
-export declare function walkDirectory(rootDir: string, options?: WalkDirectoryOptions): Promise<WalkDirectoryResultWithFailures>;
+export declare function walkDirectory(rootDir: string, options?: AsyncWalkDirectoryOptions): Promise<WalkDirectoryResultWithFailures>;
 export {};
 //# sourceMappingURL=walk.d.ts.map

package/dist/walk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"walk.d.ts","sourceRoot":"","sources":["../src/walk.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,SAAS,CAAC;AAS7B,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AACvE,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE9D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC;IACjD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC;CAClD,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,OAAO,CAAC;IAGnB,UAAU,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACrC,CAAC;AAEF,KAAK,+BAA+B,GAAG,mBAAmB,GAAG;IAC3D,UAAU,EAAE,oBAAoB,EAAE,CAAC;CACpC,CAAC;AA+EF,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,oBAAyB,GACjC,+BAA+B,CA2DjC;AAED,wBAAsB,aAAa,CACjC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,+BAA+B,CAAC,CA2D1C"}
+{"version":3,"file":"walk.d.ts","sourceRoot":"","sources":["../src/walk.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,SAAS,CAAC;AAS7B,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AACvE,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE9D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC;IACjD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC;CAClD,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAAC,oBAAoB,EAAE,SAAS,GAAG,SAAS,CAAC,GAAG;IAC1F,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACpE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACrE,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,OAAO,CAAC;IAGnB,UAAU,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACrC,CAAC;AAEF,KAAK,+BAA+B,GAAG,mBAAmB,GAAG;IAC3D,UAAU,EAAE,oBAAoB,EAAE,CAAC;CACpC,CAAC;AAoFF,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,oBAAyB,GACjC,+BAA+B,CA4DjC;AAED,wBAAsB,aAAa,CACjC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,+BAA+B,CAAC,CAiE1C"}