@openclaw/feishu 2026.9.8 → 2026.10.1-beta.2

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

@@ -3,81 +3,52 @@ import syncFs, {} from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
-import { assertDestinationHardlinkPolicy, assertDestinationHardlinkPolicySync, copyFallbackReplace, copyFallbackReplaceSync, } from "./replace-file-copy-fallback.js";
-import { applyDirectoryMode, applyDirectoryModeSync, syncDirectoryBestEffort, syncDirectoryBestEffortSync, writeTempFile, writeTempFileSync, } from "./replace-file-descriptor.js";
+import { assertDestinationHardlinkPolicy, copyFallbackReplace } from "./replace-file-copy-fallback.js";
+import { applyDirectoryMode, syncDirectoryBestEffort, writeTempFile } from "./replace-file-descriptor.js";
 import { inheritedRegularFileMode } from "./replace-file-mode.js";
 import { atomicExpectedContentHash, validateRenameIdentity, withAtomicRenameIdentityLock, withAtomicRenameIdentityLockSync, } from "./replace-file-rename-policy.js";
-import { AsyncAtomicTempOwner, SyncAtomicTempOwner } from "./replace-file-temp-owner.js";
+import { AtomicTempOwner } from "./replace-file-temp-owner.js";
 import { assertSafePathPrefix } from "./safe-path-segment.js";
 import { admitStandalonePublicationPath } from "./windows-path-alias.js";
-import { sleep, sleepSync } from "./timing.js";
 import { serializePathWrite } from "./write-queue.js";
 import { hasErrorCode, readErrorCode } from "./file-cleanup.js";
 import { AtomicMutation } from "./replace-file-mutation.js";
 import { assertSynchronousCallbackResult } from "./mutation-authority.js";
