@openclaw/fs-safe 0.11.0 → 0.13.0

package/dist/root-impl.js

@@ -56,28 +56,32 @@ 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 { assertAsyncDirectoryGuard, createAsyncDirectoryGuard, createNearestExistingDirectoryGuard } from "./directory-guard.js";
+import { assertAsyncDirectoryGuard, assertSyncDirectoryGuard, createAsyncDirectoryGuard, createNearestExistingDirectoryGuard } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
 import { syncDirectoryBestEffort } from "./directory-durability.js";
-import { sameFileIdentity, sameFileIdentityForCleanup, } from "./file-identity.js";
-import { mkdirPathComponentsWithGuards } from "./guarded-mkdir.js";
 import { withAsyncDirectoryGuards } from "./guarded-mutation.js";
-import { assertMutationNotDenied, mergeDenyMutationPolicies, } from "./deny-mutations.js";
-import { resolveOpenedFileRealPathForFd, resolveOpenedFileRealPathForHandle } from "./opened-realpath.js";
-import { openedPathResolutionError, recordExclusiveCreateFailure, recordFileOpenFailure, recordOpenedFileFailure, recordPreOpenFileChange } from "./opened-file-failure.js";
-import { runPinnedWriteHelper, runPinnedWriteWithRenamePolicy, } from "./pinned-write.js";
+import { openLocalFileDescriptor } from "./local-file-descriptor.js";
+import { assertMutationNotDenied, mergeDenyMutationPolicies } from "./deny-mutations.js";
+import { resolveOpenedFileRealPathForFd } from "./opened-realpath.js";
+import { openedPathResolutionError, recordExclusiveCreateFailure, recordOpenedFileFailure } from "./opened-file-failure.js";
+import { runPinnedWriteHelper, runPinnedWriteWithRenamePolicy } from "./pinned-write.js";
+import { preparePinnedWriteMutationAdmission, snapshotPinnedMutationPolicy } from "./pinned-mutation-admission.js";
 import { getNativeBinding } from "./native.js";
 import { validatePinnedOperationPayload } from "./pinned-operation.js";
-import { assertNoPathAliasEscape, PATH_ALIAS_POLICIES } from "./path-policy.js";
-import { assertNoNulPathInput, assertNoUnsafeDeviceReadPath, hasNodeErrorCode, isNotFoundPathError, isPathInside, isSymlinkOpenError, } from "./path.js";
+import { PATH_ALIAS_POLICIES } from "./path-policy.js";
+import { assertNoNulPathInput, hasNodeErrorCode, isNotFoundPathError, isSymlinkOpenError, } from "./path.js";
 import { readOpenedFileSafely } from "./read-opened-file.js";
-import { cleanupPinnedFilePath } from "./replace-file-temp-owner.js";
-import { resolveReadOpenFlags } from "./read-open-flags.js";
+import { cleanupPinnedFilePath, removePathIfIdentityUnchanged } from "./replace-file-temp-owner.js";
 import { realpathSync } from "./realpath.js";
+import { mkdirPathFallback, prepareRootWriteTarget, tryMkdirAtExactParent } from "./root-directory-creation.js";
 import { isNonRegularWriteOpenError, resolveNonblockingWriteFlag } from "./write-open-flags.js";
-import { resolveRootPath } from "./root-path.js";
-import { openRootDirectoryListing, listDirectoryPath, pathStatFromStats } from "./root-directory-list.js";
+import { resolveRootPath, resolveRootPathForRemoval } from "./root-path.js";
+import { RemovalPathReceipts } from "./root-remove-receipt.js";
+import { admitPathInsideRoot } from "./root-boundary.js";
+import { listDirectoryPath, openRootDirectoryListing } from "./root-directory-list.js";
+import { statResolvedPathInRoot } from "./root-path-stat.js";
 import { entriesInRoot } from "./root-entries.js";
+import { assertMoveMutationAllowed } from "./root-move-preflight.js";
 import { assertRootIdentityCurrent, assertValidRootDestinationPath, assertValidRootRelativePath, ensureTrailingSep, expandRelativePathWithHome, resolvePathInRoot, resolveRootContext, rootRelativeReadPath, } from "./root-context.js";
 import { fileNotFoundError, hardlinkedPathNotAllowedError, isAlreadyExistsError, normalizePinnedPathError, normalizePinnedWriteError, outsideWorkspaceError, } from "./root-errors.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
@@ -87,12 +91,19 @@ import { registerTempPathForExit } from "./temp-cleanup.js";
 import { removePathInRootFallback, validateRemoveOptions } from "./root-remove.js";
 import { serializePathWrite } from "./write-queue.js";
 import { verifyAtomicWriteResult } from "./root-write-verification.js";
-import { inheritWriteTargetMode } from "./root-write-mode.js";
-import { inspectFileIdentity } from "./strict-file-identity.js";
+import { assertRootWritePathSelectionSync, assertRootWriteSelectionSync, createRootWriteSelectionForFd, prepareGuardedRootWritePathSelection, resolveGuardedWritePathInRoot, resolveGuardedWriteTargetInRoot, resolvePinnedWriteTargetInRoot, refreshRetainedRootWriteAdmission, refreshRootWritePathSelection, retainRootWriteSelection, takeRootWriteSelection, } from "./root-write-admission.js";
+import { prepareSharedRootWriteTarget } from "./root-write-complete-parent.js";
+import { finishRootFallbackWrite } from "./root-write-publication.js";
+import { assertRootFallbackWritePath, withRootFallbackCompatibilityLock } from "./root-write-compatibility.js";
+import { inspectFileIdentity, inspectFileIdentitySync } from "./strict-file-identity.js";
+import { movePathNoReplaceNative } from "./root-move-noreplace.js";
+import { admitRootReadHandle, inspectOpenedPathIdentitySync } from "./root-read-admission.js";
 import { createCopyPublicationObserver, onCopyPublication } from "./copy-publication.js";
 import { writeAllToFile } from "./write-file-handle.js";
 import { createInputOptions, rethrowCreateInputError, rootWriteInput } from "./root-create-input.js";
 import { assertFinalSymlinkRejected, mutationSymlinkResolution, readSymlinkResolution } from "./root-symlink-policy.js";
+import { assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot } from "./windows-path-alias.js";
+import { resolvePinnedObservedPathInRoot } from "./root-observed-path.js";
 import { mergeReadOptions, readDefaults, } from "./root-options.js";
 import { composeMutationAssertions, MutationAuthorityError, rethrowMutationAuthorityError } from "./mutation-authority.js";
 export { DEFAULT_ROOT_MAX_BYTES } from "./root-options.js";
