@openclaw/matrix 2026.10.5-beta.3 → 2026.10.10-beta.1

package/node_modules/@openclaw/fs-safe/dist/copy-path-admission.js

@@ -5,6 +5,7 @@ import { FsSafeError } from "./errors.js";
 import { sameFileIdentity } from "./file-identity.js";
 import { realpathSync } from "./realpath.js";
 import { resolveRootPathSync, ROOT_PATH_ALIAS_POLICIES } from "./root-path.js";
+import { hasWindowsPathAlias } from "./windows-path-alias.js";
 function admitUncachedCopyPath(input, create = false, admittedRoot) {
     if (!path.isAbsolute(input.rootPath) || !path.isAbsolute(input.absolutePath)) {
         throw new FsSafeError("invalid-path", "copy roots and paths must be absolute");
@@ -50,15 +51,23 @@ export function createCopyPathAdmissionCache() {
     const assertParent = ({ root, parent, chain }) => {
         assertSyncDirectoryGuard(root);
         for (const guard of chain) {
+            // The full parent guard immediately below includes this exact identity.
+            if (guard === parent)
+                continue;
             inspectDirectoryIdentitySync(guard.dir, { dev: BigInt(guard.stat.dev), ino: BigInt(guard.stat.ino) });
         }
-        assertSyncDirectoryGuard(parent);
+        if (parent !== root)
+            assertSyncDirectoryGuard(parent);
         assertSyncDirectoryGuard(root);
     };
     const admit = (input, create = false) => {
         // Keep the public resolver for Windows aliases and noncanonical spellings,
         // including raw dot segments whose traversal must not be normalized away.
-        if (process.platform === "win32" || !path.isAbsolute(input.rootPath) ||
+        const ordinaryWindowsPath = process.platform !== "win32" || (/^[a-z]:\\/iu.test(input.rootPath) &&
+            !hasWindowsPathAlias(input.rootPath, "filesystem") &&
+            !hasWindowsPathAlias(input.absolutePath, "filesystem") &&
+            !input.absolutePath.slice(3).split("\\").some(segment => /[. ]$/u.test(segment) || segment.includes("~")));
+        if (!ordinaryWindowsPath || !path.isAbsolute(input.rootPath) ||
             !path.isAbsolute(input.absolutePath) || input.rootPath.includes("\0") || input.absolutePath.includes("\0") ||
             path.resolve(input.rootPath) !== input.rootPath || path.resolve(input.absolutePath) !== input.absolutePath ||
             !input.absolutePath.startsWith(input.rootPath.endsWith(path.sep) ? input.rootPath : `${input.rootPath}${path.sep}`)) {

package/node_modules/@openclaw/fs-safe/dist/copy-root-file-sync.d.ts

@@ -1,13 +1,11 @@
+import { type ExactIdentityReceipt, type ExactFileIdentity } from "./file-identity.js";
 import { type CopyPath } from "./copy-path-admission.js";
 import { type CopyCloneMode } from "./copy-policy.js";
 import { type OwnedFileDescriptorSync } from "./create-owned-file.js";
 export type CopyRootFileSyncOptions = {
     source: CopyPath;
     destination: CopyPath;
-    expectedSourceIdentity?: {
-        dev: bigint;
-        ino: bigint;
-    };
+    expectedSourceIdentity?: ExactFileIdentity | ExactIdentityReceipt;
     clone?: CopyCloneMode;
     maxBytes?: number;
     mode?: number;

package/node_modules/@openclaw/fs-safe/dist/copy-root-file-sync.js

@@ -1,3 +1,4 @@
+import { identityFromReceipt } from "./file-identity.js";
 import fs, {} from "node:fs";
 import path from "node:path";
 import { normalizeMaxBytes } from "./byte-budget.js";
@@ -50,7 +51,8 @@ function copyRootFileWithAdmissionSync(options, cache) {
     const targetInput = options.destination;
     const targetPath = { rootPath: targetInput.rootPath, absolutePath: targetInput.absolutePath };
     const expectedInput = options.expectedSourceIdentity;
-    const expectedSourceIdentity = expectedInput === undefined ? undefined : { dev: expectedInput.dev, ino: expectedInput.ino };
+    const expected = expectedInput === undefined ? undefined : identityFromReceipt(expectedInput);
+    const expectedSourceIdentity = expected && { dev: expected.dev, ino: expected.ino };
     const clone = resolveCopyCloneMode(options.clone, "never");
     const maxBytes = normalizeMaxBytes(options.maxBytes);
     const mode = options.mode;
@@ -68,7 +70,7 @@ function copyRootFileWithAdmissionSync(options, cache) {
     let parentOpen = false;
     let target;
     let identity;
-    const native = getNativeBinding();
+    const native = process.platform !== "win32" ? getNativeBinding("copyFileExclusiveSync", "removeStagedFile") : getNativeBinding();
     const nativeCopy = process.platform !== "win32" && native?.copyFileExclusiveSync && native.removeStagedFile
         ? native.copyFileExclusiveSync.bind(native) : undefined;
     try {

package/node_modules/@openclaw/fs-safe/dist/copy-tree-portable.js

@@ -4,12 +4,9 @@ import fsp, {} from "node:fs/promises";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
 import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
+import { timestampSeconds } from "./copy-metadata.js";
+import { readCopyLinkTarget } from "./copy-link.js";
 import { assertStagedDirectoryCurrent, exactIdentityMatches, openStagedDirectory, } from "./staged-directory.js";
-function timestampSeconds(nanoseconds) {
-    // Dates discard sub-millisecond precision; negative numbers mean "now" in
-    // Node's utimes API. Numeric strings retain fractional, pre-epoch timestamps.
-    return String(Number(nanoseconds / 1000000000n) + Number(nanoseconds % 1000000000n) / 1e9);
-}
 /** Byte-copy adapter for the shared immutable-source, caller-owned namespace contract. */
 export async function copyOwnedTree(source, destination, options) {
     const callerSignal = options.signal ? AbortSignal.any([options.signal]) : undefined;
@@ -145,7 +142,7 @@ export async function copyOwnedTree(source, destination, options) {
                 else if (child.isSymbolicLink()) {
                     const link = process.platform === "win32"
                         ? await fsp.readlink(childSource)
-                        : await fsp.readlink(childSource, { encoding: "buffer" });
+                        : await readCopyLinkTarget(childSource);
                     let type;
                     if (process.platform === "win32") {
                         // Older Node releases infer link type from the destination, where a

package/node_modules/@openclaw/fs-safe/dist/copy.js

@@ -21,7 +21,7 @@ function closeDescriptor(fd, failure) {
 }
 /** Inspect an existing real directory without creating probe files. */
 export function probeTreeClone(parentPath) {
-    const native = getNativeBinding();
+    const native = getNativeBinding("probeTreeClone");
     if (!native)
         return undefined;
     const parent = openStagedDirectory(assertAbsolutePathInput(parentPath));
@@ -64,9 +64,9 @@ async function materializeTree(source, destination, options, policy) {
         throw new FsSafeError("invalid-path", "clone concurrency must be an integer between 1 and 32");
     }
     const native = policy === "always"
-        ? requireNativeBinding()
+        ? requireNativeBinding("probeTreeClone", "cloneTree")
         : policy === "auto"
-            ? getNativeBinding()
+            ? getNativeBinding("probeTreeClone", "cloneTree")
             : undefined;
     const target = assertAbsolutePathInput(destination);
     const name = path.basename(target);

package/node_modules/@openclaw/fs-safe/dist/create.js

@@ -204,7 +204,7 @@ function privateDirectoryBackend() {
     if (getFsSafeNativeConfig().mode === "require") {
         throw new FsSafeError("helper-unavailable", "private directory creation requires an up-to-date native parent identity capability");
     }
-    warnNativeFallback("windows-private-directory", "Private Windows directory creation uses a slower built-in system command.");
+    warnNativeFallback("windows-private-directory", "Private Windows directory creation launches the packaged .NET helper for each check or creation.", "createPrivateDirectoryWithParentIdentity");
     return undefined;
 }
 export async function createDirectory(targetPath, options = {}) {

package/node_modules/@openclaw/fs-safe/dist/creation-boundary.js

@@ -53,17 +53,17 @@ export function assertPrivateFileCreationAvailable() {
         typeof native.verifyPrivateWindowsFile !== "function")
         unavailable();
 }
-function commandFallback() {
+function commandFallback(capability) {
     if (getFsSafeNativeConfig().mode === "require")
         unavailable();
-    warnNativeFallback("windows-private-creation", "Private Windows creation uses a slower built-in system command.");
+    warnNativeFallback("windows-private-creation", "Private Windows creation launches the packaged .NET helper for each check or creation.", capability);
 }
 function creationOperation(name) {
     const native = getNativeBinding();
     const operation = native?.[name];
     if (typeof operation === "function")
         return operation.bind(native);
-    commandFallback();
+    commandFallback(name);
     return undefined;
 }
 /** Full Windows identity, with security validation when requested; no repairs. */
@@ -300,7 +300,10 @@ export function assertBeforeCreation(selected, permissions, assertion, kind) {
     if (permissions.private)
         assertDarwinCreationDirectoryAcl(selected.parent.dir, selected.parent.stat, kind);
     assertSynchronousCallbackResult(assertion?.(), "assertBeforeMutation");
-    selected.assertParent();
+    // Ordinary callers enter immediately after prepareCreationPath's identical fence.
+    // A callback or private ACL inspection needs a fresh observation afterward.
+    if (assertion !== undefined || permissions.private)
+        selected.assertParent();
     if (permissions.private && kind === "directory")
         assertDarwinPrivateDirectoryMode(permissions.mode);
     if (permissions.private)

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

@@ -0,0 +1,12 @@
+export type DarwinAclInspection = {
+    kind: "none";
+} | {
+    kind: "present";
+    inheritsToFiles: boolean;
+    inheritsToDirectories: boolean;
+} | {
+    kind: "unknown";
+    reason: string;
+};
+/** Inspect one no-follow descriptor. Unknown is never evidence of no ACL. */
+export declare function inspectDarwinAcl(path: string): DarwinAclInspection;

package/node_modules/@openclaw/fs-safe/dist/darwin-acl.js

@@ -0,0 +1,29 @@
+import fs from "node:fs";
+import { getNativeBinding } from "./native.js";
+/** Inspect one no-follow descriptor. Unknown is never evidence of no ACL. */
+export function inspectDarwinAcl(path) {
+    if (process.platform !== "darwin")
+        return { kind: "unknown", reason: "unsupported-platform" };
+    let fd;
+    try {
+        const native = getNativeBinding();
+        if (!native?.inspectDarwinAcl)
+            return { kind: "unknown", reason: "helper-unavailable" };
+        fd = fs.openSync(path, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+        const facts = native.inspectDarwinAcl(fd);
+        if (facts.state === "absent" || facts.state === "empty")
+            return { kind: "none" };
+        if (facts.state === "present" && typeof facts.inheritsToFiles === "boolean" &&
+            typeof facts.inheritsToDirectories === "boolean") {
+            return { kind: "present", inheritsToFiles: facts.inheritsToFiles, inheritsToDirectories: facts.inheritsToDirectories };
+        }
+        return { kind: "unknown", reason: "incomplete-acl-facts" };
+    }
+    catch (error) {
+        return { kind: "unknown", reason: error instanceof Error ? error.message : String(error) };
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}

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

@@ -1,5 +1,6 @@
+import type { ExactFileIdentity, ExactIdentityReceipt } from "./exact-identity.js";
 import { type BigIntStats, type Stats } from "node:fs";
-import type { FileIdentityStat } from "./file-identity.js";
+import type { FileIdentityInput } from "./file-identity.js";
 export type DirectorySyncOutcome = {
     status: "synced";
 } | {
@@ -10,14 +11,16 @@ export type DirectoryReceipt<T extends Stats | BigIntStats = Stats> = {
     path: string;
     realPath: string;
     identity: T;
+    exactIdentity?: ExactFileIdentity;
 };
+export type ExactDirectoryReceipt = DirectoryReceipt & ExactIdentityReceipt;
 export type DurableDirectoryReceipt = DirectoryReceipt & {
     parentSync: DirectorySyncOutcome | {
         status: "not-needed";
     };
 };
 export type PinnedDirectory = {
-    readonly receipt: DirectoryReceipt;
+    readonly receipt: ExactDirectoryReceipt;
     assertCurrent(): Promise<void>;
     sync(): Promise<DirectorySyncOutcome>;
     close(): Promise<void>;
@@ -26,7 +29,7 @@ export type EnsureDurableDirectoryOptions = {
     directoryPath: string;
     label?: string;
     mode?: number;
-    expectedExistingIdentity?: FileIdentityStat;
+    expectedExistingIdentity?: FileIdentityInput;
     create?: (directoryPath: string) => Promise<void>;
 };
 export declare function pinDirectory(directory: string | DirectoryReceipt<Stats | BigIntStats>, options?: {
@@ -40,4 +43,4 @@ export declare function syncDirectorySync(directory: string | DirectoryReceipt<S
 }): DirectorySyncOutcome;
 export declare function syncDirectoryBestEffort(directoryPath: string): Promise<void>;
 export declare function syncDirectoryBestEffortSync(directoryPath: string): void;
-export declare function ensureDurableDirectory(options: EnsureDurableDirectoryOptions): Promise<DurableDirectoryReceipt>;
+export declare function ensureDurableDirectory(options: EnsureDurableDirectoryOptions): Promise<DurableDirectoryReceipt & ExactIdentityReceipt>;

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

@@ -1,7 +1,7 @@
 import fsSync from "node:fs";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
-import { sameFileIdentity } from "./file-identity.js";
+import { hasSafeFileIdentity, sameFileIdentity } from "./file-identity.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { isNotFoundPathError } from "./path.js";
 import { directoryComponentNotDirectoryError } from "./root-errors.js";
@@ -9,6 +9,9 @@ import { assertNoWindowsPathAlias, pathForWindowsFilesystem, resolvePathPreservi
 import { realpathSync } from "./realpath.js";
 import { directoryEntryPath } from "./directory-entry-path.js";
 import { assertStatObservationSync, inspectStatObservationSync, } from "./stat-observation.js";
+// Numeric metadata is retained for existing internal consumers; rounded IDs
+// must never become authority for a later comparison.
+const exactGuardIdentities = new WeakMap();
 export async function readDirectoryIdentity(dir) {
     const guard = await createAsyncDirectoryGuard(dir, { bigint: true });
     return Object.freeze({ dev: guard.stat.dev, ino: guard.stat.ino, realPath: guard.realPath });
@@ -43,9 +46,19 @@ export function captureDirectoryGuard(dir, mode, options) {
     if (stat.isSymbolicLink() || !stat.isDirectory()) {
         throw directoryComponentNotDirectoryError();
     }
+    let exactIdentity;
+    if (!hasSafeFileIdentity(stat)) {
+        const exact = fsSync.lstatSync(operationPath, { bigint: true });
+        if (exact.isSymbolicLink() || !exact.isDirectory())
+            throw directoryComponentNotDirectoryError();
+        exactIdentity = { dev: exact.dev, ino: exact.ino };
+    }
     const realPath = mode === "native" ? realpathSync.native(operationPath) : realpathSync(operationPath);
     assertNoWindowsPathAlias(realPath, "filesystem");
-    return { dir, realPath, stat };
+    const guard = { dir, realPath, stat };
+    if (exactIdentity)
+        exactGuardIdentities.set(guard, exactIdentity);
+    return guard;
 }
 export async function assertAsyncDirectoryGuard(guard) {
     assertDirectoryGuard(guard, "native");
@@ -59,9 +72,11 @@ export function assertDirectoryGuard(guard, mode) {
     const expectedRealPath = guard.realPath;
     assertNoWindowsPathAlias(expectedRealPath, "filesystem");
     const expectedStat = guard.stat;
-    const expectedIdentity = { dev: expectedStat.dev, ino: expectedStat.ino };
+    const suppliedIdentity = { dev: expectedStat.dev, ino: expectedStat.ino };
+    const retainedIdentity = exactGuardIdentities.get(guard);
+    const expectedIdentity = retainedIdentity ?? suppliedIdentity;
     const stat = typeof expectedIdentity.dev === "bigint" && typeof expectedIdentity.ino === "bigint"
-        ? inspectDirectoryIdentityAtPathSync(operationPath, {
+        ? retainedIdentity ? fsSync.lstatSync(operationPath, { bigint: true }) : inspectDirectoryIdentityAtPathSync(operationPath, {
             dev: expectedIdentity.dev,
             ino: expectedIdentity.ino,
         })
@@ -74,7 +89,7 @@ export function assertDirectoryGuard(guard, mode) {
     if (mode === "native" && !sameFileIdentity(stat, expectedIdentity)) {
         throw new FsSafeError("path-mismatch", "directory changed during operation");
     }
-    const realPath = mode === "native" || typeof expectedIdentity.ino === "bigint"
+    const realPath = mode === "native" || typeof suppliedIdentity.ino === "bigint"
         ? realpathSync.native(operationPath) : realpathSync(operationPath);
     assertNoWindowsPathAlias(realPath, "filesystem");
     if ((mode === "normalized" && !sameFileIdentity(stat, expectedIdentity)) || realPath !== expectedRealPath) {

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

@@ -5,6 +5,7 @@ export type DirectoryModeChecks = {
 };
 export type DirectoryModeOwner = {
     verify(check?: () => void): Promise<void>;
+    verifyCanonical?(): Promise<boolean>;
     apply(mode: number, checks?: DirectoryModeChecks): Promise<void>;
     close(): Promise<void>;
 };
@@ -12,6 +13,7 @@ export declare function assertOwnedDirectory(expected: Stats | BigIntStats, actu
 /** Serializes use and close: even a queued path-based fd operation retains its descriptor. */
 export declare function ownDirectoryMode(params: {
     inspect: () => Promise<number>;
+    inspectCanonical?: () => number | undefined;
     chmod: (mode: number) => Promise<void>;
     prepareChmod?: () => Promise<void>;
     verifyChmod?: () => Promise<void>;
@@ -28,6 +30,7 @@ export declare function nodeDirectorySearchOnlyFlags(): {
 export declare function pinNodeDirectoryForMode(dirPath: string, options?: {
     expectedIdentity?: BigIntStats;
     ownerUid?: number;
+    canonicalPath?: string;
 }): Promise<DirectoryModeOwner>;
 /** Synchronous counterpart with the same no-follow, identity, and owner checks. */
 export declare function pinNodeDirectoryForModeSync(dirPath: string, options?: {

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

@@ -4,6 +4,8 @@ import { FsSafeError } from "./errors.js";
 import { inspectDirectoryIdentity, inspectDirectoryIdentitySync } from "./directory-guard.js";
 import { inspectFileIdentity, inspectFileIdentitySync } from "./strict-file-identity.js";
 import { sameFileIdentityForCleanup } from "./file-identity.js";
+import { getNativeBinding } from "./native.js";
+import { nativePolicyDirectoryObserver } from "./native-policy-directory-observation.js";
 export function assertOwnedDirectory(expected, actual) {
     if (actual.isSymbolicLink() || !actual.isDirectory()) {
         throw new FsSafeError("not-file", "directory mode target must be a real directory");
@@ -23,7 +25,7 @@ export function ownDirectoryMode(params) {
         pending = operation.catch(() => undefined);
         return operation;
     };
-    return {
+    const owner = {
         verify: (check) => enqueue(async () => {
             check?.();
             await params.inspect();
@@ -79,6 +81,14 @@ export function ownDirectoryMode(params) {
             return closing;
         },
     };
+    if (params.inspectCanonical) {
+        owner.verifyCanonical = async () => {
+            let verified = false;
+            await enqueue(async () => { verified = params.inspectCanonical() !== undefined; });
+            return verified;
+        };
+    }
+    return owner;
 }
 /** Darwin descriptor inspection avoids requesting directory-content reads. */
 export function nodeDarwinDirectoryMetadataFlags() {
@@ -131,7 +141,11 @@ export async function pinNodeDirectoryForMode(dirPath, options = {}) {
         proc = route.proc;
         return await fs.open(dirPath, route.flags | flags);
     });
+    let observer;
     try {
+        observer = options.canonicalPath === dirPath && ownerUid === undefined
+            ? nativePolicyDirectoryObserver(getNativeBinding(), handle.fd, dirPath)
+            : undefined;
         const inspect = async () => {
             const opened = await inspectFileIdentity(() => fsSync.fstatSync(handle.fd, { bigint: true }), expected);
             assertOwnedDirectory(expected, opened);
@@ -153,8 +167,18 @@ export async function pinNodeDirectoryForMode(dirPath, options = {}) {
             assertOwner(opened);
             assertOwner(followed);
         };
+        const observeCanonical = observer;
         const owner = ownDirectoryMode({
             inspect,
+            inspectCanonical: observeCanonical ? () => {
+                const observed = observeCanonical();
+                if (!observed)
+                    return undefined;
+                if (observed.identity.dev !== expected.dev || observed.identity.ino !== expected.ino) {
+                    throw new FsSafeError("path-mismatch", "directory changed before its mode could be applied");
+                }
+                return Number(observed.identity.mode & 4095n);
+            } : undefined,
             prepareChmod: proc ? assertProcAuthority : undefined,
             verifyChmod: proc ? assertProcAuthority : undefined,
             async chmod(mode) {
@@ -165,12 +189,13 @@ export async function pinNodeDirectoryForMode(dirPath, options = {}) {
                     await handle.chmod(mode);
                 }
             },
-            close: () => handle.close(),
+            close: () => { observer?.dispose(); return handle.close(); },
         });
         await owner.verify();
         return owner;
     }
     catch (error) {
+        observer?.dispose();
         try {
             await handle.close();
         }

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

@@ -1,6 +1,6 @@
 import { type BigIntStats, type Stats } from "node:fs";
-import type { DirectoryReceipt } from "./directory-durability.js";
-import type { FileIdentityStat } from "./file-identity.js";
+import type { DirectoryReceipt, ExactDirectoryReceipt } from "./directory-durability.js";
+import { type FileIdentityInput } 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"];
@@ -13,11 +13,11 @@ type DirectoryAuthority = DirectoryProvenance & Readonly<{
     path: string;
     realPath: string;
 }>;
-export declare function directoryReceiptIdentity(identity: FileIdentityStat): ExactIdentity;
+export declare function directoryReceiptIdentity(input: FileIdentityInput): 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 ownDirectoryReceipt(receipt: DirectoryReceipt<Stats | BigIntStats>): ExactDirectoryReceipt;
+export declare function copyRetainedDirectoryReceipt(receipt: DirectoryReceipt): ExactDirectoryReceipt;
+export declare function createDirectoryReceiptFromIdentity(pathname: string, realPath: string, exactStat: BigIntStats): ExactDirectoryReceipt;
+export declare function createDirectoryReceiptSync(directoryPath: string, label: string, canonicalize?: (pathname: string) => string): ExactDirectoryReceipt;
 export declare function assertDirectoryReceiptCurrentSync(receipt: DirectoryReceipt, label: string, canonicalize?: (pathname: string) => string): void;
 export {};

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

@@ -1,6 +1,7 @@
 import fs, {} from "node:fs";
 import { inspectDirectoryIdentitySync } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
+import { identityFromReceipt } from "./file-identity.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"];
@@ -9,10 +10,11 @@ const timeFields = ["atime", "mtime", "ctime", "birthtime"];
 // 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) {
+export function directoryReceiptIdentity(input) {
+    if (!input) {
         throw new FsSafeError("path-mismatch", "directory receipt identity is missing");
     }
+    const identity = identityFromReceipt(input);
     const known = identities.get(identity);
     const dev = identity.dev;
     const ino = identity.ino;
@@ -41,9 +43,11 @@ function snapshotDirectoryReceipt(receipt) {
     }
     assertNoWindowsPathAlias(pathname, "filesystem");
     assertNoWindowsPathAlias(realPath, "filesystem");
-    const identity = directoryReceiptIdentity(stat);
+    const identity = directoryReceiptIdentity(receipt.exactIdentity ?? stat);
     const known = authorities.get(receipt);
-    if (known && (pathname !== known.path || realPath !== known.realPath ||
+    const matches = (value, expected) => typeof value === "bigint" ? value === expected : value === Number(expected);
+    if (known && (!matches(stat.dev, known.identity.dev) || !matches(stat.ino, known.identity.ino) ||
+        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");
     }
@@ -79,6 +83,7 @@ export function copyRetainedDirectoryReceipt(receipt) {
 }
 function receiptFromAuthority(authority) {
     const receipt = {
+        exactIdentity: authority.identity,
         path: authority.path,
         realPath: authority.realPath,
         identity: Object.assign(Object.create(fs.Stats.prototype), authority.metadata),

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

@@ -1,4 +1,5 @@
-export { ensureDurableDirectory, pinDirectory, syncDirectory, syncDirectoryBestEffort, syncDirectoryBestEffortSync, syncDirectorySync, type DirectoryReceipt, type DirectorySyncOutcome, type DurableDirectoryReceipt, type EnsureDurableDirectoryOptions, type PinnedDirectory, } from "./directory-durability.js";
+export { ensureDurableDirectory, pinDirectory, syncDirectory, syncDirectoryBestEffort, syncDirectoryBestEffortSync, syncDirectorySync, type DirectoryReceipt, type ExactDirectoryReceipt, type DirectorySyncOutcome, type DurableDirectoryReceipt, type EnsureDurableDirectoryOptions, type PinnedDirectory, } from "./directory-durability.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";
+export type { ExactFileIdentity, ExactIdentityReceipt } from "./exact-identity.js";

package/node_modules/@openclaw/fs-safe/dist/entry-publication.js

@@ -18,7 +18,7 @@ function basename(name) {
 }
 function identity(value) {
     const { dev, ino } = value;
-    if (typeof dev !== "bigint" || typeof ino !== "bigint" || dev < 0n || ino <= 0n ||
+    if (typeof dev !== "bigint" || typeof ino !== "bigint" || dev < -(1n << 63n) || ino < -(1n << 63n) || ino === 0n ||
         dev > 0xffffffffffffffffn || ino > 0xffffffffffffffffn) {
         throw new FsSafeError("path-mismatch", "publication requires an exact known identity");
     }
@@ -230,7 +230,7 @@ export function retainEntryForPublication(options) {
         inspectEntry(sourcePath, source.expected);
         const sourceFd = kind === "symlink"
             ? binding.openStagedSymlink(sourceParent.fd, source.basename)
-            : binding.openBeneath(sourceParent.fd, source.basename, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK |
+            : native.openBeneath(sourceParent.fd, source.basename, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK |
                 (kind === "directory" ? fs.constants.O_DIRECTORY : 0))?.fd;
         if (!Number.isInteger(sourceFd) || sourceFd < 0) {
             throw new FsSafeError("helper-unavailable", "publication source descriptor is unavailable");

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

@@ -0,0 +1,17 @@
+import { type BigIntStats, type Stats } from "node:fs";
+export type ExactFileIdentity = Readonly<{
+    dev: bigint;
+    ino: bigint;
+}>;
+export type ExactIdentityReceipt = {
+    readonly exactIdentity: ExactFileIdentity;
+};
+/** Copy scalars from one observation; never try to recover rounded identity bits. */
+export declare function exactFileIdentity(stat: {
+    dev: number | bigint;
+    ino: number | bigint;
+}): ExactFileIdentity;
+/** Node stores unsigned libuv fields in a signed BigInt64Array. */
+export declare function numberStatScalar(value: number | bigint): number;
+/** Legacy metadata view of the very same bigint observation. */
+export declare function numberStats(stat: BigIntStats): Stats;

package/node_modules/@openclaw/fs-safe/dist/exact-identity.js

@@ -0,0 +1,29 @@
+import fs, {} from "node:fs";
+import { FsSafeError } from "./errors.js";
+/** Copy scalars from one observation; never try to recover rounded identity bits. */
+export function exactFileIdentity(stat) {
+    const { dev, ino } = stat;
+    if ((typeof dev !== "bigint" && !Number.isSafeInteger(dev)) ||
+        (typeof ino !== "bigint" && !Number.isSafeInteger(ino))) {
+        throw new FsSafeError("path-mismatch", "file identity is not exact");
+    }
+    return Object.freeze({ dev: BigInt(dev), ino: BigInt(ino) });
+}
+/** Node stores unsigned libuv fields in a signed BigInt64Array. */
+export function numberStatScalar(value) {
+    return typeof value === "bigint" ? Number(BigInt.asUintN(64, value)) : Number(value);
+}
+/** Legacy metadata view of the very same bigint observation. */
+export function numberStats(stat) {
+    const result = Object.create(fs.Stats.prototype);
+    for (const field of ["dev", "mode", "nlink", "uid", "gid", "rdev", "blksize", "ino", "size", "blocks"]) {
+        result[field] = numberStatScalar(stat[field]);
+    }
+    for (const field of ["atime", "mtime", "ctime", "birthtime"]) {
+        const ns = stat[`${field}Ns`];
+        const remainder = ((ns % 1000000000n) + 1000000000n) % 1000000000n;
+        result[`${field}Ms`] = Number((ns - remainder) / 1000000000n) * 1_000 + Number(remainder) / 1_000_000;
+        // Stats.prototype supplies Node's lazy, correctly rounded Date getters.
+    }
+    return result;
+}

package/node_modules/@openclaw/fs-safe/dist/file-handle-transfer.js

@@ -113,7 +113,8 @@ export async function copyFileHandle(source, target, options = {}) {
     const assertBeforeMutation = composeMutationAssertions(undefined, options.assertBeforeMutation);
     const sourceStat = await inspectFileIdentity(() => {
         signal?.throwIfAborted();
-        return source.stat({ bigint: true });
+        const fd = source.fd;
+        return fd < 0 ? source.stat({ bigint: true }) : fs.fstatSync(fd, { bigint: true });
     });
     signal?.throwIfAborted();
     if (!sourceStat.isFile())
@@ -123,7 +124,8 @@ export async function copyFileHandle(source, target, options = {}) {
     }
     const targetStat = await inspectFileIdentity(() => {
         signal?.throwIfAborted();
-        return target.stat({ bigint: true });
+        const fd = target.fd;
+        return fd < 0 ? target.stat({ bigint: true }) : fs.fstatSync(fd, { bigint: true });
     });
     signal?.throwIfAborted();
     if (!targetStat.isFile())

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

@@ -10,7 +10,7 @@ export type Sha256FileResult = {
     bytes: number;
     digest: string;
 };
-export declare function hashFileHandle(handle: FileHandle, native?: NativeBinding | undefined, { maxBytes, signal }?: Sha256FileOptions): Promise<Sha256FileResult>;
+export declare function hashFileHandle(handle: FileHandle, native?: NativeBinding | undefined, { maxBytes, signal }?: Sha256FileOptions, ownsPosition?: boolean): Promise<Sha256FileResult>;
 export declare function sha256File(input: Sha256FileInput, options?: Sha256FileOptions): Promise<Sha256FileResult>;
 /** Hash synchronously from offset zero, retaining ownership and position of a borrowed fd. */
 export declare function sha256FileSync(input: Sha256FileSyncInput, options?: Sha256FileOptions): Sha256FileResult;