@openclaw/openshell-sandbox 2026.10.5-beta.4 → 2026.10.10-beta.2

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

@@ -1,7 +1,9 @@
+import { type ExactFileIdentity } from "./exact-identity.js";
 import fs from "node:fs";
 import type { PathAliasPolicy } from "./path-policy.js";
 import { type SymlinkPolicy } from "./root-symlink-policy.js";
 import { type PinnedOpenSyncAllowedType, type PinnedOpenSyncFailureReason } from "./pinned-open.js";
+import { type CanonicalRootObservation } from "./root-file-final-admission.js";
 type BoundaryReadFs = Pick<typeof fs, "closeSync" | "constants" | "fstatSync" | "lstatSync" | "openSync" | "readFileSync" | "realpathSync">;
 export type RootFileOpenFailureReason = PinnedOpenSyncFailureReason | "validation";
 export type RootFileOpenResult = {
@@ -9,6 +11,7 @@ export type RootFileOpenResult = {
     path: string;
     fd: number;
     stat: fs.Stats;
+    exactIdentity: ExactFileIdentity;
     rootRealPath: string;
 } | {
     ok: false;
@@ -42,5 +45,9 @@ export declare function matchRootFileOpenFailure<T>(failure: RootFileOpenFailure
     io?: (failure: RootFileOpenFailure) => T;
     fallback: (failure: RootFileOpenFailure) => T;
 }): T;
+/** Internal retained-root adapter; the native opener owns component admission. */
+export declare function openRootFileWithRetainedRootSync(params: OpenRootFileSyncParams, root: Extract<CanonicalRootObservation, {
+    ok: true;
+}>, admittedFd: number): RootFileOpenResult;
 export declare function openRootFile(params: OpenRootFileParams): Promise<RootFileOpenResult>;
 export {};

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

@@ -1,3 +1,4 @@
+import { exactFileIdentity } from "./exact-identity.js";
 import fs from "node:fs";
 import path from "node:path";
 import { resolveRootPathSyncWithCanonicalRootObservation, resolveRootPathWithCanonicalRootObservation, } from "./root-path.js";
@@ -82,6 +83,8 @@ function finalizeRootFileOpen(params) {
         maxBytes: params.maxBytes,
         allowedType: params.allowedType,
         ioFs: params.ioFs,
+        admittedFd: params.admittedFd,
+        rejectLeafSymlinks: params.rejectLeafSymlinks,
         finalAdmission: createRootFileFinalAdmission(params.ioFs, resolved.rootObservation, resolved.boundaryLabel, rejectHardlinks),
     });
     if (!opened.ok) {
@@ -92,9 +95,21 @@ function finalizeRootFileOpen(params) {
         path: opened.path,
         fd: opened.fd,
         stat: opened.stat,
+        exactIdentity: exactFileIdentity(opened.identity),
         rootRealPath: resolved.rootRealPath,
     };
 }