@@ -103,8 +114,6 @@ function logWarn(message) {
     }
 }
 const SUPPORTS_NOFOLLOW = process.platform !== "win32" && "O_NOFOLLOW" in fsConstants;
-const OPEN_READ_FLAGS = resolveReadOpenFlags();
-const OPEN_READ_FOLLOW_FLAGS = resolveReadOpenFlags({ followSymlinks: true });
 const OPEN_WRITE_EXISTING_FLAGS = fsConstants.O_WRONLY | (SUPPORTS_NOFOLLOW ? fsConstants.O_NOFOLLOW : 0) |
     resolveNonblockingWriteFlag();
 const OPEN_WRITE_CREATE_FLAGS = fsConstants.O_WRONLY |
@@ -128,69 +137,9 @@ function openResult(params) {
     };
 }
 async function openVerifiedLocalFile(filePath, options) {
-    assertNoUnsafeDeviceReadPath(filePath);
     const fsSafeTestHooks = getFsSafeTestHooks();
-    let preOpenStat;
-    let observedBeforeOpen = false;
-    // Reject directories before opening so we never surface EISDIR to callers (e.g. tool
-    // results that get sent to messaging channels). See openclaw/openclaw#31186.
+    const { handle, stat, identity, preOpenStat } = await openLocalFileDescriptor(filePath, options);
     try {
-        preOpenStat = await inspectFileIdentity(async () => {
-            const stat = fsSync.lstatSync(filePath, { bigint: true });
-            observedBeforeOpen = true;
-            if (stat.isSymbolicLink() && options?.symlinks !== "follow-within-root") {
-                throw new FsSafeError("symlink", "symlink not allowed");
-            }
-            if (!stat.isFile() && !stat.isSymbolicLink()) {
-                throw new FsSafeError("not-file", "not a file");
-            }
-            return stat;
-        });
-    }
-    catch (err) {
-        if (err instanceof FsSafeError || observedBeforeOpen) {
-            throw err;
-        }
-        // Only an initial lookup failure falls through; a failed re-inspection aborts.
-    }
-    if (preOpenStat) {
-        await fsSafeTestHooks?.afterPreOpenLstat?.(filePath);
-    }
-    const openFlags = options?.symlinks === "follow-within-root"
-        ? OPEN_READ_FOLLOW_FLAGS
-        : OPEN_READ_FLAGS;
-    await fsSafeTestHooks?.beforeOpen?.(filePath, openFlags);
-    let handle;
-    try {
-        handle = await fs.open(filePath, openFlags).catch((error) => recordFileOpenFailure(isNotFoundPathError(error) ? fileNotFoundError() : error, filePath));
-    }
-    catch (err) {
-        if (isSymlinkOpenError(err)) {
-            throw new FsSafeError("symlink", "symlink open blocked", { cause: err });
-        }
-        // Defensive: if open still throws EISDIR (e.g. race), sanitize so it never leaks.
-        if (hasNodeErrorCode(err, "EISDIR")) {
-            throw new FsSafeError("not-file", "not a file");
-        }
-        throw err;
-    }
-    try {
-        await fsSafeTestHooks?.afterOpen?.(filePath, handle);
-        const stat = fsSync.fstatSync(handle.fd);
-        if (!stat.isFile()) {
-            throw new FsSafeError("not-file", "not a file");
-        }
-        // Keep numeric Stats for the public receipt, never for identity verification.
-        let openedIdentity;
-        const identity = await inspectFileIdentity(async () => (openedIdentity = fsSync.fstatSync(handle.fd, { bigint: true })), preOpenStat && !preOpenStat.isSymbolicLink() ? preOpenStat : undefined).catch(async (error) => {
-            if ([0, 1].includes(stat.nlink)) {
-                await recordPreOpenFileChange(error, handle, filePath, preOpenStat, openedIdentity);
-            }
-            throw error;
-        });
-        if (options?.hardlinks === "reject" && stat.nlink > 1) {
-            throw hardlinkedPathNotAllowedError();
-        }
         const inspectPathIdentity = async (inspect) => {
             try {
                 return await inspectFileIdentity(inspect, identity);
@@ -203,15 +152,7 @@ async function openVerifiedLocalFile(filePath, options) {
                 throw failure;
             }
         };
-        await inspectPathIdentity(async () => {
-            const pathStat = options?.symlinks === "follow-within-root"
-                ? fsSync.statSync(filePath, { bigint: true })
-                : fsSync.lstatSync(filePath, { bigint: true });
-            if (pathStat.isSymbolicLink() && options?.symlinks !== "follow-within-root") {
-                throw new FsSafeError("symlink", "symlink not allowed");
-            }
-            return pathStat;
-        });
+        await inspectPathIdentity(async () => inspectOpenedPathIdentitySync(filePath, options?.symlinks));
         await fsSafeTestHooks?.afterOpenedPathIdentityCheck?.(filePath, handle);
         const resolved = await resolveOpenedFileRealPathForFd(handle.fd, identity, filePath)
             .catch(async (error) => {
@@ -221,6 +162,7 @@ async function openVerifiedLocalFile(filePath, options) {
             throw error;
         });
         const { realPath } = resolved;
+        assertNoWindowsPathAlias(realPath, "filesystem", "resolved file path uses a Windows filesystem namespace alias");
         let resolvedStat = resolved.stat;
         await inspectPathIdentity(async () => {
             // Reuse the post-realpath observation; unknown Windows identities still
@@ -240,12 +182,14 @@ async function openVerifiedLocalFile(filePath, options) {
     }
 }
 export class RootHandle {
+    rootGuard;
     rootIdentity;
     rootDir;
     rootReal;
     rootWithSep;
     defaults;
     constructor(context, defaults = {}) {
+        this.rootGuard = context.rootGuard;
         this.rootIdentity = context.rootIdentity;
         this.rootDir = context.rootDir;
         this.rootReal = context.rootReal;
@@ -255,6 +199,7 @@ export class RootHandle {
     get context() {
         return {
             rootDir: this.rootDir,
+            rootGuard: this.rootGuard,
             rootIdentity: this.rootIdentity,
             rootReal: this.rootReal,
             rootWithSep: this.rootWithSep,
@@ -309,7 +254,7 @@ export class RootHandle {
     async openWritable(relativePath, options = {}) {
         assertValidRootDestinationPath(relativePath);
         const writeMode = options.writeMode ?? "replace";
-        return await openWritableFileInRoot(this.context, {
+        const target = await openWritableFileInRoot(this.context, {
             relativePath,
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
@@ -317,6 +262,7 @@ export class RootHandle {
             append: writeMode === "append",
             truncateExisting: writeMode === "replace",
         }).catch(rethrowMutationAuthorityError);
+        return target.opened;
     }
     async append(relativePath, data, options = {}) {
         assertValidRootDestinationPath(relativePath);
@@ -428,6 +374,7 @@ export class RootHandle {
         assertValidRootDestinationPath(toRelative);
         validatePinnedOperationPayload({ from: fromRelative, to: toRelative });
         const { denyMutations, assertBeforeMutation, mutationSymlinks } = this.mutationOptions(options);
+        const overwrite = options.overwrite ?? false;
         await assertMoveMutationAllowed(this.context, {
             fromRelative,
             toRelative,
@@ -438,7 +385,7 @@ export class RootHandle {
             denyMutations,
             assertBeforeMutation,
             mutationSymlinks,
-            overwrite: options.overwrite ?? false,
+            overwrite,
             toRelative,
         }).catch(rethrowMutationAuthorityError);
     }
@@ -471,31 +418,36 @@ export async function root(rootDir, defaults = {}) {
 export function rootFromDirectoryGuard(guard, defaults = {}) {
     normalizeMaxBytes(defaults.maxBytes);
     return new RootHandle({
-        rootDir: path.resolve(guard.dir),
+        rootDir: resolvePathPreservingWindowsRoot(guard.dir),
+        rootGuard: { dir: guard.realPath, realPath: guard.realPath, stat: guard.stat },
         rootIdentity: { dev: guard.stat.dev, ino: guard.stat.ino },
         rootReal: guard.realPath,
         rootWithSep: ensureTrailingSep(guard.realPath),
     }, defaults);
 }
 async function openFileInRoot(root, params) {
-    const { rootWithSep, resolved } = await resolvePathInRoot(root, params.relativePath, {
+    const { resolved } = await resolvePathInRoot(root, params.relativePath, {
         allowFinalSymlink: true,
         rejectUnsafeDeviceReads: true,
         ...readSymlinkResolution(params.symlinks),
         resolveCanonical: true,
     });
-    const { opened } = await openVerifiedLocalFile(resolved, {
+    const fsSafeTestHooks = getFsSafeTestHooks();
+    if (fsSafeTestHooks?.afterRootReadPathResolution) {
+        await fsSafeTestHooks.afterRootReadPathResolution(resolved);
+    }
+    const { handle, stat, identity } = await openLocalFileDescriptor(resolved, {
         symlinks: params.symlinks,
     });
-    if (params.hardlinks !== "allow" && opened.stat.nlink > 1) {
-        await opened.handle.close().catch(() => { });
-        throw hardlinkedPathNotAllowedError();
-    }
-    if (!isPathInside(rootWithSep, opened.realPath)) {
-        await opened.handle.close().catch(() => { });
-        throw outsideWorkspaceError();
-    }
-    return opened;
+    // 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,
+        hardlinks: params.hardlinks, symlinks: params.symlinks,
+        beforeFinalFence: fsSafeTestHooks?.beforeRootReadFinalFence,
+        afterPathIdentityCheck: fsSafeTestHooks?.afterRootReadFinalPathIdentityCheck,
+    });
+    return openResult(admitted);
 }
 async function readFileInRoot(root, params) {
     const opened = await openFileInRoot(root, params);
@@ -526,8 +478,10 @@ export async function readLocalFileSafely(params) {
     }
 }
 export async function openLocalFileSafely(params) {
-    assertNoNulPathInput(params.filePath, "file path contains a NUL byte");
-    return (await openVerifiedLocalFile(params.filePath)).opened;
+    const filePath = params.filePath;
+    assertNoNulPathInput(filePath, "file path contains a NUL byte");
+    assertNoWindowsPathAlias(filePath, "filesystem", "file path uses a Windows filesystem namespace alias");
+    return (await openVerifiedLocalFile(filePath)).opened;
 }
 function emitWriteBoundaryWarning(reason) {
     logWarn(`security: fs-safe write boundary warning (${reason})`);
@@ -538,56 +492,38 @@ function buildAtomicWriteTempPath(targetPath) {
 function rootWriteQueueKey(root, relativePath) {
     return `${root.rootReal}\0${relativePath}`;
 }
-async function prepareRootWriteTarget(rootReal, targetPath, assertBeforeMutation) {
-    const parentPath = await mkdirPathComponentsWithGuards({
-        rootReal,
-        targetPath: path.dirname(targetPath),
-        assertBeforeMutation,
-    });
-    // Continue through the guarded walk's real parent instead of re-entering
-    // the original path through a symlinked component.
-    return path.join(parentPath, path.basename(targetPath));
-}
-async function resolveGuardedWritePathInRoot(root, params) {
-    const resolvedPath = await resolvePathInRoot(root, params.relativePath, {
-        aliasErrorCode: "path-alias",
-        rejectAmbiguousParents: true,
-        allowFinalSymlink: params.allowFinalSymlink,
-        ...mutationSymlinkResolution(params.mutationSymlinks),
-    });
-    await assertMutationNotDenied(resolvedPath.resolved, params.denyMutations, params.protectDeniedAncestors ? { protectAncestors: true } : undefined);
-    if (await (params.shouldAssertNoPathAlias?.(resolvedPath) ?? true)) {
-        try {
-            await assertNoPathAliasEscape({
-                absolutePath: resolvedPath.resolved,
-                rootPath: resolvedPath.rootReal,
-                boundaryLabel: "root",
-            });
-        }
-        catch (error) {
-            throw new FsSafeError("path-alias", "path alias escape blocked", {
-                cause: error instanceof Error ? error : undefined,
-            });
-        }
-    }
-    return resolvedPath;
-}
 async function openWritableFileInRoot(root, params) {
-    const { rootReal, rootWithSep, resolved } = await resolveGuardedWritePathInRoot(root, {
+    const guardedTarget = params.denyMutations === undefined && params.mutationSymlinks === undefined
+        ? undefined
+        : await resolveGuardedWriteTargetInRoot(root, {
+            relativePath: params.relativePath,
+            denyMutations: params.denyMutations,
+            mutationSymlinks: params.mutationSymlinks,
+        });
+    const { resolved } = guardedTarget?.resolvedPath ?? await resolveGuardedWritePathInRoot(root, {
         relativePath: params.relativePath,
-        denyMutations: params.denyMutations,
-        mutationSymlinks: params.mutationSymlinks,
     });
-    let ioPath = params.mkdir === false
-        ? resolved
-        : await prepareRootWriteTarget(rootReal, resolved, params.assertBeforeMutation);
+    const prepared = guardedTarget ? await prepareSharedRootWriteTarget(root, {
+        relativePath: params.relativePath, guardedTarget, mkdir: params.mkdir,
+        assertBeforeMutation: params.assertBeforeMutation,
+    }) : undefined;
+    const mutationAdmission = prepared?.mutationAdmission;
+    const preparedParent = prepared?.preparedParent;
+    let ioPath = 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;
-        if (!isPathInside(rootWithSep, resolvedRealPath)) {
+        const admittedRealPath = admitPathInsideRoot({
+            rootPath: root.rootReal,
+            candidatePath: resolvedRealPath,
+            rootIdentity: root.rootIdentity,
+        });
+        if (!admittedRealPath) {
             throw outsideWorkspaceError();
         }
-        ioPath = resolvedRealPath;
+        ioPath = admittedRealPath.path;
     }
     catch (err) {
         if (err instanceof FsSafeError) {
@@ -597,13 +533,20 @@ async function openWritableFileInRoot(root, params) {
             throw err;
         }
     }
+    assertRootFallbackWritePath(params.expectedWritePath, ioPath);
     const mode = params.mode ?? 0o600;
     let handle;
     let createdForWrite = false;
+    let writePathSelection = undefined;
     const existingFlags = params.append ? OPEN_APPEND_EXISTING_FLAGS : OPEN_WRITE_EXISTING_FLAGS;
     const createFlags = params.append ? OPEN_APPEND_CREATE_FLAGS : OPEN_WRITE_CREATE_FLAGS;
     try {
+        writePathSelection = guardedTarget
+            ? await prepareGuardedRootWritePathSelection(guardedTarget, ioPath, operationTargetPath, preparedParent)
+            : undefined;
         try {
+            if (writePathSelection)
+                assertRootWritePathSelectionSync(root, writePathSelection);
             handle = await fs.open(ioPath, existingFlags, mode);
         }
         catch (err) {
@@ -613,7 +556,11 @@ async function openWritableFileInRoot(root, params) {
             if (!isNotFoundPathError(err)) {
                 throw err;
             }
+            if (writePathSelection)
+                await refreshRootWritePathSelection(writePathSelection);
             params.assertBeforeMutation?.();
+            if (writePathSelection)
+                assertRootWritePathSelectionSync(root, writePathSelection);
             handle = await fs.open(ioPath, createFlags, mode);
             createdForWrite = true;
         }
@@ -634,49 +581,91 @@ async function openWritableFileInRoot(root, params) {
     let createdIdentity = null;
     try {
         const stat = fsSync.fstatSync(handle.fd);
-        if (createdForWrite) {
-            createdIdentity = stat;
-        }
-        if (!stat.isFile()) {
-            throw new FsSafeError("not-file", "path is not a regular file under root");
-        }
-        if (stat.nlink > 1) {
-            throw hardlinkedPathNotAllowedError();
-        }
-        try {
-            const lstat = fsSync.lstatSync(ioPath);
-            if (lstat.isSymbolicLink() || !lstat.isFile()) {
-                throw new FsSafeError(lstat.isSymbolicLink() ? "symlink" : "not-file", "path is not a regular file under root");
-            }
-            if (!sameFileIdentity(stat, lstat)) {
-                throw new FsSafeError("path-mismatch", "path changed during write");
+        const identity = inspectFileIdentitySync(() => {
+            const observed = fsSync.fstatSync(handle.fd, { bigint: true });
+            if (!observed.isFile()) {
+                throw new FsSafeError("not-file", "path is not a regular file under root");
             }
+            if (observed.nlink > 1n)
+                throw hardlinkedPathNotAllowedError();
+            return observed;
+        });
+        if (createdForWrite)
+            createdIdentity = identity;
+        let observedIoPath = false;
+        try {
+            inspectFileIdentitySync(() => {
+                const lstat = fsSync.lstatSync(ioPath, { bigint: true });
+                observedIoPath = true;
+                if (lstat.isSymbolicLink() || !lstat.isFile()) {
+                    throw new FsSafeError(lstat.isSymbolicLink() ? "symlink" : "not-file", "path is not a regular file under root");
+                }
+                if (lstat.nlink > 1n)
+                    throw hardlinkedPathNotAllowedError();
+                return lstat;
+            }, identity);
         }
         catch (err) {
-            if (!isNotFoundPathError(err)) {
+            if (isNotFoundPathError(err) && !observedIoPath) {
+                // The opened file may have been renamed before its first pathname
+                // observation. The descriptor-bound resolver below must still find it.
+            }
+            else if (err instanceof FsSafeError && err.code === "path-mismatch") {
+                throw new FsSafeError("path-mismatch", "path changed during write", { cause: err });
+            }
+            else {
                 throw err;
             }
         }
-        const realPath = await resolveOpenedFileRealPathForHandle(handle, ioPath);
-        realPathForCleanup = realPath;
-        const realStat = fsSync.statSync(realPath);
-        if (!sameFileIdentity(stat, realStat)) {
-            throw new FsSafeError("path-mismatch", "path mismatch");
+        let realPath = (await resolveOpenedFileRealPathForFd(handle.fd, identity, ioPath)).realPath;
+        assertNoWindowsPathAlias(realPath, "filesystem", "resolved file path uses a Windows filesystem namespace alias");
+        try {
+            inspectFileIdentitySync(() => {
+                const realStat = fsSync.statSync(realPath, { bigint: true });
+                if (!realStat.isFile()) {
+                    throw new FsSafeError("not-file", "path is not a regular file under root");
+                }
+                if (realStat.nlink > 1n)
+                    throw hardlinkedPathNotAllowedError();
+                return realStat;
+            }, identity);
         }
-        if (realStat.nlink > 1) {
-            throw hardlinkedPathNotAllowedError();
+        catch (err) {
+            if (err instanceof FsSafeError && err.code === "path-mismatch") {
+                throw new FsSafeError("path-mismatch", "path mismatch", { cause: err });
+            }
+            throw err;
         }
-        if (!isPathInside(rootWithSep, realPath)) {
+        const admittedRealPath = admitPathInsideRoot({
+            rootPath: root.rootReal,
+            candidatePath: realPath,
+            rootIdentity: root.rootIdentity,
+        });
+        if (!admittedRealPath) {
             throw outsideWorkspaceError();
         }
+        realPath = admittedRealPath.path;
+        realPathForCleanup = realPath;
+        assertRootFallbackWritePath(params.expectedWritePath, realPath);
+        const writeSelection = writePathSelection
+            ? createRootWriteSelectionForFd(writePathSelection, handle.fd)
+            : undefined;
         // Truncate only after boundary and identity checks complete. This avoids
         // irreversible side effects if a symlink target changes before validation.
         if (params.append !== true && params.truncateExisting !== false && !createdForWrite) {
+            if (writeSelection)
+                await refreshRetainedRootWriteAdmission(root, writeSelection, true, handle.fd);
             assertFinalSymlinkRejected(ioPath, params.mutationSymlinks !== undefined);
             params.assertBeforeMutation?.();
+            if (writeSelection)
+                assertRootWriteSelectionSync(root, writeSelection, true, handle.fd);
             await handle.truncate(0);
         }
-        return {
+        if (writeSelection) {
+            await refreshRetainedRootWriteAdmission(root, writeSelection, true, handle.fd);
+            assertRootWriteSelectionSync(root, writeSelection, true, handle.fd);
+        }
+        const result = {
             handle,
             containment: "best-effort",
             createdForWrite,
@@ -684,6 +673,9 @@ async function openWritableFileInRoot(root, params) {
             stat,
             [Symbol.asyncDispose]: () => handle.close().catch(() => undefined),
         };
+        if (writeSelection)
+            retainRootWriteSelection(result, writeSelection);
+        return { opened: result, identity };
     }
     catch (err) {
         const cleanupCreatedPath = createdForWrite && err instanceof FsSafeError;
@@ -698,7 +690,7 @@ async function openWritableFileInRoot(root, params) {
 async function appendFileInRoot(root, params) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const target = await openWritableFileInRoot(root, {
+        const { opened: target, identity } = await openWritableFileInRoot(root, {
             relativePath: params.relativePath,
             mkdir: params.mkdir,
             mode: params.mode,
@@ -713,7 +705,7 @@ async function appendFileInRoot(root, params) {
         const cleanup = __addDisposableResource(env_1, {
             async [Symbol.asyncDispose]() {
                 if (!dispatched && target.createdForWrite) {
-                    await removePathIfIdentityUnchanged(target.realPath, target.stat);
+                    await removePathIfIdentityUnchanged(target.realPath, identity);
                 }
             },
         }, true);
@@ -766,14 +758,16 @@ async function appendFileInRoot(root, params) {
 }
 async function removePathInRoot(root, params) {
     validatePinnedOperationPayload({ relativePath: params.relativePath });
+    const removalReceipts = params.recursive ? undefined : new RemovalPathReceipts();
     const resolved = await resolvePinnedPathInRoot(root, {
         relativePath: params.relativePath,
         denyMutations: params.denyMutations,
         mutationSymlinks: params.mutationSymlinks,
         remove: true,
+        removalReceipts,
     });
     try {
-        await removePathInRootFallback(root, resolved.resolved, params);
+        await removePathInRootFallback(root, resolved.resolved, params, removalReceipts);
     }
     catch (error) {
         if (params.recursive)
@@ -783,9 +777,41 @@ async function removePathInRoot(root, params) {
 }
 async function mkdirPathInRoot(root, params) {
     validatePinnedOperationPayload({ relativePath: params.relativePath });
-    const resolved = await resolvePinnedPathInRoot(root, params);
+    const policy = params.denyMutations === undefined && params.mutationSymlinks === undefined
+        ? undefined
+        : snapshotPinnedMutationPolicy(params.denyMutations, params.mutationSymlinks);
+    const resolveCurrent = policy
+        ? async () => await resolvePinnedPathInRoot(root, {
+            ...params,
+            denyMutations: policy.denyMutations,
+            mutationSymlinks: policy.mutationSymlinks,
+        })
+        : undefined;
+    const resolved = resolveCurrent
+        ? await resolveCurrent()
+        : await resolvePinnedPathInRoot(root, params);
+    const prepared = policy && resolved.relativePosix !== ""
+        ? await preparePinnedWriteMutationAdmission({
+            rootReal: resolved.rootReal,
+            rootWithSep: ensureTrailingSep(resolved.rootReal),
+            rootIdentity: root.rootIdentity,
+            resolvedTargetPath: resolved.resolved,
+            originalPath: params.relativePath,
+            defaultRelativeParentPath: path.posix.dirname(resolved.relativePosix) === "."
+                ? ""
+                : path.posix.dirname(resolved.relativePosix),
+            policy,
+            resolveCurrent: resolveCurrent,
+        })
+        : undefined;
+    if (prepared?.mutationAdmission) {
+        await getFsSafeTestHooks()?.beforePinnedWriteParentAdmission?.(resolved.resolved);
+    }
     try {
-        await mkdirPathFallback(resolved, params.assertBeforeMutation, params.mutationSymlinks !== undefined);
+        if (prepared?.mutationAdmission && params.assertBeforeMutation === undefined &&
+            await tryMkdirAtExactParent(root, resolved.resolved, prepared.mutationAdmission))
+            return;
+        await mkdirPathFallback(root, resolved, params.assertBeforeMutation, policy?.mutationSymlinks !== undefined, prepared?.mutationAdmission);
     }
     catch (error) {
         throw normalizePinnedPathError(error);
@@ -822,6 +848,7 @@ async function commitPinnedWriteInRoot(root, pinned, params, input) {
             input,
             maxBytes: params.maxBytes,
             rootIdentity: root.rootIdentity,
+            mutationAdmission: pinned.mutationAdmission,
             assertBeforeMutation: params.assertBeforeMutation,
             verifyPublished: async (fd, expectedIdentity, parentGuard) => {
                 verifyingPublication = true;
@@ -863,6 +890,7 @@ async function copyFileInRoot(root, params) {
     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,
         }));
@@ -914,6 +942,7 @@ async function copyFileInRoot(root, params) {
                         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) {
@@ -933,61 +962,6 @@ async function copyFileInRoot(root, params) {
         await source.handle.close().catch(() => { });
     }
 }
-async function removePathIfIdentityUnchanged(targetPath, identity) {
-    const parentGuard = await createAsyncDirectoryGuard(path.dirname(targetPath));
-    await withAsyncDirectoryGuards([parentGuard], async () => {
-        const current = fsSync.lstatSync(targetPath);
-        if (current.isSymbolicLink() || !sameFileIdentityForCleanup(current, identity))
-            return;
-        await fs.unlink(targetPath);
-    });
-}
-async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode, denyMutations, overwrite = true, mutationSymlinks) {
-    const { rootReal, rootWithSep, resolved } = await resolveGuardedWritePathInRoot(root, {
-        relativePath,
-        denyMutations,
-        mutationSymlinks,
-    });
-    // resolvePathInRoot already enforces isPathInside, so any actual escape
-    // is rejected upstream.
-    const relativeResolved = path.relative(rootReal, resolved);
-    if (path.isAbsolute(relativeResolved)) {
-        throw outsideWorkspaceError();
-    }
-    const relativePosix = relativeResolved
-        ? relativeResolved.split(path.sep).join(path.posix.sep)
-        : "";
-    const basename = path.posix.basename(relativePosix);
-    if (!basename || basename === "." || basename === "/") {
-        throw new FsSafeError("invalid-path", "invalid target path");
-    }
-    // Exclusive publication cannot inherit an existing file's mode. Keep type
-    // and alias checks, but never open a competing owner's record just to reject it.
-    if (!overwrite) {
-        try {
-            const existing = fsSync.statSync(resolved);
-            if (!existing.isFile())
-                throw new FsSafeError("not-file", "not a file");
-            if (existing.nlink > 1)
-                throw hardlinkedPathNotAllowedError();
-            throw new FsSafeError("already-exists", "file already exists");
-        }
-        catch (error) {
-            if (!isNotFoundPathError(error))
-                throw error;
-        }
-    }
-    const mode = overwrite
-        ? await inheritWriteTargetMode({ targetPath: resolved, rootWithSep, requestedMode })
-        : requestedMode ?? 0o600;
-    return {
-        rootReal,
-        targetPath: resolved,
-        relativeParentPath: path.posix.dirname(relativePosix) === "." ? "" : path.posix.dirname(relativePosix),
-        basename,
-        mode,
-    };
-}
 async function resolvePinnedPathInRoot(root, params) {
     return await resolvePinnedOperationPathInRoot(root, {
         allowRoot: params.allowRoot,
@@ -996,6 +970,7 @@ async function resolvePinnedPathInRoot(root, params) {
         protectDenyMutationAncestors: params.remove === true,
         relativePath: params.relativePath,
         policy: params.remove ? PATH_ALIAS_POLICIES.unlinkTarget : PATH_ALIAS_POLICIES.strict,
+        removalReceipts: params.removalReceipts,
     });
 }
 async function resolvePinnedOperationPathInRoot(root, params) {
@@ -1003,6 +978,7 @@ async function resolvePinnedOperationPathInRoot(root, params) {
         relativePath: params.relativePath,
         policy: params.policy,
         mutationSymlinks: params.mutationSymlinks,
+        removalReceipts: params.removalReceipts,
     });
     const relativeResolved = path.relative(resolved.rootReal, resolved.canonicalPath);
     if ((relativeResolved === "" || relativeResolved === ".") && params.allowRoot === true) {
@@ -1017,30 +993,38 @@ async function resolvePinnedOperationPathInRoot(root, params) {
         throw outsideWorkspaceError();
     }
     const relativePosix = relativeResolved.split(path.sep).join(path.posix.sep);
-    if (!isPathInside(resolved.rootWithSep, resolved.canonicalPath)) {
+    const admittedCanonicalPath = admitPathInsideRoot({
+        rootPath: resolved.rootReal,
+        candidatePath: resolved.canonicalPath,
+        rootIdentity: root.rootIdentity,
+    });
+    if (!admittedCanonicalPath) {
         throw outsideWorkspaceError();
     }
+    resolved.canonicalPath = admittedCanonicalPath.path;
     await assertMutationNotDenied(resolved.canonicalPath, params.denyMutations, {
         protectAncestors: params.protectDenyMutationAncestors,
     });
     return { rootReal: resolved.rootReal, resolved: resolved.canonicalPath, relativePosix };
 }
 async function resolvePinnedRootPathInRoot(root, params) {
-    await assertRootIdentityCurrent(root);
+    await assertRootIdentityCurrent(root, params.removalReceipts?.observeRoot);
     const rootReal = root.rootReal;
     let resolved;
     try {
         const expandedPath = await expandRelativePathWithHome(params.relativePath);
-        resolved = await resolveRootPath({
+        const resolution = {
             absolutePath: path.isAbsolute(expandedPath)
                 ? expandedPath
                 : `${ensureTrailingSep(rootReal)}${expandedPath}`,
             rootPath: rootReal,
             rootCanonicalPath: rootReal,
+            rootIdentity: root.rootIdentity,
             boundaryLabel: "root",
             policy: params.policy,
             ...mutationSymlinkResolution(params.mutationSymlinks),
-        });
+        };
+        resolved = await (params.removalReceipts ? resolveRootPathForRemoval(resolution, params.removalReceipts) : resolveRootPath(resolution));
     }
     catch (err) {
         if (err instanceof FsSafeError && err.code === "symlink")
@@ -1054,44 +1038,20 @@ async function resolvePinnedRootPathInRoot(root, params) {
         canonicalPath: resolved.canonicalPath,
     };
 }
-async function mkdirPathFallback(resolved, assertBeforeMutation, rejectSymlinks = false) {
-    await mkdirPathComponentsWithGuards({
-        rootReal: resolved.rootReal, targetPath: resolved.resolved, assertBeforeMutation,
-        rejectSymlinks,
-        beforeComponent: async (componentPath) => await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("mkdir", componentPath),
-    });
-}
 async function statPathFallback(root, relativePath) {
-    const resolved = await resolvePinnedPathInRoot(root, { relativePath, allowRoot: true });
-    try {
-        const stat = pathStatFromStats(fsSync.lstatSync(resolved.resolved));
-        await assertRootIdentityCurrent(root);
-        return stat;
-    }
-    catch (error) {
-        if (isNotFoundPathError(error)) {
-            throw fileNotFoundError(error instanceof Error ? error : undefined);
-        }
-        throw error;
-    }
+    const initialObservationHook = getFsSafeTestHooks()?.beforeRootStatInitialObservation;
+    const observed = initialObservationHook
+        ? undefined
+        : await resolvePinnedObservedPathInRoot(root, relativePath, "stat");
+    const resolved = observed ??
+        await resolvePinnedPathInRoot(root, { relativePath, allowRoot: true });
+    return await statResolvedPathInRoot(root, resolved.resolved, resolved.receipt);
 }
 async function listPathFallback(root, relativePath, withFileTypes) {
-    const resolved = await resolvePinnedPathInRoot(root, { relativePath, allowRoot: true });
-    return await listDirectoryPath(root, resolved.resolved, withFileTypes);
-}
-async function assertMoveMutationAllowed(root, params) {
-    // Keep this preflight separate from the pinned resolutions in movePathFallback:
-    // mutation denials must take precedence over source alias or identity failures.
-    const source = await resolvePathInRoot(root, params.fromRelative, {
-        aliasErrorCode: "path-alias",
-        allowFinalSymlink: true,
-    });
-    await assertMutationNotDenied(source.resolved, params.denyMutations, { protectAncestors: true });
-    const target = await resolvePathInRoot(root, params.toRelative, {
-        aliasErrorCode: "path-alias",
-        allowFinalSymlink: true,
-    });
-    await assertMutationNotDenied(target.resolved, params.denyMutations, { protectAncestors: true });
+    const observed = await resolvePinnedObservedPathInRoot(root, relativePath, "directory");
+    const resolved = observed ??
+        await resolvePinnedPathInRoot(root, { relativePath, allowRoot: true });
+    return await listDirectoryPath(root, resolved.resolved, withFileTypes, resolved.receipt);
 }
 async function movePathFallback(root, params) {
     const source = await resolvePathInRoot(root, params.fromRelative, {
@@ -1100,11 +1060,12 @@ async function movePathFallback(root, params) {
         ...mutationSymlinkResolution(params.mutationSymlinks),
     });
     await assertMutationNotDenied(source.resolved, params.denyMutations, { protectAncestors: true });
-    await resolvePinnedRootPathInRoot(root, {
+    const pinnedSource = await resolvePinnedRootPathInRoot(root, {
         relativePath: params.fromRelative,
         policy: PATH_ALIAS_POLICIES.strict,
         mutationSymlinks: params.mutationSymlinks,
     });
+    let pinnedTarget;
     const target = await resolveGuardedWritePathInRoot(root, {
         relativePath: params.toRelative,
         denyMutations: params.denyMutations,
@@ -1112,10 +1073,12 @@ async function movePathFallback(root, params) {
         allowFinalSymlink: true,
         protectDeniedAncestors: true,
         shouldAssertNoPathAlias: async (resolvedTarget) => {
-            await resolvePinnedRootPathInRoot(root, {
+            pinnedTarget = await resolvePinnedRootPathInRoot(root, {
                 relativePath: params.toRelative,
                 policy: PATH_ALIAS_POLICIES.unlinkTarget,
             });
+            if (!params.overwrite)
+                return true;
             let targetStat;
             try {
                 targetStat = fsSync.lstatSync(resolvedTarget.resolved);
@@ -1146,18 +1109,16 @@ async function movePathFallback(root, params) {
         throw new FsSafeError("invalid-path", "directory moves require overwrite: true");
     }
     if (!params.overwrite) {
-        try {
-            fsSync.lstatSync(target.resolved);
-            throw new FsSafeError("already-exists", "destination exists");
-        }
-        catch (error) {
-            if (error instanceof FsSafeError) {
-                throw error;
-            }
-            if (!isNotFoundPathError(error)) {
-                throw error;
-            }
+        if (!pinnedTarget) {
+            throw new FsSafeError("path-mismatch", "destination admission was not completed");
         }
+        await movePathNoReplaceNative(root, params, {
+            sourcePath: source.resolved,
+            sourceParentPath: path.dirname(pinnedSource.canonicalPath),
+            targetPath: target.resolved,
+            targetParentPath: path.dirname(pinnedTarget.canonicalPath),
+        });
+        return;
     }
     const sourceParentGuard = await createAsyncDirectoryGuard(path.dirname(source.resolved));
     const targetParentGuard = await createNearestExistingDirectoryGuard(target.rootReal, path.dirname(target.resolved));
@@ -1190,11 +1151,22 @@ async function movePathFallback(root, params) {
     }
 }
 async function writeFileFallback(root, params) {
+    if (params.renameIdentity !== "verify-content-with-lock")
+        return await writeFileFallbackUnlocked(root, params);
+    const policy = snapshotPinnedMutationPolicy(params.denyMutations, params.mutationSymlinks);
+    if (policy)
+        params = { ...params, ...policy };
+    const { rootReal, resolved } = await resolveGuardedWritePathInRoot(root, params);
+    await withRootFallbackCompatibilityLock({
+        rootPath: rootReal, rootIdentity: root.rootIdentity, targetPath: resolved, assertBeforeMutation: params.assertBeforeMutation,
+    }, async ({ targetPath, ...binding }) => await writeFileFallbackUnlocked(root, { ...params, ...binding }, targetPath));
+}
+async function writeFileFallbackUnlocked(root, params, expectedWritePath) {
     if (params.overwrite === false) {
-        await writeMissingFileFallback(root, params);
+        await writeMissingFileFallback(root, params, expectedWritePath);
         return;
     }
-    const target = await openWritableFileInRoot(root, {
+    const { opened: target, identity: targetIdentity } = await openWritableFileInRoot(root, {
         relativePath: params.relativePath,
         mkdir: params.mkdir,
         // Private, writable placeholder: Windows cannot rename over a read-only file.
@@ -1203,13 +1175,21 @@ async function writeFileFallback(root, params) {
         assertBeforeMutation: params.assertBeforeMutation,
         mutationSymlinks: params.mutationSymlinks,
         truncateExisting: false,
+        expectedWritePath,
     });
-    const destinationPath = target.realPath;
+    const policyEnabled = params.denyMutations !== undefined || params.mutationSymlinks !== undefined;
+    const retainedSelection = policyEnabled ? takeRootWriteSelection(target) : undefined;
+    const destinationPath = retainedSelection?.selectedPath ?? target.realPath;
     const mode = params.mode ?? (target.stat.mode & 0o777);
-    const destinationGuard = await createAsyncDirectoryGuard(path.dirname(destinationPath), { bigint: true }).catch(async (error) => {
+    if (policyEnabled && !retainedSelection) {
         await target.handle.close().catch(() => undefined);
-        throw error;
-    });
+        throw new FsSafeError("path-mismatch", "write admission state was not retained");
+    }
+    const destinationGuard = retainedSelection?.parentGuard ??
+        await createAsyncDirectoryGuard(path.dirname(destinationPath), { bigint: true }).catch(async (error) => {
+            await target.handle.close().catch(() => undefined);
+            throw error;
+        });
     let tempPath = null;
     let unregisterTempPath = null;
     let writtenHandle;
@@ -1218,9 +1198,15 @@ async function writeFileFallback(root, params) {
     let published = false;
     try {
         if (target.createdForWrite)
-            placeholderIdentity = fsSync.fstatSync(target.handle.fd, { bigint: true });
+            placeholderIdentity = targetIdentity;
         tempPath = buildAtomicWriteTempPath(destinationPath);
+        if (retainedSelection) {
+            await refreshRetainedRootWriteAdmission(root, retainedSelection, true, target.handle.fd);
+        }
         params.assertBeforeMutation?.();
+        if (retainedSelection) {
+            assertRootWriteSelectionSync(root, retainedSelection, true, target.handle.fd);
+        }
         writtenHandle = await fs.open(tempPath, OPEN_WRITE_CREATE_FLAGS, 0o600);
         writtenIdentity = fsSync.fstatSync(writtenHandle.fd, { bigint: true });
         unregisterTempPath = registerTempPathForExit(tempPath, { identity: writtenIdentity, singleLinkFile: true });
@@ -1244,41 +1230,27 @@ async function writeFileFallback(root, params) {
             }
             // Windows cannot replace a destination while its old handle remains open.
             await target.handle.close();
+            if (retainedSelection) {
+                await refreshRetainedRootWriteAdmission(root, retainedSelection, !target.createdForWrite);
+            }
             assertFinalSymlinkRejected(destinationPath, params.mutationSymlinks !== undefined);
             params.assertBeforeMutation?.();
+            if (retainedSelection) {
+                assertRootWriteSelectionSync(root, retainedSelection, !target.createdForWrite);
+            }
             await fs.rename(commitTempPath, destinationPath);
             tempPath = null;
             published = true;
         });
         unregisterTempPath();
         unregisterTempPath = null;
-        // Final mode via the retained handle after publication, as the native writer does.
-        try {
-            await writtenHandle.chmod(mode);
-        }
-        catch (error) {
-            await cleanupPinnedFilePath({
-                pathname: destinationPath, handle: writtenHandle, identity: writtenIdentity, parentGuard: destinationGuard,
-            });
-            throw error;
-        }
-        if (params.durable !== false)
-            await writtenHandle.sync();
-        try {
-            await verifyAtomicWriteResult({
-                root,
-                targetPath: destinationPath,
-                expectedIdentity: writtenIdentity,
-                fd: writtenHandle.fd,
-                parentGuard: destinationGuard,
-            });
-        }
-        catch (err) {
-            emitWriteBoundaryWarning(`post-write verification failed: ${String(err)}`);
-            throw err;
-        }
-        if (params.durable !== false)
-            await syncDirectoryBestEffort(path.dirname(destinationPath));
+        await finishRootFallbackWrite({
+            root, targetPath: destinationPath, handle: writtenHandle, identity: writtenIdentity,
+            parentGuard: destinationGuard, mode, options: params,
+            // Read/write access is needed to sync the accepted destination on Windows.
+            openForCompatibility: () => openVerifiedLocalFile(destinationPath, { hardlinks: "reject", readWrite: true }),
+            onVerificationFailure: err => emitWriteBoundaryWarning(`post-write verification failed: ${String(err)}`),
+        });
     }
     finally {
         if (!published && target.createdForWrite) {
@@ -1296,16 +1268,31 @@ async function writeFileFallback(root, params) {
         unregisterTempPath?.();
     }
 }
-async function writeMissingFileFallback(root, params) {
-    const { rootReal, resolved } = await resolveGuardedWritePathInRoot(root, {
+async function writeMissingFileFallback(root, params, expectedWritePath) {
+    const guardedTarget = params.denyMutations === undefined && params.mutationSymlinks === undefined
+        ? undefined
+        : await resolveGuardedWriteTargetInRoot(root, {
+            relativePath: params.relativePath,
+            denyMutations: params.denyMutations,
+            mutationSymlinks: params.mutationSymlinks,
+        });
+    const { resolved } = guardedTarget?.resolvedPath ?? await resolveGuardedWritePathInRoot(root, {
         relativePath: params.relativePath,
-        denyMutations: params.denyMutations,
-        mutationSymlinks: params.mutationSymlinks,
     });
-    const targetPath = params.mkdir === false
-        ? resolved
-        : await prepareRootWriteTarget(rootReal, resolved, params.assertBeforeMutation);
-    const parentGuard = await createAsyncDirectoryGuard(path.dirname(targetPath), { bigint: true });
+    const prepared = guardedTarget ? await prepareSharedRootWriteTarget(root, {
+        relativePath: params.relativePath, guardedTarget, mkdir: params.mkdir,
+        assertBeforeMutation: params.assertBeforeMutation,
+    }) : undefined;
+    const mutationAdmission = prepared?.mutationAdmission;
+    const preparedParent = prepared?.preparedParent;
+    const targetPath = prepared?.targetPath ?? (params.mkdir === false ? resolved :
+        await prepareRootWriteTarget(root, resolved, params.assertBeforeMutation));
+    assertRootFallbackWritePath(expectedWritePath, targetPath);
+    const pathSelection = guardedTarget
+        ? await prepareGuardedRootWritePathSelection(guardedTarget, targetPath, targetPath, preparedParent)
+        : undefined;
+    const parentGuard = pathSelection?.parentGuard ??
+        await createAsyncDirectoryGuard(path.dirname(targetPath), { bigint: true });
     let created = false;
     let createdIdentity;
     let writtenHandle;
@@ -1314,6 +1301,8 @@ async function writeMissingFileFallback(root, params) {
         const { handle, writtenStat } = await withAsyncDirectoryGuards([parentGuard], async () => {
             assertFinalSymlinkRejected(targetPath, params.mutationSymlinks !== undefined);
             params.assertBeforeMutation?.();
+            if (mutationAdmission)
+                assertSyncDirectoryGuard(parentGuard);
             const handle = await fs.open(targetPath, OPEN_WRITE_CREATE_FLAGS, params.mode ?? 0o600).catch((error) => recordExclusiveCreateFailure(error, targetPath));
             writtenHandle = handle;
             created = true;
@@ -1324,6 +1313,8 @@ async function writeMissingFileFallback(root, params) {
                 assertBeforeMutation: () => {
                     assertFinalSymlinkRejected(targetPath, params.mutationSymlinks !== undefined);
                     params.assertBeforeMutation?.();
+                    if (mutationAdmission)
+                        assertSyncDirectoryGuard(parentGuard);
                 },
             });
             if (params.durable !== false)