-async function renameWithRetry(params) {
-    for (let attempt = 0; attempt <= params.maxRetries; attempt++) {
+import { AtomicIo, runAsync, runSync, wait } from "./atomic-io.js";
+function* renameWithRetry(io, source, destination, options, mutation) {
+    const maxRetries = options.renameMaxRetries ?? 0;
+    const baseDelayMs = options.renameRetryBaseDelayMs ?? 50;
+    const copyFallbackOnPermissionError = options.copyFallbackOnPermissionError === true;
+    const restore = options.copyFallbackRestore ?? "none";
+    const maxRestoreBytes = options.maxRestoreBytes;
+    const destinationHardlinks = options.destinationHardlinks;
+    const sourceIdentity = source.identity;
+    const sync = options.syncTempFile === true;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
         if (attempt > 0)
-            await params.assertSourceCurrent();
+            yield* source.assertCurrent();
         try {
-            params.mutation.assert();
-            await params.fsModule.rename(params.src, params.dest);
+            mutation.assert();
+            yield* io.rename(source.pathname, destination);
             return { method: "rename" };
         }
         catch (error) {
-            params.mutation.rethrowRefusal();
+            mutation.rethrowRefusal();
             const code = readErrorCode(error);
-            if (code === "EBUSY" && attempt < params.maxRetries) {
-                await sleep(params.baseDelayMs * 2 ** attempt);
+            if (code === "EBUSY" && attempt < maxRetries) {
+                yield* io.delay(baseDelayMs * 2 ** attempt);
                 continue;
             }
-            if (params.copyFallbackOnPermissionError && (code === "EPERM" || code === "EEXIST")) {
-                await copyFallbackReplace({
-                    fsModule: params.fsModule,
-                    src: params.src,
-                    dest: params.dest,
-                    destinationHardlinks: params.destinationHardlinks,
-                    restore: params.copyFallbackRestore,
-                    maxRestoreBytes: params.maxRestoreBytes,
-                    expectedSourceIdentity: params.sourceIdentity,
-                    sync: params.syncFallback,
-                    mutation: params.mutation,
-                });
-                return { method: "copy-fallback" };
-            }
-            throw error;
-        }
-    }
-    throw new Error("Atomic rename retry loop exhausted.");
-}
-function renameWithRetrySync(params) {
-    for (let attempt = 0; attempt <= params.maxRetries; attempt++) {
-        if (attempt > 0)
-            params.assertSourceCurrent();
-        try {
-            params.mutation.assert();
-            params.fsModule.renameSync(params.src, params.dest);
-            return { method: "rename" };
-        }
-        catch (error) {
-            params.mutation.rethrowRefusal();
-            const code = readErrorCode(error);
-            if (code === "EBUSY" && attempt < params.maxRetries) {
-                sleepSync(params.baseDelayMs * 2 ** attempt);
-                continue;
-            }
-            if (params.copyFallbackOnPermissionError && (code === "EPERM" || code === "EEXIST")) {
-                copyFallbackReplaceSync({
-                    fsModule: params.fsModule,
-                    src: params.src,
-                    dest: params.dest,
-                    destinationHardlinks: params.destinationHardlinks,
-                    restore: params.copyFallbackRestore,
-                    maxRestoreBytes: params.maxRestoreBytes,
-                    expectedSourceIdentity: params.sourceIdentity,
-                    fchmodSync: params.fchmodSync,
-                    sync: params.syncFallback,
-                    mutation: params.mutation,
+            if (copyFallbackOnPermissionError && (code === "EPERM" || code === "EEXIST")) {
+                yield* copyFallbackReplace(io, {
+                    src: source.pathname,
+                    dest: destination,
+                    destinationHardlinks,
+                    restore,
+                    maxRestoreBytes,
+                    expectedSourceIdentity: sourceIdentity,
+                    sync,
+                    mutation,
                 });
                 return { method: "copy-fallback" };
             }
@@ -107,48 +78,24 @@ function buildReplaceTempPath(filePath, tempPrefix) {
     const safePrefix = assertSafePathPrefix(tempPrefix ?? ".fs-safe-replace", { label: "atomic replace temp prefix" });
     return path.join(dir, `${safePrefix}.${process.pid}.${randomUUID()}.tmp`);
 }
-async function resolveMode(options, filePath) {
+function* resolveMode(io, options, filePath) {
     const defaultMode = options.mode ?? 0o600;
-    if (!options.preserveExistingMode) {
+    if (!options.preserveExistingMode)
         return defaultMode;
-    }
-    const fsModule = options.fileSystem?.promises ?? fs;
     let stat;
     try {
-        stat = fsModule === fs ? syncFs.lstatSync(filePath) : await fsModule.lstat(filePath);
+        stat = yield* io.lstat(filePath);
     }
     catch (error) {
-        if (hasErrorCode(error, "ENOENT")) {
-            return defaultMode;
-        }
-        throw error;
-    }
-    return stat ? inheritedRegularFileMode(stat) : defaultMode;
-}
-function resolveModeSync(options, filePath) {
-    const defaultMode = options.mode ?? 0o600;
-    if (!options.preserveExistingMode) {
-        return defaultMode;
-    }
-    const fsModule = options.fileSystem ?? syncFs;
-    let stat;
-    try {
-        stat = fsModule.lstatSync(filePath);
-    }
-    catch (error) {
-        if (!hasErrorCode(error, "ENOENT")) {
+        if (!hasErrorCode(error, "ENOENT"))
             throw error;
-        }
     }
     return stat ? inheritedRegularFileMode(stat) : defaultMode;
 }
-function missingFchmodSyncError() {
-    return new TypeError("fileSystem.fchmodSync is required when mode, dirMode, or preserveExistingMode is specified");
-}
 export async function replaceFileAtomic(options) {
     return await replaceFileAtomicWithDirectorySync(options);
 }
-// Internal owner hook: keep directory durability inside publication verification and serialization.
+// Directory durability remains inside the serialized publication and verification lifetime.
 export async function replaceFileAtomicWithDirectorySync(options, syncParent) {
     const mutation = new AtomicMutation(options);
     const filePath = validateReplaceFilePath(options.filePath);
@@ -157,7 +104,7 @@ export async function replaceFileAtomicWithDirectorySync(options, syncParent) {
     validateRenameIdentity(renameIdentity);
     return await serializePathWrite(path.resolve(filePath), async () => {
         if (renameIdentity !== "verify-content-with-lock") {
-            return await replaceFileAtomicUnserialized(options, filePath, renameIdentity, mutation, syncParent);
+            return await replaceAsync(options, filePath, renameIdentity, mutation, syncParent);
         }
         const fsModule = options.fileSystem?.promises ?? fs;
         const dir = path.dirname(filePath);
@@ -167,88 +114,11 @@ export async function replaceFileAtomicWithDirectorySync(options, syncParent) {
             mode: options.dirMode ?? 0o700,
         });
         mutation.assert();
-        return await withAtomicRenameIdentityLock(filePath, async () => await replaceFileAtomicUnserialized(options, filePath, renameIdentity, mutation, syncParent));
+        return await withAtomicRenameIdentityLock(filePath, () => replaceAsync(options, filePath, renameIdentity, mutation, syncParent));
     });
 }
-async function replaceFileAtomicUnserialized(options, filePath, renameIdentity, mutation, syncParent) {
-    const fsModule = options.fileSystem?.promises ?? fs;
-    const dir = path.dirname(filePath);
-    const dirMode = options.dirMode ?? 0o700;
-    const mode = await resolveMode(options, filePath);
-    const expectedHash = atomicExpectedContentHash(renameIdentity, options.content);
-    const tempPath = buildReplaceTempPath(filePath, options.tempPrefix);
-    const tempOwner = new AsyncAtomicTempOwner(tempPath);
-    let originalFailure;
-    try {
-        mutation.assert();
-        await fsModule.mkdir(fsModule === fs ? recursiveMkdirPath(dir) : dir, { recursive: true, mode: dirMode });
-        await applyDirectoryMode({ fsModule, dirPath: dir, mode: dirMode, mutation });
-        tempOwner.start();
-        tempOwner.adopt(await writeTempFile({
-            fsModule,
-            tempPath,
-            content: options.content,
-            mode,
-            sync: options.syncTempFile === true,
-            onIdentity: tempOwner.onIdentity,
-            mutation,
-        }));
-        await tempOwner.assertCurrent(fsModule);
-        if (options.beforeRename) {
-            await options.beforeRename({ filePath, tempPath });
-            await tempOwner.assertCurrent(fsModule);
-        }
-        if (options.destinationHardlinks === "reject") {
-            await assertDestinationHardlinkPolicy(fsModule, filePath, options.destinationHardlinks);
-            await tempOwner.assertCurrent(fsModule);
-        }
-        const result = await renameWithRetry({
-            fsModule,
-            src: tempPath,
-            dest: filePath,
-            maxRetries: options.renameMaxRetries ?? 0,
-            baseDelayMs: options.renameRetryBaseDelayMs ?? 50,
-            copyFallbackOnPermissionError: options.copyFallbackOnPermissionError === true,
-            copyFallbackRestore: options.copyFallbackRestore ?? "none",
-            maxRestoreBytes: options.maxRestoreBytes,
-            destinationHardlinks: options.destinationHardlinks,
-            sourceIdentity: tempOwner.identity,
-            assertSourceCurrent: () => tempOwner.assertCurrent(fsModule),
-            syncFallback: options.syncTempFile === true,
-            mutation,
-        });
-        if (result.method === "rename") {
-            tempOwner.markRenamed();
-            await tempOwner.assertPublished(fsModule, filePath, expectedHash, identity => mutation.destination("published", filePath, identity));
-        }
-        else {
-            await tempOwner.assertCurrent(fsModule);
-        }
-        let didSyncParent = false;
-        if (syncParent) {
-            await syncParent(dir);
-            didSyncParent = true;
-        }
-        else if (options.syncParentDir) {
-            await syncDirectoryBestEffort(fsModule, dir);
-            didSyncParent = true;
-        }
-        if (result.method === "rename" && didSyncParent) {
-            await tempOwner.assertPublished(fsModule, filePath, expectedHash);
-        }
-        return result;
-    }
-    catch (error) {
-        originalFailure = { error };
-        throw error;
-    }
-    finally {
-        await tempOwner.finish({
-            fsModule,
-            originalFailure,
-            throwOnCleanupError: options.throwOnCleanupError === true,
-        });
-    }
+function replaceAsync(options, filePath, renameIdentity, mutation, syncParent) {
+    return runAsync(replace(AtomicIo.async(options.fileSystem?.promises ?? fs), options, filePath, renameIdentity, mutation, syncParent));
 }
 export function replaceFileAtomicSync(options) {
     const mutation = new AtomicMutation(options);
@@ -257,7 +127,7 @@ export function replaceFileAtomicSync(options) {
     const renameIdentity = options.renameIdentity;
     validateRenameIdentity(renameIdentity);
     if (renameIdentity !== "verify-content-with-lock") {
-        return replaceFileAtomicSyncUnserialized(options, filePath, renameIdentity, mutation);
+        return replaceSync(options, filePath, renameIdentity, mutation);
     }
     const fsModule = options.fileSystem ?? syncFs;
     const dir = path.dirname(filePath);
@@ -267,78 +137,72 @@ export function replaceFileAtomicSync(options) {
         mode: options.dirMode ?? 0o700,
     });
     mutation.assert();
-    return withAtomicRenameIdentityLockSync(filePath, () => replaceFileAtomicSyncUnserialized(options, filePath, renameIdentity, mutation));
+    return withAtomicRenameIdentityLockSync(filePath, () => replaceSync(options, filePath, renameIdentity, mutation));
 }
-function replaceFileAtomicSyncUnserialized(options, filePath, renameIdentity, mutation) {
-    const fsModule = options.fileSystem ?? syncFs;
+function replaceSync(options, filePath, renameIdentity, mutation) {
+    return runSync(replace(AtomicIo.sync(options.fileSystem ?? syncFs), options, filePath, renameIdentity, mutation));
+}
+function* replace(io, options, filePath, renameIdentity, mutation, syncParent) {
     const dir = path.dirname(filePath);
     const dirMode = options.dirMode ?? 0o700;
-    const mode = resolveModeSync(options, filePath);
+    const mode = yield* resolveMode(io, options, filePath);
     const expectedHash = atomicExpectedContentHash(renameIdentity, options.content);
-    const fchmodSync = options.fileSystem?.fchmodSync ?? (options.fileSystem === undefined ? syncFs.fchmodSync : undefined);
-    if (!fchmodSync &&
-        (options.mode !== undefined ||
-            options.preserveExistingMode === true ||
+    if (!io.asynchronous) {
+        const syncOptions = options;
+        io.fchmodSync = syncOptions.fileSystem?.fchmodSync ?? (syncOptions.fileSystem === undefined ? syncFs.fchmodSync : undefined);
+        if (!io.fchmodSync && (options.mode !== undefined || options.preserveExistingMode === true ||
             (process.platform !== "win32" && options.dirMode !== undefined))) {
-        throw missingFchmodSyncError();
+            throw new TypeError("fileSystem.fchmodSync is required when mode, dirMode, or preserveExistingMode is specified");
+        }
     }
     const tempPath = buildReplaceTempPath(filePath, options.tempPrefix);
-    const tempOwner = new SyncAtomicTempOwner(tempPath);
+    const tempOwner = new AtomicTempOwner(tempPath, io);
     let originalFailure;
     try {
         mutation.assert();
-        fsModule.mkdirSync(fsModule === syncFs ? recursiveMkdirPath(dir) : dir, { recursive: true, mode: dirMode });
-        applyDirectoryModeSync({ fsModule, dirPath: dir, mode: dirMode, fchmodSync, mutation });
+        yield* io.mkdir(dir, dirMode);
+        yield* applyDirectoryMode(io, { dirPath: dir, mode: dirMode, mutation });
         tempOwner.start();
-        tempOwner.adopt(writeTempFileSync({
-            fsModule,
+        tempOwner.adopt(yield* writeTempFile(io, {
             tempPath,
             content: options.content,
             mode,
-            fchmodSync,
             sync: options.syncTempFile === true,
             onIdentity: tempOwner.onIdentity,
             mutation,
         }));
-        tempOwner.assertCurrent(fsModule);
+        yield* tempOwner.assertCurrent();
         if (options.beforeRename) {
-            assertSynchronousCallbackResult(options.beforeRename({ filePath, tempPath }), "beforeRename");
-            tempOwner.assertCurrent(fsModule);
+            const result = options.beforeRename({ filePath, tempPath });
+            if (io.asynchronous)
+                yield* wait(result);
+            else
+                assertSynchronousCallbackResult(result, "beforeRename");
+            yield* tempOwner.assertCurrent();
         }
         if (options.destinationHardlinks === "reject") {
-            assertDestinationHardlinkPolicySync(fsModule, filePath, options.destinationHardlinks);
-            tempOwner.assertCurrent(fsModule);
+            yield* assertDestinationHardlinkPolicy(io, filePath, options.destinationHardlinks);
+            yield* tempOwner.assertCurrent();
         }
-        const result = renameWithRetrySync({
-            fsModule,
-            src: tempPath,
-            dest: filePath,
-            maxRetries: options.renameMaxRetries ?? 0,
-            baseDelayMs: options.renameRetryBaseDelayMs ?? 50,
-            copyFallbackOnPermissionError: options.copyFallbackOnPermissionError === true,
-            copyFallbackRestore: options.copyFallbackRestore ?? "none",
-            maxRestoreBytes: options.maxRestoreBytes,
-            destinationHardlinks: options.destinationHardlinks,
-            sourceIdentity: tempOwner.identity,
-            assertSourceCurrent: () => tempOwner.assertCurrent(fsModule),
-            fchmodSync,
-            syncFallback: options.syncTempFile === true,
-            mutation,
-        });
+        const result = yield* renameWithRetry(io, tempOwner, filePath, options, mutation);
         if (result.method === "rename") {
             tempOwner.markRenamed();
-            tempOwner.assertPublished(fsModule, filePath, expectedHash, identity => mutation.destination("published", filePath, identity));
+            yield* tempOwner.assertPublished(filePath, expectedHash, identity => mutation.destination("published", filePath, identity));
         }
         else {
-            tempOwner.assertCurrent(fsModule);
+            yield* tempOwner.assertCurrent();
         }
         let didSyncParent = false;
-        if (options.syncParentDir) {
-            syncDirectoryBestEffortSync(fsModule, dir);
+        if (syncParent) {
+            yield* wait(syncParent(dir));
+            didSyncParent = true;
+        }
+        else if (options.syncParentDir) {
+            yield* syncDirectoryBestEffort(io, dir);
             didSyncParent = true;
         }
         if (result.method === "rename" && didSyncParent) {
-            tempOwner.assertPublished(fsModule, filePath, expectedHash);
+            yield* tempOwner.assertPublished(filePath, expectedHash);
         }
         return result;
     }
@@ -347,10 +211,6 @@ function replaceFileAtomicSyncUnserialized(options, filePath, renameIdentity, mu
         throw error;
     }
     finally {
-        tempOwner.finish({
-            fsModule,
-            originalFailure,
-            throwOnCleanupError: options.throwOnCleanupError === true,
-        });
+        yield* tempOwner.finish({ originalFailure, throwOnCleanupError: options.throwOnCleanupError === true });
     }
 }

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

@@ -6,25 +6,14 @@ export function sameNormalizedPathSpelling(left, right) {
     // Preserve case on Windows, where individual directories can be case-sensitive.
     return path.resolve(left) === path.resolve(right);
 }
-function windowsComparablePath(value, normalize) {
-    const original = normalize
-        ? path.win32.normalize(value.replaceAll("/", "\\"))
-        : value.replaceAll("/", "\\");
+function windowsComparisonSpelling(original) {
     if (/^\\\\\?\\UNC\\/i.test(original)) {
-        return {
-            original,
-            comparison: `\\\\${original.slice(8)}`,
-            originalIndex: (comparisonIndex) => comparisonIndex + 6,
-        };
+        return `\\\\${original.slice(8)}`;
     }
     if (original.startsWith("\\\\?\\")) {
-        return {
-            original,
-            comparison: original.slice(4),
-            originalIndex: (comparisonIndex) => comparisonIndex + 4,
-        };
+        return original.slice(4);
     }
-    return { original, comparison: original, originalIndex: (comparisonIndex) => comparisonIndex };
+    return original;
 }
 function trimWindowsTrailingSeparators(value) {
     const rootLength = path.win32.parse(value).root.length;
@@ -63,24 +52,25 @@ function windowsRootPrefix(rootPath, candidatePath) {
     const exact = exactWindowsRootPrefix(rootPath, candidatePath);
     if (exact)
         return exact;
-    const trusted = windowsComparablePath(rootPath, true);
-    const supplied = windowsComparablePath(candidatePath, false);
-    const root = trimWindowsTrailingSeparators(trusted.original);
-    const rootComparison = trimWindowsTrailingSeparators(trusted.comparison);
-    const candidate = supplied.comparison;
-    if (!path.win32.isAbsolute(supplied.original))
+    const trusted = path.win32.normalize(rootPath.replaceAll("/", "\\"));
+    const trustedComparison = windowsComparisonSpelling(trusted);
+    const supplied = candidatePath.replaceAll("/", "\\");
+    const candidate = windowsComparisonSpelling(supplied);
+    const root = trimWindowsTrailingSeparators(trusted);
+    const rootComparison = trimWindowsTrailingSeparators(trustedComparison);
+    if (!path.win32.isAbsolute(supplied))
         return undefined;
     let relativePath;
     let candidateRootPath;
     let admission;
     if (candidate === rootComparison) {
         relativePath = "";
-        candidateRootPath = supplied.original;
+        candidateRootPath = supplied;
         admission = "exact";
     }
     else if (candidate.toLowerCase() === rootComparison.toLowerCase()) {
         relativePath = "";
-        candidateRootPath = supplied.original;
+        candidateRootPath = supplied;
         admission = "identity";
     }
     else {
@@ -96,7 +86,7 @@ function windowsRootPrefix(rootPath, candidatePath) {
             return undefined;
         }
         relativePath = trimWindowsLeadingSeparators(candidate.slice(rootWithSep.length));
-        candidateRootPath = supplied.original.slice(0, supplied.originalIndex(rootComparison.length));
+        candidateRootPath = supplied.slice(0, rootComparison.length + (supplied.length - candidate.length));
     }
     const rebasedPath = relativePath === ""
         ? root

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

@@ -4,9 +4,6 @@ export type RootContext = {
     rootDir: string;
     rootGuard?: AsyncDirectoryGuard<BigIntStats>;
     rootIdentity: {
-        dev: number;
-        ino: number;
-    } | {
         dev: bigint;
         ino: bigint;
     };
@@ -27,7 +24,7 @@ export declare function assertRootIdentityCurrent(root: RootContext, observe?: (
  * This is deliberately separate from {@link assertRootIdentityCurrent}: callers
  * must not retain the returned guard beyond the operation that requested it.
  */
-export declare function createRootObservationGuard(root: RootContext): Promise<DirectoryObservationGuard | undefined>;
+export declare function createRootObservationGuard(root: RootContext): Promise<DirectoryObservationGuard>;
 export declare function resolvePathInRoot(root: RootContext, relativePath: string, options?: {
     aliasErrorCode?: "outside-workspace" | "path-alias";
     allowFinalSymlink?: boolean;

package/node_modules/@openclaw/fs-safe/dist/root-context.js

@@ -3,7 +3,6 @@ import os from "node:os";
 import path from "node:path";
 import { extendDirectoryObservationGuard, inspectDirectoryIdentitySync, inspectDirectoryObservationSync, } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
-import { sameFileIdentity } from "./file-identity.js";
 import { assertNoNulPathInput, assertNoUnsafeDeviceReadPath, hasNodeErrorCode, isNotFoundPathError, isPathInside, } from "./path.js";
 import { ROOT_PATH_ALIAS_POLICIES, resolveRootPath } from "./root-path.js";
 import { admitPathInsideRoot } from "./root-boundary.js";
@@ -12,9 +11,6 @@ import { isDriveRelativePath } from "./safe-path-segment.js";
 import { realpathSync } from "./realpath.js";
 import { inspectFileIdentity } from "./strict-file-identity.js";
 import { assertNoWindowsPathAlias, pathForWindowsFilesystem, resolvePathFromBasePreservingWindowsRoot, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
-function hasExactRootIdentity(identity) {
-    return typeof identity.dev === "bigint" && typeof identity.ino === "bigint";
-}
 export const ensureTrailingSep = (value) => value.endsWith(path.sep) ? value : value + path.sep;
 export function assertValidRootRelativePath(relativePath) {
     assertNoNulPathInput(relativePath, "relative path contains a NUL byte");
@@ -123,23 +119,13 @@ export function rootRelativeReadPath(root, filePath) {
     return raw;
 }
 export function assertRootIdentityCurrentSync(root, observe) {
-    let current;
     try {
-        if (typeof root.rootIdentity.dev === "bigint" && typeof root.rootIdentity.ino === "bigint") {
-            const stat = inspectDirectoryIdentitySync(root.rootReal, { dev: root.rootIdentity.dev, ino: root.rootIdentity.ino });
-            observe?.(stat);
-            return;
-        }
-        current = fs.lstatSync(root.rootReal);
+        const stat = inspectDirectoryIdentitySync(root.rootReal, { dev: root.rootIdentity.dev, ino: root.rootIdentity.ino });
+        observe?.(stat);
     }
     catch (error) {
         throw rootPathChangedError(error instanceof Error ? error : undefined);
     }
-    if (current.isSymbolicLink() ||
-        !current.isDirectory() ||
-        !sameFileIdentity(current, root.rootIdentity)) {
-        throw rootPathChangedError();
-    }
 }
 export async function assertRootIdentityCurrent(root, observe) {
     assertRootIdentityCurrentSync(root, observe);
@@ -152,9 +138,8 @@ export async function assertRootIdentityCurrent(root, observe) {
  */
 export async function createRootObservationGuard(root) {
     const rootIdentity = root.rootIdentity;
-    if (!hasExactRootIdentity(rootIdentity)) {
-        await assertRootIdentityCurrent(root);
-        return undefined;
+    if (typeof rootIdentity?.dev !== "bigint" || typeof rootIdentity.ino !== "bigint") {
+        throw rootPathChangedError();
     }
     try {
         const observed = await inspectDirectoryObservationSync(root.rootReal, rootIdentity);

package/node_modules/@openclaw/fs-safe/dist/root-create-native.d.ts

@@ -0,0 +1,52 @@
+import fs from "node:fs";
+import type { FileHandle } from "node:fs/promises";
+import { type AnyAsyncDirectoryGuard } from "./directory-guard.js";
+import { type PinnedMutationPolicySnapshot } from "./pinned-mutation-admission.js";
+import { type RootContext } from "./root-context.js";
+import type { RootWritePathSelection, RetainedRootWriteSelection } from "./root-write-admission.js";
+import type { WritableOpenResult } from "./root-impl.js";
+import type { RootOpenWritableOptions } from "./root-options.js";
+export type OpenedWritableFileInRoot = {
+    opened: WritableOpenResult;
+    identity: fs.BigIntStats;
+    writeSelection?: RetainedRootWriteSelection;
+    cleanupCreated?: () => Promise<void>;
+    releaseCreationParent?: () => void;
+};
+export type WritableFileInRootParams = Omit<RootOpenWritableOptions, "writeMode"> & {
+    relativePath: string;
+    truncateExisting?: boolean;
+    append?: boolean;
+    expectedWritePath?: string;
+    keepCreationParent?: boolean;
+};
+export declare function rootWriteQueueKey(root: RootContext, relativePath: string): string;
+export declare function buildAtomicWriteTempPath(targetPath: string): string;
+export type MissingWritableFileInRoot = {
+    missing: true;
+    targetPath: string;
+    parentGuard: AnyAsyncDirectoryGuard;
+    writeSelection?: RootWritePathSelection;
+};
+type Creation = {
+    root: RootContext;
+    directory: string;
+    target: string;
+    mkdir: boolean;
+    private?: boolean;
+    policy?: PinnedMutationPolicySnapshot;
+    resolveCurrent(): Promise<string>;
+    assertBeforeMutation?: () => void;
+    originalPath?: string;
+};
+export declare function tryMkdirRootNative(params: Creation): Promise<boolean>;
+export declare function tryOpenCreateRootNative(params: Creation & {
+    flags: number;
+    existingFlags: number;
+    mode: number;
+}): Promise<{
+    handle: FileHandle;
+    cleanupCreated(): Promise<void>;
+    releaseCreationParent(): void;
+}>;
+export {};