@openclaw/openshell-sandbox 2026.9.5 → 2026.9.7

package/node_modules/@openclaw/fs-safe/dist/directory-durability.js

@@ -3,7 +3,8 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { ensureAbsoluteDirectory } from "./absolute-path.js";
 import { FsSafeError } from "./errors.js";
-import { sameFileIdentity } from "./file-identity.js";
+import { assertDirectoryReceiptCurrentSync, copyRetainedDirectoryReceipt, createDirectoryReceiptSync, directoryReceiptAuthority, directoryReceiptIdentity, ownDirectoryReceipt, } from "./directory-receipt.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { assertNoWindowsPathAlias, pathForWindowsFilesystem, resolvePathPreservingWindowsRoot } from "./windows-path-alias.js";
 import { realpathSync } from "./realpath.js";
 function directoryOpenFlags() {
@@ -38,81 +39,23 @@ function unsupportedOutcome(error) {
     const code = error.code;
     return code ? { status: "unsupported", code } : { status: "unsupported" };
 }
-function assertDirectory(identity, pathname, label) {
-    if (identity.isSymbolicLink() || !identity.isDirectory()) {
-        throw new FsSafeError("not-file", `${label} must be a real directory: ${pathname}`);
-    }
-}
-function ownDirectoryReceipt(receipt) {
-    const pathname = receipt.path;
-    const realPath = receipt.realPath;
-    const identity = receipt.identity;
-    return { path: pathname, realPath, identity };
-}
-function assertDirectoryReceiptPaths(receipt, label) {
-    assertNoWindowsPathAlias(receipt.path, "filesystem", `${label} path uses a Windows filesystem namespace alias`);
-    assertNoWindowsPathAlias(receipt.realPath, "filesystem", `${label} real path uses a Windows filesystem namespace alias`);
-}
 async function createDirectoryReceipt(directoryPath, label) {
-    assertNoWindowsPathAlias(directoryPath, "filesystem", `${label} path uses a Windows filesystem namespace alias`);
-    const resolvedPath = resolvePathPreservingWindowsRoot(directoryPath);
-    assertNoWindowsPathAlias(resolvedPath, "filesystem", `${label} path uses a Windows filesystem namespace alias`);
-    const operationPath = pathForWindowsFilesystem(resolvedPath);
-    const identity = fsSync.lstatSync(operationPath);
-    assertDirectory(identity, resolvedPath, label);
-    const realPath = realpathSync.native(operationPath);
-    assertNoWindowsPathAlias(realPath, "filesystem", `${label} real path uses a Windows filesystem namespace alias`);
-    return {
-        path: resolvedPath,
-        realPath,
-        identity,
-    };
-}
-function createDirectoryReceiptSync(directoryPath, label) {
-    assertNoWindowsPathAlias(directoryPath, "filesystem", `${label} path uses a Windows filesystem namespace alias`);
-    const resolvedPath = resolvePathPreservingWindowsRoot(directoryPath);
-    assertNoWindowsPathAlias(resolvedPath, "filesystem", `${label} path uses a Windows filesystem namespace alias`);
-    const operationPath = pathForWindowsFilesystem(resolvedPath);
-    const identity = fsSync.lstatSync(operationPath);
-    assertDirectory(identity, resolvedPath, label);
-    const realPath = realpathSync(operationPath);
-    assertNoWindowsPathAlias(realPath, "filesystem", `${label} real path uses a Windows filesystem namespace alias`);
-    return {
-        path: resolvedPath,
-        realPath,
-        identity,
-    };
+    return createDirectoryReceiptSync(directoryPath, label, realpathSync.native);
 }
 async function assertDirectoryReceiptCurrent(receipt, label) {
-    assertDirectoryReceiptPaths(receipt, label);
-    const operationPath = pathForWindowsFilesystem(receipt.path);
-    const currentIdentity = fsSync.lstatSync(operationPath);
-    assertDirectory(currentIdentity, receipt.path, label);
-    const realPath = realpathSync.native(operationPath);
-    assertNoWindowsPathAlias(realPath, "filesystem", `${label} real path uses a Windows filesystem namespace alias`);
-    if (!sameFileIdentity(receipt.identity, currentIdentity) ||
-        realPath !== receipt.realPath) {
-        throw new FsSafeError("path-mismatch", `${label} changed during durable directory operation: ${receipt.path}`);
-    }
+    assertDirectoryReceiptCurrentSync(receipt, label, realpathSync.native);
 }
-function assertDirectoryReceiptCurrentSync(receipt, label) {
-    assertDirectoryReceiptPaths(receipt, label);
-    const operationPath = pathForWindowsFilesystem(receipt.path);
-    const currentIdentity = fsSync.lstatSync(operationPath);
-    assertDirectory(currentIdentity, receipt.path, label);
-    const realPath = realpathSync(operationPath);
-    assertNoWindowsPathAlias(realPath, "filesystem", `${label} real path uses a Windows filesystem namespace alias`);
-    if (!sameFileIdentity(receipt.identity, currentIdentity) ||
-        realPath !== receipt.realPath) {
-        throw new FsSafeError("path-mismatch", `${label} changed during durable directory operation: ${receipt.path}`);
-    }
+function assertOpenDirectoryIdentity(descriptor, receipt, label) {
+    inspectFileIdentitySync(() => {
+        const opened = fsSync.fstatSync(descriptor, { bigint: true });
+        if (!opened.isDirectory()) {
+            throw new FsSafeError("not-file", `${label} must be a real directory: ${receipt.path}`);
+        }
+        return opened;
+    }, directoryReceiptAuthority(receipt).identity);
 }
 async function assertOpenDirectoryCurrent(handle, receipt, label) {
-    const openedIdentity = fsSync.fstatSync(handle.fd);
-    assertDirectory(openedIdentity, receipt.path, label);
-    if (!sameFileIdentity(receipt.identity, openedIdentity)) {
-        throw new FsSafeError("path-mismatch", `${label} handle changed during directory sync: ${receipt.path}`);
-    }
+    assertOpenDirectoryIdentity(handle.fd, receipt, label);
     await assertDirectoryReceiptCurrent(receipt, label);
 }
 class PinnedDirectoryImpl {
@@ -124,7 +67,7 @@ class PinnedDirectoryImpl {
     constructor(handle, receipt, label) {
         this.#handle = handle;
         this.#authority = receipt;
-        this.receipt = ownDirectoryReceipt(receipt);
+        this.receipt = copyRetainedDirectoryReceipt(receipt);
         this.#label = label;
     }
     async assertCurrent() {
@@ -213,11 +156,7 @@ export function syncDirectorySync(directory, options = {}) {
         return unsupportedOutcome(error);
     }
     try {
-        const openedIdentity = fsSync.fstatSync(descriptor);
-        assertDirectory(openedIdentity, receipt.path, label);
-        if (!sameFileIdentity(receipt.identity, openedIdentity)) {
-            throw new FsSafeError("path-mismatch", `${label} handle changed during directory sync: ${receipt.path}`);
-        }
+        assertOpenDirectoryIdentity(descriptor, receipt, label);
         assertDirectoryReceiptCurrentSync(receipt, label);
         try {
             fsSync.fsyncSync(descriptor);
@@ -273,13 +212,16 @@ export async function ensureDurableDirectory(options) {
     assertNoWindowsPathAlias(requestedDirectoryPath, "filesystem", `${label} path uses a Windows filesystem namespace alias`);
     const directoryPath = resolvePathPreservingWindowsRoot(requestedDirectoryPath);
     assertNoWindowsPathAlias(directoryPath, "filesystem", `${label} path uses a Windows filesystem namespace alias`);
+    const expectedInput = options.expectedExistingIdentity;
+    const expectedIdentity = expectedInput && directoryReceiptIdentity(expectedInput);
     const ancestorReceipt = await findExistingAncestorReceipt(directoryPath, label);
     const targetExists = ancestorReceipt.path === directoryPath;
-    const expectedExistingIdentity = options.expectedExistingIdentity;
-    if (expectedExistingIdentity &&
-        (!targetExists || !sameFileIdentity(expectedExistingIdentity, ancestorReceipt.identity))) {
+    if (expectedIdentity && !targetExists) {
         throw new FsSafeError("path-mismatch", `${label} changed before durable directory pinning: ${directoryPath}`);
     }
+    if (expectedIdentity) {
+        inspectFileIdentitySync(() => directoryReceiptAuthority(ancestorReceipt).identity, expectedIdentity);
+    }
     const ancestor = await pinDirectory(ancestorReceipt, { label });
     const pinnedDirectories = [ancestor];
     try {
@@ -336,7 +278,7 @@ export async function ensureDurableDirectory(options) {
         }
         await ancestor.assertCurrent();
         await assertDirectoryReceiptCurrent(finalReceipt, label);
-        return { ...finalReceipt, parentSync };
+        return Object.assign(copyRetainedDirectoryReceipt(finalReceipt), { parentSync });
     }
     finally {
         await Promise.all(pinnedDirectories.toReversed().map(async (directory) => directory.close()));

package/node_modules/@openclaw/fs-safe/dist/directory-entry-path.d.ts

@@ -1,3 +1,2 @@
 /** Strip only trailing separators: lstat must inspect the entry, not follow a leaf link. */
 export declare function directoryEntryPath(dir: string, platform?: NodeJS.Platform): string;
-//# sourceMappingURL=directory-entry-path.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/directory-guard.d.ts

@@ -6,11 +6,7 @@ export type AsyncDirectoryGuard<T extends Stats | BigIntStats = Stats> = {
     stat: T;
 };
 export type AnyAsyncDirectoryGuard = AsyncDirectoryGuard<Stats | BigIntStats>;
-export type SyncDirectoryGuard = {
-    dir: string;
-    realPath: string;
-    stat: Stats;
-};
+export type SyncDirectoryGuard = AsyncDirectoryGuard;
 export type DirectoryIdentity = Readonly<{
     dev: bigint;
     ino: bigint;
@@ -30,14 +26,16 @@ export declare function createAsyncDirectoryGuard(dir: string, options?: {
 export declare function createAsyncDirectoryGuard(dir: string, options: {
     bigint: boolean;
 }): Promise<AnyAsyncDirectoryGuard>;
-export declare function assertAsyncDirectoryGuard(guard: AnyAsyncDirectoryGuard): Promise<void>;
 export declare function createSyncDirectoryGuard(dir: string): SyncDirectoryGuard;
+export declare function assertAsyncDirectoryGuard(guard: AnyAsyncDirectoryGuard): Promise<void>;
 export declare function assertSyncDirectoryGuard(guard: SyncDirectoryGuard | AnyAsyncDirectoryGuard): void;
 export declare function createNearestExistingDirectoryGuard(rootReal: string, targetPath: string): Promise<AsyncDirectoryGuard>;
+export declare function createNearestExistingDirectoryGuard(rootReal: string, targetPath: string, options: {
+    bigint: true;
+}): Promise<AsyncDirectoryGuard<BigIntStats>>;
 export declare function createNearestExistingDirectoryGuard(rootReal: string, targetPath: string, options: {
     bigint: boolean;
 }): Promise<AnyAsyncDirectoryGuard>;
-export declare function createNearestExistingSyncDirectoryGuard(rootReal: string, targetPath: string): SyncDirectoryGuard;
 export declare function inspectDirectoryIdentity(dir: string, expected?: Pick<BigIntStats, "dev" | "ino">): Promise<BigIntStats>;
 export declare function observeDirectoryIdentitySync(dir: string, options: {
     bigint: true;
@@ -54,4 +52,3 @@ export declare function extendDirectoryObservationGuard(observation: StatObserva
 export declare function inspectDirectoryObservationSync(dir: string, expected?: ExactStatIdentity): StatObservationReceipt;
 export declare function assertDirectoryObservationSync(dir: string, expected: ExactStatIdentity): Stats | BigIntStats;
 export declare function assertDirectoryObservationGuardSync(guard: DirectoryObservationGuard): void;
-//# sourceMappingURL=directory-guard.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/directory-guard.js

@@ -30,6 +30,12 @@ export function assertDirectoryIdentitySync(observedPath, expected) {
     }
 }
 export async function createAsyncDirectoryGuard(dir, options) {
+    return captureDirectoryGuard(dir, "native", options);
+}
+export function createSyncDirectoryGuard(dir) {
+    return captureDirectoryGuard(dir, "normalized");
+}
+function captureDirectoryGuard(dir, mode, options) {
     const operationPath = directoryOperationPath(dir);
     const stat = options?.bigint
         ? inspectDirectoryIdentityAtPathSync(operationPath, undefined, options.initial)
@@ -37,11 +43,17 @@ export async function createAsyncDirectoryGuard(dir, options) {
     if (stat.isSymbolicLink() || !stat.isDirectory()) {
         throw directoryComponentNotDirectoryError();
     }
-    const realPath = realpathSync.native(operationPath);
+    const realPath = mode === "native" ? realpathSync.native(operationPath) : realpathSync(operationPath);
     assertNoWindowsPathAlias(realPath, "filesystem");
     return { dir, realPath, stat };
 }
 export async function assertAsyncDirectoryGuard(guard) {
+    assertDirectoryGuard(guard, "native");
+}
+export function assertSyncDirectoryGuard(guard) {
+    assertDirectoryGuard(guard, "normalized");
+}
+function assertDirectoryGuard(guard, mode) {
     const dir = guard.dir;
     const operationPath = directoryOperationPath(dir);
     const expectedRealPath = guard.realPath;
@@ -57,71 +69,29 @@ export async function assertAsyncDirectoryGuard(guard) {
     if (stat.isSymbolicLink() || !stat.isDirectory()) {
         throw directoryComponentNotDirectoryError();
     }
-    if (!sameFileIdentity(stat, expectedIdentity)) {
+    // Native guards check identity first; normalized numeric guards preserve
+    // canonicalization errors before their final identity comparison.
+    if (mode === "native" && !sameFileIdentity(stat, expectedIdentity)) {
         throw new FsSafeError("path-mismatch", "directory changed during operation");
     }
-    const realPath = realpathSync.native(operationPath);
-    assertNoWindowsPathAlias(realPath, "filesystem");
-    if (realPath !== expectedRealPath) {
-        throw new FsSafeError("path-mismatch", "directory changed during operation");
-    }
-}
-export function createSyncDirectoryGuard(dir) {
-    const operationPath = directoryOperationPath(dir);
-    const stat = fsSync.lstatSync(operationPath);
-    if (stat.isSymbolicLink() || !stat.isDirectory()) {
-        throw directoryComponentNotDirectoryError();
-    }
-    const realPath = realpathSync(operationPath);
-    assertNoWindowsPathAlias(realPath, "filesystem");
-    return { dir, realPath, stat };
-}
-export function assertSyncDirectoryGuard(guard) {
-    const dir = guard.dir;
-    const operationPath = directoryOperationPath(dir);
-    const expectedRealPath = guard.realPath;
-    assertNoWindowsPathAlias(expectedRealPath, "filesystem");
-    const expectedStat = guard.stat;
-    const expectedIdentity = { dev: expectedStat.dev, ino: expectedStat.ino };
-    const stat = typeof expectedIdentity.dev === "bigint" && typeof expectedIdentity.ino === "bigint"
-        ? inspectDirectoryIdentityAtPathSync(operationPath, { dev: expectedIdentity.dev, ino: expectedIdentity.ino })
-        : fsSync.lstatSync(operationPath);
-    if (stat.isSymbolicLink() || !stat.isDirectory()) {
-        throw directoryComponentNotDirectoryError();
-    }
-    const realPath = typeof expectedIdentity.ino === "bigint"
+    const realPath = mode === "native" || typeof expectedIdentity.ino === "bigint"
         ? realpathSync.native(operationPath) : realpathSync(operationPath);
     assertNoWindowsPathAlias(realPath, "filesystem");
-    if (!sameFileIdentity(stat, expectedIdentity) || realPath !== expectedRealPath) {
+    if ((mode === "normalized" && !sameFileIdentity(stat, expectedIdentity)) || realPath !== expectedRealPath) {
         throw new FsSafeError("path-mismatch", "directory changed during operation");
     }
 }
 export async function createNearestExistingDirectoryGuard(rootReal, targetPath, options = { bigint: false }) {
-    assertNoWindowsPathAlias(rootReal, "filesystem");
-    assertNoWindowsPathAlias(targetPath, "filesystem");
-    let current = resolvePathPreservingWindowsRoot(targetPath);
-    const root = resolvePathPreservingWindowsRoot(rootReal);
-    while (current !== root) {
-        try {
-            return await createAsyncDirectoryGuard(current, options);
-        }
-        catch (error) {
-            if (!isNotFoundPathError(error)) {
-                throw error;
-            }
-            current = path.dirname(current);
-        }
-    }
-    return await createAsyncDirectoryGuard(root, options);
+    return nearestExistingDirectoryGuard(rootReal, targetPath, "native", options);
 }
-export function createNearestExistingSyncDirectoryGuard(rootReal, targetPath) {
+function nearestExistingDirectoryGuard(rootReal, targetPath, mode, options) {
     assertNoWindowsPathAlias(rootReal, "filesystem");
     assertNoWindowsPathAlias(targetPath, "filesystem");
     let current = resolvePathPreservingWindowsRoot(targetPath);
     const root = resolvePathPreservingWindowsRoot(rootReal);
     while (current !== root) {
         try {
-            return createSyncDirectoryGuard(current);
+            return captureDirectoryGuard(current, mode, options);
         }
         catch (error) {
             if (!isNotFoundPathError(error)) {
@@ -130,15 +100,11 @@ export function createNearestExistingSyncDirectoryGuard(rootReal, targetPath) {
             current = path.dirname(current);
         }
     }
-    return createSyncDirectoryGuard(root);
+    return captureDirectoryGuard(root, mode, options);
 }
 // Recovery receipts must retain every identity bit, including on Windows.
 export async function inspectDirectoryIdentity(dir, expected) {
-    const operationPath = directoryOperationPath(dir);
-    const expectedIdentity = expected === undefined
-        ? undefined
-        : { dev: expected.dev, ino: expected.ino };
-    return inspectDirectoryIdentityAtPathSync(operationPath, expectedIdentity);
+    return inspectDirectoryIdentitySync(dir, expected);
 }
 function directoryOperationPath(dir) {
     assertNoWindowsPathAlias(dir, "filesystem");

package/node_modules/@openclaw/fs-safe/dist/directory-mode-node.d.ts

@@ -1,5 +1,25 @@
-import { type BigIntStats } from "node:fs";
-import { type DirectoryModeOwner } from "./directory-mode-owner.js";
+import { type BigIntStats, type Stats } from "node:fs";
+export type DirectoryModeChecks = {
+    check?: () => void;
+    beforeChmod?: () => Promise<void>;
+};
+export type DirectoryModeOwner = {
+    verify(check?: () => void): Promise<void>;
+    apply(mode: number, checks?: DirectoryModeChecks): Promise<void>;
+    close(): Promise<void>;
+};
+export declare function assertOwnedDirectory(expected: Stats | BigIntStats, actual: Stats | BigIntStats): void;
+/** Serializes use and close: even a queued path-based fd operation retains its descriptor. */
+export declare function ownDirectoryMode(params: {
+    inspect: () => Promise<number>;
+    chmod: (mode: number) => Promise<void>;
+    prepareChmod?: () => Promise<void>;
+    verifyChmod?: () => Promise<void>;
+    close: () => Promise<void>;
+    ignoreChmodError?: boolean;
+}): DirectoryModeOwner;
+/** Darwin descriptor inspection avoids requesting directory-content reads. */
+export declare function nodeDarwinDirectoryMetadataFlags(): number;
 export declare function nodeDirectorySearchOnlyFlags(): {
     flags: number;
     proc: boolean;
@@ -17,4 +37,3 @@ export declare function pinNodeDirectoryForModeSync(dirPath: string, options?: {
     apply(mode: number, check?: () => void): void;
     close(): void;
 };
-//# sourceMappingURL=directory-mode-node.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/directory-mode-node.js

@@ -3,7 +3,91 @@ import fs from "node:fs/promises";
 import { FsSafeError } from "./errors.js";
 import { inspectDirectoryIdentity, inspectDirectoryIdentitySync } from "./directory-guard.js";
 import { inspectFileIdentity, inspectFileIdentitySync } from "./strict-file-identity.js";
-import { assertOwnedDirectory, ownDirectoryMode } from "./directory-mode-owner.js";
+import { sameFileIdentityForCleanup } from "./file-identity.js";
+export function assertOwnedDirectory(expected, actual) {
+    if (actual.isSymbolicLink() || !actual.isDirectory()) {
+        throw new FsSafeError("not-file", "directory mode target must be a real directory");
+    }
+    if (!sameFileIdentityForCleanup(expected, actual)) {
+        throw new FsSafeError("path-mismatch", "directory changed before its mode could be applied");
+    }
+}
+/** Serializes use and close: even a queued path-based fd operation retains its descriptor. */
+export function ownDirectoryMode(params) {
+    let pending = Promise.resolve();
+    let closing;
+    const enqueue = (run) => {
+        if (closing)
+            return Promise.reject(new FsSafeError("path-mismatch", "directory mode owner is closed"));
+        const operation = pending.then(run);
+        pending = operation.catch(() => undefined);
+        return operation;
+    };
+    return {
+        verify: (check) => enqueue(async () => {
+            check?.();
+            await params.inspect();
+            check?.();
+        }),
+        apply: (mode, checks = {}) => enqueue(async () => {
+            // inspect() reports permission bits only; chmod ignores file-type bits,
+            // so tolerate raw stat modes (e.g. S_IFDIR | 0o755) by masking up front.
+            mode &= 0o7777;
+            checks.check?.();
+            const currentMode = await params.inspect();
+            checks.check?.();
+            if (currentMode === mode && !checks.beforeChmod && !checks.check)
+                return;
+            if (currentMode !== mode) {
+                await params.prepareChmod?.();
+                checks.check?.();
+            }
+            await checks.beforeChmod?.();
+            checks.check?.();
+            // Hooks/ancestor checks can yield; recheck the original named association.
+            await params.inspect();
+            checks.check?.();
+            let dispatchDeadlineFailure;
+            if (currentMode !== mode) {
+                checks.check?.();
+                try {
+                    await params.chmod(mode);
+                }
+                catch (error) {
+                    if (!params.ignoreChmodError)
+                        throw error;
+                }
+                // Expiry cannot release the fd while post-dispatch verification is pending.
+                try {
+                    checks.check?.();
+                }
+                catch (error) {
+                    dispatchDeadlineFailure = { error };
+                }
+                await params.verifyChmod?.();
+            }
+            const finalMode = await params.inspect();
+            if (dispatchDeadlineFailure)
+                throw dispatchDeadlineFailure.error;
+            checks.check?.();
+            if (!params.ignoreChmodError && finalMode !== mode) {
+                throw new FsSafeError("path-mismatch", "directory final mode could not be verified");
+            }
+        }),
+        close() {
+            closing ??= pending.then(params.close);
+            return closing;
+        },
+    };
+}
+/** Darwin descriptor inspection avoids requesting directory-content reads. */
+export function nodeDarwinDirectoryMetadataFlags() {
+    if (process.platform !== "darwin" || (process.arch !== "x64" && process.arch !== "arm64")) {
+        throw new FsSafeError("helper-unavailable", "Darwin directory metadata descriptors are unavailable");
+    }
+    // Darwin SDK O_EVTONLY; Node omits this flag from its exported constants.
+    return 0x8000 | constants.O_DIRECTORY | constants.O_NOFOLLOW | constants.O_NONBLOCK;
+}
 export function nodeDirectorySearchOnlyFlags() {
     if (process.arch !== "x64" && process.arch !== "arm64")
         return undefined;
@@ -87,7 +171,12 @@ export async function pinNodeDirectoryForMode(dirPath, options = {}) {
         return owner;
     }
     catch (error) {
-        await handle.close();
+        try {
+            await handle.close();
+        }
+        catch {
+            // Preserve the initial admission failure before ownership transfers.
+        }
         throw error;
     }
 }
@@ -185,7 +274,12 @@ export function pinNodeDirectoryForModeSync(dirPath, options = {}) {
         };
     }
     catch (error) {
-        fsSync.closeSync(fd);
+        try {
+            fsSync.closeSync(fd);
+        }
+        catch {
+            // Preserve the initial admission failure before ownership transfers.
+        }
         throw error;
     }
 }

package/node_modules/@openclaw/fs-safe/dist/directory-receipt.d.ts

@@ -0,0 +1,23 @@
+import { type BigIntStats, type Stats } from "node:fs";
+import type { DirectoryReceipt } from "./directory-durability.js";
+import type { FileIdentityStat } from "./file-identity.js";
+type ExactIdentity = Readonly<Pick<BigIntStats, "dev" | "ino">>;
+declare const numericFields: readonly ["dev", "mode", "nlink", "uid", "gid", "rdev", "blksize", "ino", "size", "blocks"];
+declare const timeFields: readonly ["atime", "mtime", "ctime", "birthtime"];
+type DirectoryMetadata = Pick<Stats, typeof numericFields[number] | `${typeof timeFields[number]}Ms`>;
+type DirectoryProvenance = Readonly<{
+    identity: ExactIdentity;
+    metadata: Readonly<DirectoryMetadata>;
+}>;
+type DirectoryAuthority = DirectoryProvenance & Readonly<{
+    path: string;
+    realPath: string;
+}>;
+export declare function directoryReceiptIdentity(identity: FileIdentityStat): ExactIdentity;
+export declare function directoryReceiptAuthority(receipt: DirectoryReceipt<Stats | BigIntStats>): DirectoryAuthority;
+export declare function ownDirectoryReceipt(receipt: DirectoryReceipt<Stats | BigIntStats>): DirectoryReceipt;
+export declare function copyRetainedDirectoryReceipt(receipt: DirectoryReceipt): DirectoryReceipt;
+export declare function createDirectoryReceiptFromIdentity(pathname: string, realPath: string, exactStat: BigIntStats): DirectoryReceipt;
+export declare function createDirectoryReceiptSync(directoryPath: string, label: string, canonicalize?: (pathname: string) => string): DirectoryReceipt;
+export declare function assertDirectoryReceiptCurrentSync(receipt: DirectoryReceipt, label: string, canonicalize?: (pathname: string) => string): void;
+export {};

package/node_modules/@openclaw/fs-safe/dist/directory-receipt.js

@@ -0,0 +1,121 @@
+import fs, {} from "node:fs";
+import { inspectDirectoryIdentitySync } from "./directory-guard.js";
+import { FsSafeError } from "./errors.js";
+import { realpathSync } from "./realpath.js";
+import { assertNoWindowsPathAlias, pathForWindowsFilesystem, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+const numericFields = ["dev", "mode", "nlink", "uid", "gid", "rdev", "blksize", "ino", "size", "blocks"];
+const timeFields = ["atime", "mtime", "ctime", "birthtime"];
+// Live pins retain private authority. New admissions snapshot the supplied
+// fields and accept exact provenance only while its public identity is intact.
+const authorities = new WeakMap();
+const identities = new WeakMap();
+export function directoryReceiptIdentity(identity) {
+    if (!identity) {
+        throw new FsSafeError("path-mismatch", "directory receipt identity is missing");
+    }
+    const known = identities.get(identity);
+    const dev = identity.dev;
+    const ino = identity.ino;
+    if (known) {
+        const matches = (value, expected) => typeof value === "bigint" ? value === expected : value === Number(expected);
+        if (!matches(dev, known.identity.dev) || !matches(ino, known.identity.ino)) {
+            throw new FsSafeError("path-mismatch", "directory receipt identity changed");
+        }
+        return known.identity;
+    }
+    const exact = (value) => {
+        if ((typeof value !== "bigint" && !Number.isSafeInteger(value)) ||
+            (process.platform === "win32" && (value === 0 || value === 0n))) {
+            throw new FsSafeError("path-mismatch", "directory receipt identity could not be verified");
+        }
+        return BigInt(value);
+    };
+    return Object.freeze({ dev: exact(dev), ino: exact(ino) });
+}
+function snapshotDirectoryReceipt(receipt) {
+    const pathname = receipt?.path;
+    const realPath = receipt?.realPath;
+    const stat = receipt?.identity;
+    if (typeof pathname !== "string" || typeof realPath !== "string" || stat == null) {
+        throw new FsSafeError("path-mismatch", "directory receipt is incomplete");
+    }
+    assertNoWindowsPathAlias(pathname, "filesystem");
+    assertNoWindowsPathAlias(realPath, "filesystem");
+    const identity = directoryReceiptIdentity(stat);
+    const known = authorities.get(receipt);
+    if (known && (pathname !== known.path || realPath !== known.realPath ||
+        identity.dev !== known.identity.dev || identity.ino !== known.identity.ino)) {
+        throw new FsSafeError("path-mismatch", "directory receipt changed before admission");
+    }
+    const metadata = known?.metadata ?? identities.get(stat)?.metadata ?? snapshotDirectoryMetadata(stat, identity);
+    return Object.freeze({ path: pathname, realPath, identity, metadata });
+}
+function snapshotDirectoryMetadata(stat, identity) {
+    const metadata = {};
+    for (const field of numericFields) {
+        metadata[field] = Number(field === "dev" || field === "ino" ? identity[field] : stat[field]);
+    }
+    for (const field of timeFields) {
+        if ("atimeNs" in stat) {
+            const nanoseconds = stat[`${field}Ns`];
+            const remainder = ((nanoseconds % 1000000000n) + 1000000000n) % 1000000000n;
+            metadata[`${field}Ms`] = Number((nanoseconds - remainder) / 1000000000n) * 1_000 + Number(remainder) / 1_000_000;
+        }
+        else {
+            metadata[`${field}Ms`] = stat[`${field}Ms`];
+        }
+    }
+    return Object.freeze(metadata);
+}
+export function directoryReceiptAuthority(receipt) {
+    return authorities.get(receipt) ?? snapshotDirectoryReceipt(receipt);
+}
+export function ownDirectoryReceipt(receipt) {
+    return receiptFromAuthority(snapshotDirectoryReceipt(receipt));
+}
+export function copyRetainedDirectoryReceipt(receipt) {
+    const authority = directoryReceiptAuthority(receipt);
+    return receiptFromAuthority(authority);
+}
+function receiptFromAuthority(authority) {
+    const receipt = {
+        path: authority.path,
+        realPath: authority.realPath,
+        identity: Object.assign(Object.create(fs.Stats.prototype), authority.metadata),
+    };
+    authorities.set(receipt, authority);
+    identities.set(receipt.identity, authority);
+    return receipt;
+}
+// The caller already admitted the exact observation and its paths.
+export function createDirectoryReceiptFromIdentity(pathname, realPath, exactStat) {
+    const identity = Object.freeze({ dev: exactStat.dev, ino: exactStat.ino });
+    return receiptFromAuthority(Object.freeze({
+        path: pathname,
+        realPath,
+        identity,
+        // Project metadata from the admitted observation, never a fresh pathname stat.
+        metadata: snapshotDirectoryMetadata(exactStat, identity),
+    }));
+}
+export function createDirectoryReceiptSync(directoryPath, label, canonicalize = realpathSync) {
+    assertNoWindowsPathAlias(directoryPath, "filesystem", `${label} path uses a Windows filesystem namespace alias`);
+    const pathname = resolvePathPreservingWindowsRoot(directoryPath);
+    assertNoWindowsPathAlias(pathname, "filesystem", `${label} path uses a Windows filesystem namespace alias`);
+    const exact = inspectDirectoryIdentitySync(pathname);
+    const operationPath = pathForWindowsFilesystem(pathname);
+    const realPath = canonicalize(operationPath);
+    assertNoWindowsPathAlias(realPath, "filesystem", `${label} real path uses a Windows filesystem namespace alias`);
+    return createDirectoryReceiptFromIdentity(pathname, realPath, exact);
+}
+export function assertDirectoryReceiptCurrentSync(receipt, label, canonicalize = realpathSync) {
+    const authority = directoryReceiptAuthority(receipt);
+    assertNoWindowsPathAlias(authority.path, "filesystem", `${label} path uses a Windows filesystem namespace alias`);
+    assertNoWindowsPathAlias(authority.realPath, "filesystem", `${label} real path uses a Windows filesystem namespace alias`);
+    inspectDirectoryIdentitySync(authority.path, authority.identity);
+    const realPath = canonicalize(pathForWindowsFilesystem(authority.path));
+    assertNoWindowsPathAlias(realPath, "filesystem", `${label} real path uses a Windows filesystem namespace alias`);
+    if (realPath !== authority.realPath) {
+        throw new FsSafeError("path-mismatch", `${label} changed during durable directory operation: ${authority.path}`);
+    }
+}

package/node_modules/@openclaw/fs-safe/dist/durability.d.ts

@@ -1,4 +1,4 @@
 export { ensureDurableDirectory, pinDirectory, syncDirectory, syncDirectoryBestEffort, syncDirectoryBestEffortSync, syncDirectorySync, type DirectoryReceipt, type DirectorySyncOutcome, type DurableDirectoryReceipt, type EnsureDurableDirectoryOptions, type PinnedDirectory, } from "./directory-durability.js";
-export { isHardlinkFallbackError, publishFileExclusive, type PublishFileExclusiveResult, type PublishFileExclusiveStrategy, type PublishFileExclusiveCleanup, type PublishFileExclusiveDirectorySyncFailure, type PublishFileExclusiveFailureDetails, type PublishFileExclusiveFailurePhase, type PublishFileExclusiveSyncFailurePolicy, } from "./publish-file.js";
+export { isHardlinkFallbackError, publishFileExclusive, type PublishFileExclusiveResult, type PublishFileExclusiveStrategy, } from "./publish-file.js";
+export type { PublishFileExclusiveCleanup, PublishFileExclusiveDirectorySyncFailure, PublishFileExclusiveFailureDetails, PublishFileExclusiveFailurePhase, PublishFileExclusiveSyncFailurePolicy, } from "./publish-file-failure.js";
 export { sha256File, sha256FileSync, type Sha256FileInput, type Sha256FileSyncInput, type Sha256FileOptions, type Sha256FileResult, } from "./file-hash.js";
-//# sourceMappingURL=durability.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/effective-uid.d.ts

@@ -1,2 +1 @@
 export declare function resolveEffectiveUid(): number;
-//# sourceMappingURL=effective-uid.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/effective-uid.js

@@ -1,6 +1,3 @@
-function isValidUid(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
 function unavailable(cause) {
     return new Error("Effective user identity is unavailable.", {
         ...(cause === undefined ? {} : { cause }),
@@ -18,7 +15,7 @@ export function resolveEffectiveUid() {
     catch (cause) {
         throw unavailable(cause);
     }
-    if (!isValidUid(uid)) {
+    if (!(typeof uid === "number" && Number.isSafeInteger(uid) && uid >= 0)) {
         throw unavailable();
     }
     return uid;

package/node_modules/@openclaw/fs-safe/dist/error-detail.d.ts

@@ -1,3 +1,2 @@
 export declare function formatErrorDetail(value: string): string;
 export declare function shortPath(value: string): string;
-//# sourceMappingURL=error-detail.d.ts.map