+/** Internal retained-root adapter; the native opener owns component admission. */
+export function openRootFileWithRetainedRootSync(params, root, admittedFd) {
+    return finalizeRootFileOpen({
+        resolved: {
+            absolutePath: params.absolutePath, resolvedPath: params.absolutePath,
+            rootRealPath: root.path, rootObservation: root, boundaryLabel: params.boundaryLabel,
+        },
+        maxBytes: params.maxBytes, rejectHardlinks: params.rejectHardlinks,
+        allowedType: params.allowedType, ioFs: fs, admittedFd, rejectLeafSymlinks: true,
+    });
+}
 export async function openRootFile(params) {
     const ioFs = params.ioFs ?? fs;
     const rawAbsolutePath = params.absolutePath;

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

@@ -1,3 +1,4 @@
+import { type ExactFileIdentity } from "./exact-identity.js";
 import type { BigIntStats, Stats } from "node:fs";
 import type { FileHandle } from "node:fs/promises";
 import type { ContainmentGuarantee } from "./containment.js";
@@ -14,6 +15,7 @@ export type OpenResult = {
     containment: ContainmentGuarantee;
     realPath: string;
     stat: Stats;
+    exactIdentity: ExactFileIdentity;
     [Symbol.asyncDispose](): Promise<void>;
 };
 export interface Root {

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

@@ -50,12 +50,13 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import { exactFileIdentity, numberStats } from "./exact-identity.js";
 import { registerRootHandleContext } from "./root-handle-context.js";
 import fsSync, { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { normalizeMaxBytes } from "./byte-budget.js";
-import { assertCopySourceCurrent, resolveFileCopyCloneMode } from "./copy-file-input.js";
+import { copyFileInRoot } from "./root-copy.js";
 import { assertPrivateFileCreationAvailable, resolveCreationPermissions } from "./creation-boundary.js";
 import { assertAsyncDirectoryGuard, assertSyncDirectoryGuard, createAsyncDirectoryGuard, createNearestExistingDirectoryGuard } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
@@ -68,6 +69,7 @@ import { openedPathResolutionError, recordExclusiveCreateFailure, recordOpenedFi
 import { runPinnedWriteHelper, runPinnedWriteWithRenamePolicy } from "./pinned-write.js";
 import { preparePinnedWriteMutationAdmission, snapshotPinnedMutationPolicy } from "./pinned-mutation-admission.js";
 import { getNativeBinding } from "./native.js";
+import { getPinnedWriteNativeBinding } from "./native-pinned-write.js";
 import { isFsSafeNativeRequired } from "./native-config.js";
 import { validatePinnedRelativePath } from "./pinned-operation.js";
 import { PATH_ALIAS_POLICIES } from "./path-policy.js";
@@ -78,7 +80,8 @@ import { sameFileIdentity } from "./file-identity.js";
 import { removePathIfIdentityUnchanged } from "./replace-file-temp-owner.js";
 import { realpathSync } from "./realpath.js";
 import { mkdirPathFallback, prepareRootWriteTarget, tryMkdirAtExactParent } from "./root-directory-creation.js";
-import { buildAtomicWriteTempPath, rootWriteQueueKey, tryMkdirRootNative, tryOpenCreateRootNative } from "./root-create-native.js";
+import { tryMkdirNativeParents } from "./root-mkdir-native.js";
+import { buildAtomicWriteTempPath, rootWriteQueueKey, ensureNativeRootCurrent, isNativeCreateCollision, probeNativeCreationPath, tryMkdirNativeDirectChild, tryMkdirRootNative, tryOpenCreateRootNative } from "./root-create-native.js";
 import { isNonRegularWriteOpenError, resolveNonblockingWriteFlag } from "./write-open-flags.js";
 import { resolveRootPath, resolveRootPathSync, resolveRootPathForRemoval } from "./root-path.js";
 import { RemovalPathReceipts } from "./root-remove-receipt.js";
@@ -101,10 +104,10 @@ import { prepareSharedRootWriteTarget } from "./root-write-complete-parent.js";
 import { finishRootFallbackWrite } from "./root-write-publication.js";
 import { withRootFallbackCompatibilityLock } from "./root-write-compatibility.js";
 import { assertRootFallbackWritePath } from "./root-write-lock-binding.js";
-import { inspectFileIdentity, inspectFileIdentitySync } from "./strict-file-identity.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { admitMoveSourceStat, movePathNative } from "./root-move-noreplace.js";
 import { admitRootReadHandle, inspectOpenedPathIdentitySync } from "./root-read-admission.js";
-import { createCopyPublicationObserver, onCopyPublication, onCopySourceAdmission } from "./copy-publication.js";
+import { onCopyPublication, onCopySourceAdmission } from "./copy-publication.js";
 import { writeAllToFile } from "./write-file-handle.js";
 import { createInputOptions, rethrowCreateInputError, rootWriteInput, retainSidecarCreated } from "./root-create-input.js";
 import { assertFinalSymlinkRejected, mutationSymlinkResolution, readSymlinkResolution } from "./root-symlink-policy.js";
@@ -113,7 +116,7 @@ import { assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot } from "./wi
 import { resolvePinnedObservedPathInRoot } from "./root-observed-path.js";
 import { registerFileLockSyncRootAdapter } from "./file-lock-sync-root.js";
 import { mergeReadOptions, readDefaults, } from "./root-options.js";
-import { composeMutationAssertions, MutationAuthorityError, rethrowMutationAuthorityError } from "./mutation-authority.js";
+import { composeMutationAssertions, rethrowMutationAuthorityError } from "./mutation-authority.js";
 export { DEFAULT_ROOT_MAX_BYTES } from "./root-options.js";
 export { resolveOpenedFileRealPathForHandle } from "./opened-realpath.js";
 function logWarn(message) {
@@ -141,6 +144,7 @@ function openResult(params) {
         containment: "best-effort",
         realPath: params.realPath,
         stat: params.stat,
+        exactIdentity: params.exactIdentity,
         [Symbol.asyncDispose]: () => params.handle.close().catch(() => undefined),
     };
 }
@@ -150,7 +154,7 @@ async function openVerifiedLocalFile(filePath, options) {
     try {
         const inspectPathIdentity = async (inspect) => {
             try {
-                return await inspectFileIdentity(inspect, identity);
+                return inspectFileIdentitySync(inspect, identity);
             }
             catch (error) {
                 const failure = isNotFoundPathError(error) ? openedPathResolutionError(fileNotFoundError()) : error;
@@ -160,8 +164,10 @@ async function openVerifiedLocalFile(filePath, options) {
                 throw failure;
             }
         };
-        await inspectPathIdentity(async () => inspectOpenedPathIdentitySync(filePath, options?.symlinks));
-        await fsSafeTestHooks?.afterOpenedPathIdentityCheck?.(filePath, handle);
+        await inspectPathIdentity(() => inspectOpenedPathIdentitySync(filePath, options?.symlinks));
+        if (fsSafeTestHooks?.afterOpenedPathIdentityCheck) {
+            await fsSafeTestHooks.afterOpenedPathIdentityCheck(filePath, handle);
+        }
         const resolved = await resolveOpenedFileRealPathForFd(handle.fd, identity, filePath)
             .catch(async (error) => {
             if (stat.nlink <= 1 && (!preOpenStat || preOpenStat.nlink <= 1n)) {
@@ -172,7 +178,7 @@ async function openVerifiedLocalFile(filePath, options) {
         const { realPath } = resolved;
         assertNoWindowsPathAlias(realPath, "filesystem", "resolved file path uses a Windows filesystem namespace alias");
         let resolvedStat = resolved.stat;
-        await inspectPathIdentity(async () => {
+        await inspectPathIdentity(() => {
             // Reuse the post-realpath observation; unknown Windows identities still
             // get a fresh observation on inspectFileIdentity's retry.
             const realStat = resolvedStat ?? fsSync.statSync(realPath, { bigint: true });
@@ -182,7 +188,7 @@ async function openVerifiedLocalFile(filePath, options) {
             }
             return realStat;
         });
-        return { opened: openResult({ handle, realPath, stat }), identity };
+        return { opened: openResult({ handle, realPath, stat, exactIdentity: exactFileIdentity(identity) }), identity };
     }
     catch (err) {
         await handle.close().catch(() => { });
@@ -355,7 +361,7 @@ export class RootHandle {
             durable: options.durable ?? this.defaults.durable ?? true,
             verifyPublished: options[onCopyPublication],
             admitSource: options[onCopySourceAdmission],
-        }).catch(rethrowMutationAuthorityError);
+        }, openVerifiedLocalFile).catch(rethrowMutationAuthorityError);
     }
     async exists(relativePath) {
         try {
@@ -464,7 +470,7 @@ async function openFileInRoot(root, params) {
     // The admission helper owns the descriptor until the complete root/file/root
     // fence succeeds, then transfers that still-open handle to the caller.
     const admitted = await admitRootReadHandle({
-        root, filePath: resolved, opened: { handle, stat }, identity,
+        root, filePath: resolved, opened: { handle, stat, exactIdentity: exactFileIdentity(identity) }, identity,
         hardlinks: params.hardlinks, symlinks: params.symlinks,
         beforeFinalFence: fsSafeTestHooks?.beforeRootReadFinalFence,
         afterPathIdentityCheck: fsSafeTestHooks?.afterRootReadFinalPathIdentityCheck,
@@ -511,46 +517,61 @@ async function openWritableFileInRoot(root, params, options) {
             denyMutations: params.denyMutations,
             mutationSymlinks: params.mutationSymlinks,
         });
-    const { resolved } = guardedTarget?.resolvedPath ?? await resolveGuardedWritePathInRoot(root, {
+    const creationProbe = requireNative && !guardedTarget && params.assertBeforeMutation === undefined && options?.createIfMissing !== false
+        ? probeNativeCreationPath(root, params.relativePath) : undefined;
+    const { resolved } = creationProbe ?? guardedTarget?.resolvedPath ?? await resolveGuardedWritePathInRoot(root, {
         relativePath: params.relativePath,
     });
     const resolveCurrent = async () => (await resolveGuardedWritePathInRoot(root, {
         relativePath: params.relativePath, ...policy,
     })).resolved;
-    const nativeParent = requireNative && params.mkdir !== false && await tryMkdirRootNative({
-        originalPath: params.relativePath,
-        root, directory: path.dirname(resolved), target: resolved, mkdir: true, policy,
-        resolveCurrent, assertBeforeMutation: params.assertBeforeMutation,
-    });
-    const prepared = !nativeParent && guardedTarget ? await prepareSharedRootWriteTarget(root, {
+    // Existing-file opens need no mkdir. Keep capability admission, and create
+    // missing parents only when the native exclusive-create route is needed.
+    const nativeCreatesParents = requireNative && params.mkdir !== false;
+    if (nativeCreatesParents) {
+        const binding = getNativeBinding("openBeneath", "mkdirChildBeneath", "closeOwnedFd");
+        if (!binding)
+            throw new FsSafeError("helper-unavailable", "native confined creation is unavailable");
+        // Policy selection retains a parent receipt before the existing-file open.
+        if (guardedTarget)
+            await tryMkdirRootNative({
+                originalPath: params.relativePath,
+                root, directory: path.dirname(resolved), target: resolved, mkdir: true, policy,
+                resolveCurrent, assertBeforeMutation: params.assertBeforeMutation,
+            });
+    }
+    const prepared = !nativeCreatesParents && guardedTarget ? await prepareSharedRootWriteTarget(root, {
         relativePath: params.relativePath, guardedTarget, mkdir: params.mkdir,
         assertBeforeMutation: params.assertBeforeMutation,
     }) : undefined;
     const preparedParent = prepared?.preparedParent;
-    let ioPath = nativeParent ? resolved : prepared?.targetPath ?? (params.mkdir === false ? resolved :
+    let ioPath = nativeCreatesParents ? resolved : prepared?.targetPath ?? (params.mkdir === false ? resolved :
         await prepareRootWriteTarget(root, resolved, params.assertBeforeMutation));
     const operationTargetPath = ioPath;
-    try {
-        assertFinalSymlinkRejected(ioPath, params.mutationSymlinks !== undefined);
-        const resolvedRealPath = params.mutationSymlinks === undefined ? realpathSync.native(ioPath) : ioPath;
-        const admittedRealPath = admitPathInsideRoot({
-            rootPath: root.rootReal,
-            candidatePath: resolvedRealPath,
-            rootIdentity: root.rootIdentity,
-        });
-        if (!admittedRealPath) {
-            throw outsideWorkspaceError();
-        }
-        ioPath = admittedRealPath.path;
-    }
-    catch (err) {
-        if (err instanceof FsSafeError) {
-            throw err;
+    let observedMissing = Boolean(creationProbe);
+    if (!creationProbe)
+        try {
+            assertFinalSymlinkRejected(ioPath, params.mutationSymlinks !== undefined);
+            const resolvedRealPath = params.mutationSymlinks === undefined ? realpathSync.native(ioPath) : ioPath;
+            const admittedRealPath = admitPathInsideRoot({
+                rootPath: root.rootReal,
+                candidatePath: resolvedRealPath,
+                rootIdentity: root.rootIdentity,
+            });
+            if (!admittedRealPath) {
+                throw outsideWorkspaceError();
+            }
+            ioPath = admittedRealPath.path;
         }
-        if (!isNotFoundPathError(err)) {
-            throw err;
+        catch (err) {
+            if (err instanceof FsSafeError) {
+                throw err;
+            }
+            if (!isNotFoundPathError(err)) {
+                throw err;
+            }
+            observedMissing = true;
         }
-    }
     assertRootFallbackWritePath(params.expectedWritePath, ioPath);
     const mode = params.mode ?? 0o600;
     let handle;
@@ -564,55 +585,82 @@ async function openWritableFileInRoot(root, params, options) {
         writePathSelection = guardedTarget
             ? await prepareGuardedRootWritePathSelection(guardedTarget, ioPath, operationTargetPath, preparedParent)
             : undefined;
-        try {
-            if (writePathSelection)
-                assertRootWritePathSelectionSync(root, writePathSelection);
-            handle = await fs.open(ioPath, existingFlags, mode);
-        }
-        catch (err) {
-            if (await isNonRegularWriteOpenError(err, ioPath, existingFlags)) {
-                throw new FsSafeError("not-file", "path is not a regular file under root");
+        const createNative = () => tryOpenCreateRootNative({
+            originalPath: params.relativePath,
+            root, directory: path.dirname(ioPath), target: ioPath, mkdir: params.mkdir !== false, policy,
+            selectedParent: creationProbe?.parent,
+            resolveCurrent,
+            assertBeforeMutation: params.assertBeforeMutation !== undefined || writePathSelection !== undefined ? () => {
+                params.assertBeforeMutation?.();
+                if (writePathSelection)
+                    assertRootWritePathSelectionSync(root, writePathSelection);
+            } : undefined,
+            flags: createFlags, existingFlags, mode,
+        });
+        let precreated;
+        if (requireNative && observedMissing && !guardedTarget && params.assertBeforeMutation === undefined && options?.createIfMissing !== false) {
+            try {
+                precreated = await createNative();
             }
-            if (!isNotFoundPathError(err)) {
-                throw err;
+            catch (error) {
+                if (!hasNodeErrorCode(error, "EEXIST") || !isNativeCreateCollision(error))
+                    throw error;
             }
-            if (options?.createIfMissing === false) {
-                const parentGuard = writePathSelection?.parentGuard ??
-                    await createAsyncDirectoryGuard(path.dirname(ioPath), { bigint: true });
-                assertRootIdentityCurrentSync(root);
-                if (!admitPathInsideRoot({
-                    rootPath: root.rootReal, candidatePath: parentGuard.realPath, rootIdentity: root.rootIdentity,
-                }))
-                    throw outsideWorkspaceError();
-                assertSyncDirectoryGuard(parentGuard);
-                return { missing: true, targetPath: ioPath, parentGuard, writeSelection: writePathSelection };
+        }
+        if (precreated) {
+            handle = precreated.handle;
+            cleanupCreated = precreated.cleanupCreated;
+            releaseCreationParent = precreated.releaseCreationParent;
+            createdForWrite = true;
+        }
+        else {
+            try {
+                if (writePathSelection)
+                    assertRootWritePathSelectionSync(root, writePathSelection);
+                handle = await fs.open(ioPath, existingFlags, mode);
             }
-            if (writePathSelection)
-                await refreshRootWritePathSelection(writePathSelection);
-            const nativeCreated = requireNative ? await tryOpenCreateRootNative({
-                originalPath: params.relativePath,
-                root, directory: path.dirname(ioPath), target: ioPath, mkdir: false, policy,
-                resolveCurrent, assertBeforeMutation() {
+            catch (err) {
+                if (await isNonRegularWriteOpenError(err, ioPath, existingFlags)) {
+                    throw new FsSafeError("not-file", "path is not a regular file under root");
+                }
+                if (!isNotFoundPathError(err)) {
+                    throw err;
+                }
+                if (options?.createIfMissing === false) {
+                    if (nativeCreatesParents && !guardedTarget)
+                        await tryMkdirRootNative({
+                            originalPath: params.relativePath,
+                            root, directory: path.dirname(ioPath), target: ioPath, mkdir: true, policy,
+                            resolveCurrent, assertBeforeMutation: params.assertBeforeMutation,
+                        });
+                    const parentGuard = writePathSelection?.parentGuard ??
+                        await createAsyncDirectoryGuard(path.dirname(ioPath), { bigint: true });
+                    assertRootIdentityCurrentSync(root);
+                    if (!admitPathInsideRoot({
+                        rootPath: root.rootReal, candidatePath: parentGuard.realPath, rootIdentity: root.rootIdentity,
+                    }))
+                        throw outsideWorkspaceError();
+                    assertSyncDirectoryGuard(parentGuard);
+                    return { missing: true, targetPath: ioPath, parentGuard, writeSelection: writePathSelection };
+                }
+                if (writePathSelection)
+                    await refreshRootWritePathSelection(writePathSelection);
+                const nativeCreated = requireNative ? await createNative() : undefined;
+                if (nativeCreated)
+                    handle = nativeCreated.handle;
+                else {
                     params.assertBeforeMutation?.();
                     if (writePathSelection)
                         assertRootWritePathSelectionSync(root, writePathSelection);
-                },
-                flags: createFlags, existingFlags, mode,
-            }) : undefined;
-            if (nativeCreated)
-                handle = nativeCreated.handle;
-            else {
-                params.assertBeforeMutation?.();
-                if (writePathSelection)
-                    assertRootWritePathSelectionSync(root, writePathSelection);
-                // Windows can follow a dangling symlink even with O_EXCL.
-                if (!SUPPORTS_NOFOLLOW)
-                    assertFinalSymlinkRejected(ioPath, true);
-                handle = await fs.open(ioPath, createFlags, mode);
+                    // Windows can follow a dangling symlink even with O_EXCL.
+                    if (!SUPPORTS_NOFOLLOW)
+                        assertFinalSymlinkRejected(ioPath, true);
+                    handle = await fs.open(ioPath, createFlags, mode);
+                }
+                cleanupCreated = nativeCreated?.cleanupCreated;
+                releaseCreationParent = nativeCreated?.releaseCreationParent;
+                createdForWrite = true;
             }
-            cleanupCreated = nativeCreated?.cleanupCreated;
-            releaseCreationParent = nativeCreated?.releaseCreationParent;
-            createdForWrite = true;
         }
     }
     catch (err) {
@@ -630,7 +678,6 @@ async function openWritableFileInRoot(root, params, options) {
     let realPathForCleanup = null;
     let createdIdentity = null;
     try {
-        const stat = fsSync.fstatSync(handle.fd);
         const identity = inspectFileIdentitySync(() => {
             const observed = fsSync.fstatSync(handle.fd, { bigint: true });
             if (!observed.isFile()) {
@@ -640,6 +687,7 @@ async function openWritableFileInRoot(root, params, options) {
                 throw hardlinkedPathNotAllowedError();
             return observed;
         });
+        const stat = numberStats(identity);
         if (createdForWrite)
             createdIdentity = identity;
         let observedIoPath = false;
@@ -721,6 +769,7 @@ async function openWritableFileInRoot(root, params, options) {
             createdForWrite,
             realPath,
             stat,
+            exactIdentity: exactFileIdentity(identity),
             [Symbol.asyncDispose]: () => handle.close().catch(() => undefined),
         };
         if (!params.keepCreationParent)
@@ -851,6 +900,16 @@ async function mkdirPathInRoot(root, params) {
     const policy = params.denyMutations === undefined && params.mutationSymlinks === undefined
         ? undefined
         : snapshotPinnedMutationPolicy(params.denyMutations, params.mutationSymlinks);
+    if (requireNative && !privateMode && !policy && !params.assertBeforeMutation) {
+        if (params.allowRoot && params.relativePath === "") {
+            ensureNativeRootCurrent(root);
+            return;
+        }
+        if (tryMkdirNativeDirectChild(root, params.relativePath))
+            return;
+        if (tryMkdirNativeParents(root, params.relativePath))
+            return;
+    }
     const resolution = { relativePath: params.relativePath, allowRoot: params.allowRoot, ...policy };
     const resolveCurrent = policy
         ? async () => await resolvePinnedPathInRoot(root, resolution)
@@ -897,7 +956,7 @@ async function writeFileInRoot(root, params) {
     const input = rootWriteInput(params);
     await serializePathWrite(rootWriteQueueKey(root, params.relativePath), async () => {
         if (!params.private && input.kind === "buffer" && !input.stageBeforePublish && process.platform === "win32" &&
-            (params.renameIdentity === "verify-content-with-lock" || !getNativeBinding())) {
+            (params.renameIdentity === "verify-content-with-lock" || !getPinnedWriteNativeBinding({ input }))) {
             await writeFileFallback(root, { ...params, data: input.data });
             return;
         }
@@ -965,93 +1024,6 @@ async function commitPinnedWriteInRoot(root, pinned, params, input) {
         throw normalizePinnedWriteError(error);
     }
 }
-async function copyFileInRoot(root, params) {
-    params.signal?.throwIfAborted();
-    const clone = resolveFileCopyCloneMode(params.clone);
-    let source;
-    let sourceIdentity;
-    if (typeof params.source === "string") {
-        assertNoNulPathInput(params.source, "source path contains a NUL byte");
-        assertNoWindowsPathAlias(params.source, "filesystem", "source path uses a Windows filesystem namespace alias");
-        ({ opened: source, identity: sourceIdentity } = await openVerifiedLocalFile(params.source, {
-            hardlinks: params.sourceHardlinks,
-        }));
-    }
-    else {
-        source = await params.source.root.open(params.source.relativePath, params.sourceHardlinks === undefined ? undefined : { hardlinks: params.sourceHardlinks });
-        try {
-            sourceIdentity = await inspectFileIdentity(() => fsSync.fstatSync(source.handle.fd, { bigint: true }));
-        }
-        catch (error) {
-            await source.handle.close().catch(() => undefined);
-            throw error;
-        }
-    }
-    if (params.maxBytes !== undefined && source.stat.size > params.maxBytes) {
-        await source.handle.close().catch(() => { });
-        throw new FsSafeError("too-large", `file exceeds limit of ${params.maxBytes} bytes (got ${source.stat.size})`);
-    }
-    try {
-        const sourceAdmission = params.admitSource?.(sourceIdentity, source.realPath);
-        const mode = sourceAdmission?.mode ?? params.mode;
-        await serializePathWrite(rootWriteQueueKey(root, params.relativePath), async () => {
-            const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, mode ?? (params.preserveSourceMode ? Number(sourceIdentity.mode & 4095n) : undefined), params.denyMutations, params.overwrite !== false, params.mutationSymlinks);
-            await serializePathWrite(pinned.targetPath, async () => {
-                await assertCopySourceCurrent(source, sourceIdentity);
-                const verifySource = async () => {
-                    params.signal?.throwIfAborted();
-                    try {
-                        sourceAdmission?.verify();
-                    }
-                    catch (error) {
-                        throw new MutationAuthorityError(error);
-                    }
-                    if (typeof params.source !== "string") {
-                        await params.source.root.stat(".");
-                    }
-                    await assertCopySourceCurrent(source, sourceIdentity);
-                };
-                const observer = createCopyPublicationObserver(pinned.targetPath, params.onDestinationPublished);
-                try {
-                    await runPinnedWriteHelper({
-                        rootPath: pinned.rootReal,
-                        relativeParentPath: pinned.relativeParentPath,
-                        basename: pinned.basename,
-                        mkdir: params.mkdir !== false,
-                        mode: pinned.mode,
-                        overwrite: params.overwrite !== false,
-                        rejectFinalSymlink: params.mutationSymlinks !== undefined,
-                        maxBytes: params.maxBytes,
-                        sync: params.durable !== false,
-                        assertBeforeMutation: params.signal || params.assertBeforeMutation ? () => {
-                            if (params.signal?.aborted)
-                                throw new MutationAuthorityError(params.signal.reason);
-                            params.assertBeforeMutation?.();
-                        } : undefined,
-                        verifyPublished: params.verifyPublished,
-                        onPublished: observer.onPublished,
-                        input: { kind: "file", handle: source.handle, size: source.stat.size, clone, signal: params.signal, verifySource },
-                        rootIdentity: root.rootIdentity,
-                        mutationAdmission: pinned.mutationAdmission,
-                    });
-                }
-                catch (error) {
-                    observer.rethrowObserverFailure(error);
-                    if (params.signal?.aborted && error === params.signal.reason)
-                        throw error;
-                    if (isAlreadyExistsError(error)) {
-                        throw new FsSafeError("already-exists", "copy destination already exists", { cause: error });
-                    }
-                    throw normalizePinnedWriteError(error);
-                }
-                await verifySource();
-            });
-        });
-    }
-    finally {
-        await source.handle.close().catch(() => { });
-    }
-}
 async function resolvePinnedPathInRoot(root, params) {
     const resolved = await resolvePinnedRootPathInRoot(root, {
         relativePath: params.relativePath,
@@ -1203,10 +1175,15 @@ async function movePathFallback(root, params) {
     }
     const guardOptions = { bigint: sourceIdentity !== undefined };
     const sourceParentGuard = await createAsyncDirectoryGuard(path.dirname(source.resolved), guardOptions);
-    const targetParentGuard = await createNearestExistingDirectoryGuard(target.rootReal, path.dirname(target.resolved), guardOptions);
-    await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("move", target.resolved);
+    const targetParentGuard = path.dirname(target.resolved) === sourceParentGuard.dir
+        ? sourceParentGuard
+        : await createNearestExistingDirectoryGuard(target.rootReal, path.dirname(target.resolved), guardOptions);
+    const beforeMutation = getFsSafeTestHooks()?.beforeRootFallbackMutation;
+    if (beforeMutation)
+        await beforeMutation("move", target.resolved);
     await assertAsyncDirectoryGuard(sourceParentGuard);
-    await assertAsyncDirectoryGuard(targetParentGuard);
+    if (targetParentGuard !== sourceParentGuard)
+        await assertAsyncDirectoryGuard(targetParentGuard);
     try {
         assertFinalSymlinkRejected(source.resolved, params.mutationSymlinks !== undefined);
         assertFinalSymlinkRejected(target.resolved, params.mutationSymlinks !== undefined);
@@ -1214,7 +1191,8 @@ async function movePathFallback(root, params) {
         if (sourceIdentity) {
             assertRootIdentityCurrentSync(root);
             assertSyncDirectoryGuard(sourceParentGuard);
-            assertSyncDirectoryGuard(targetParentGuard);
+            if (targetParentGuard !== sourceParentGuard)
+                assertSyncDirectoryGuard(targetParentGuard);
             for (const [route, selected, expected, policy] of [
                 [originalRoutes[0], source.resolved, pinnedSource.canonicalPath, PATH_ALIAS_POLICIES.strict],
                 [originalRoutes[1], target.resolved, pinnedTarget.canonicalPath, PATH_ALIAS_POLICIES.unlinkTarget],
@@ -1249,7 +1227,8 @@ async function movePathFallback(root, params) {
     }
     try {
         await assertAsyncDirectoryGuard(sourceParentGuard);
-        await assertAsyncDirectoryGuard(targetParentGuard);
+        if (targetParentGuard !== sourceParentGuard)
+            await assertAsyncDirectoryGuard(targetParentGuard);
     }
     catch (error) {
         throw normalizePinnedPathError(error);

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

@@ -0,0 +1,2 @@
+import { type RootContext } from "./root-context.js";
+export declare function tryMkdirNativeParents(root: RootContext, relativePath: string): boolean;