@openclaw/openshell-sandbox 2026.9.5 → 2026.9.7

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

@@ -1,17 +1,21 @@
+import type { DirectoryObservationGuard } from "./directory-guard.js";
+import { type RootPathObservationReceipt } from "./root-path.js";
 import type { RootDirectoryListing, RootDirectoryListingOptions } from "./root-directory-list.js";
 import type { PathStat } from "./types.js";
-export type RootWalkSymlinkPolicy = "skip" | "follow-within-root";
+export type RootWalkSymlinkPolicy = "skip" | "follow-within-root" | "include";
+type LegacyRootWalkSymlinkPolicy = Exclude<RootWalkSymlinkPolicy, "include">;
 export type RootWalkLimitBehavior = "truncate" | "throw";
 export type RootWalkDirectoryErrorBehavior = "throw" | "skip-and-report";
 export type RootWalkEntryFilterResult = "include" | "skip" | "skip-subtree";
-export type RootWalkDataEntryKind = "file" | "directory" | "other";
-export type RootWalkEntryKind = RootWalkDataEntryKind | "directory-error" | "truncated";
-export type RootWalkDataEntry = {
+export type RootWalkDataEntryKind<Policy extends RootWalkSymlinkPolicy = LegacyRootWalkSymlinkPolicy> = "file" | "directory" | "other" | ("include" extends Policy ? "symlink" : never);
+export type RootWalkEntryKind<Policy extends RootWalkSymlinkPolicy = LegacyRootWalkSymlinkPolicy> = RootWalkDataEntryKind<Policy> | "directory-error" | "truncated";
+type WalkEntryOfKind<Kind extends RootWalkDataEntryKind<RootWalkSymlinkPolicy>> = {
     relativePath: string;
-    kind: RootWalkDataEntryKind;
+    kind: Kind;
     size: number;
 };
-export type RootWalkEntry = RootWalkDataEntry | {
+export type RootWalkDataEntry<Policy extends RootWalkSymlinkPolicy = LegacyRootWalkSymlinkPolicy> = WalkEntryOfKind<RootWalkDataEntryKind> | ("include" extends Policy ? WalkEntryOfKind<"symlink"> : never);
+export type RootWalkEntry<Policy extends RootWalkSymlinkPolicy = LegacyRootWalkSymlinkPolicy> = RootWalkDataEntry<Policy> | {
     relativePath: string;
     kind: "truncated";
     size: 0;
@@ -21,22 +25,24 @@ export type RootWalkEntry = RootWalkDataEntry | {
     size: 0;
     error: unknown;
 };
-export type RootWalkEntryFilter = (entry: RootWalkDataEntry) => RootWalkEntryFilterResult;
-export type RootWalkOptions = {
+export type RootWalkEntryFilter<Policy extends RootWalkSymlinkPolicy = LegacyRootWalkSymlinkPolicy> = (entry: RootWalkDataEntry<Policy>) => RootWalkEntryFilterResult | Promise<RootWalkEntryFilterResult>;
+export type RootWalkOptions<Policy extends RootWalkSymlinkPolicy = LegacyRootWalkSymlinkPolicy> = {
     maxDepth?: number;
     maxEntries?: number;
     order?: "sorted" | "filesystem";
-    symlinkPolicy: RootWalkSymlinkPolicy;
+    symlinkPolicy: Policy;
     signal?: AbortSignal;
     limitBehavior?: RootWalkLimitBehavior;
-    entryFilter?: RootWalkEntryFilter;
+    entryFilter?: RootWalkEntryFilter<Policy>;
     onDirectoryError?: RootWalkDirectoryErrorBehavior;
 };
+type AnyRootWalkOptions = RootWalkOptions | RootWalkOptions<"include"> | RootWalkOptions<RootWalkSymlinkPolicy>;
+type AnyRootWalkEntry = RootWalkEntry<RootWalkSymlinkPolicy>;
 type RootWalkCapability = {
     rootReal: string;
+    observeRoot(): Promise<DirectoryObservationGuard | undefined>;
     stat(relativePath: string): Promise<PathStat>;
-    list(relativePath: string, options: RootDirectoryListingOptions): Promise<RootDirectoryListing>;
+    list(relativePath: string, options: RootDirectoryListingOptions, receipt?: RootPathObservationReceipt): Promise<RootDirectoryListing>;
 };
-export declare function walkRoot(root: RootWalkCapability, relativePath: string, options: RootWalkOptions): AsyncGenerator<RootWalkEntry>;
+export declare function walkRoot(root: RootWalkCapability, relativePath: string, options: AnyRootWalkOptions): AsyncGenerator<AnyRootWalkEntry>;
 export {};
-//# sourceMappingURL=root-walk.d.ts.map

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

@@ -1,7 +1,14 @@
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
-import { resolveRootPath } from "./root-path.js";
+import { expandRelativePathWithHome } from "./root-context.js";
+import { resolveRootPath, resolveRootPathWithObservation, ROOT_PATH_ALIAS_POLICIES, RootPathObservationError, } from "./root-path.js";
 import { createSuppressedError } from "./suppressed-error.js";
+function filterEntry(options, entry) {
+    if (entry.kind === "symlink") {
+        return options.symlinkPolicy === "include" ? options.entryFilter?.(entry) ?? "include" : "skip";
+    }
+    return options.entryFilter?.(entry) ?? "include";
+}
 function validateBudget(name, value) {
     if (value === undefined)
         return Number.POSITIVE_INFINITY;
@@ -23,7 +30,7 @@ function limitEntry(relativePath) {
     return { relativePath, kind: "truncated", size: 0 };
 }
 export async function* walkRoot(root, relativePath, options) {
-    if (!["skip", "follow-within-root"].includes(options.symlinkPolicy)) {
+    if (!["skip", "follow-within-root", "include"].includes(options.symlinkPolicy)) {
         throw new TypeError(`invalid root walk symlink policy: ${String(options.symlinkPolicy)}`);
     }
     if (options.order !== undefined && !["sorted", "filesystem"].includes(options.order)) {
@@ -61,19 +68,50 @@ export async function* walkRoot(root, relativePath, options) {
             throw error;
         return { relativePath: directory, kind: "directory-error", size: 0, error };
     };
-    async function* visit(directory, depth) {
+    async function* visit(directory, depth, admittedChildPath) {
         options.signal?.throwIfAborted();
         let listing;
+        let canonicalDirectory;
         try {
-            const resolvedDirectory = await resolveRootPath({
-                absolutePath: path.resolve(root.rootReal, directory),
+            const expandedDirectory = depth === 0 ? await expandRelativePathWithHome(directory) : directory;
+            const noFollowChildSymlinks = depth > 0 && options.symlinkPolicy !== "follow-within-root";
+            const includeChild = depth > 0 && options.symlinkPolicy === "include";
+            const resolution = {
+                absolutePath: admittedChildPath ?? path.resolve(root.rootReal, expandedDirectory),
                 rootPath: root.rootReal,
                 rootCanonicalPath: root.rootReal,
                 boundaryLabel: "root walk",
-            });
+                policy: noFollowChildSymlinks ? ROOT_PATH_ALIAS_POLICIES.unlinkTarget : undefined,
+            };
+            let receipt;
+            let resolvedDirectory;
+            if (includeChild) {
+                const rootGuard = await root.observeRoot();
+                if (!rootGuard) {
+                    throw new FsSafeError("helper-unavailable", "root walk requires an exact directory observation");
+                }
+                const observed = await resolveRootPathWithObservation({
+                    ...resolution,
+                    rootIdentity: rootGuard.identity,
+                }, { kind: "directory", rootGuard });
+                resolvedDirectory = observed.resolved;
+                receipt = observed.receipt;
+            }
+            else {
+                resolvedDirectory = await resolveRootPath(resolution);
+            }
+            if (noFollowChildSymlinks && resolvedDirectory.kind === "symlink") {
+                if (options.symlinkPolicy === "skip")
+                    return;
+                throw new FsSafeError("path-mismatch", `root walk directory became a symlink: ${directory}`);
+            }
             if (!resolvedDirectory.exists || resolvedDirectory.kind !== "directory") {
                 throw new FsSafeError("not-file", `root walk path is not a directory: ${directory || "."}`);
             }
+            if (includeChild && (!receipt || receipt.directoryGuard.realPath !== resolvedDirectory.canonicalPath)) {
+                throw new FsSafeError("path-mismatch", "root walk directory observation was not retained");
+            }
+            canonicalDirectory = resolvedDirectory.canonicalPath;
             if (visitedDirectories.has(resolvedDirectory.canonicalPath)) {
                 return;
             }
@@ -83,15 +121,18 @@ export async function* walkRoot(root, relativePath, options) {
                 .relative(root.rootReal, resolvedDirectory.canonicalPath)
                 .split(path.sep)
                 .join(path.posix.sep);
-            listing = await root.list(listingDirectory, {
+            if (depth === 0 && expandedDirectory !== directory)
+                directory = listingDirectory;
+            // Resolved filesystem names are literal, not caller home-directory shorthand.
+            listing = await root.list(`./${listingDirectory}`, {
                 order: options.order ?? "sorted",
                 signal: options.signal,
                 snapshot: maxEntries === Number.POSITIVE_INFINITY,
                 admitEntry,
-            });
+            }, receipt);
         }
         catch (error) {
-            yield onDirectoryError(directory, error);
+            yield onDirectoryError(directory, error instanceof RootPathObservationError ? error.error : error);
             return;
         }
         // A thrown undefined still needs to be retained if closing also fails.
@@ -122,10 +163,9 @@ export async function* walkRoot(root, relativePath, options) {
                 const entry = next.entry;
                 let kind = entryKind(entry);
                 let size = entry.size;
-                if (kind === "symlink") {
-                    if (options.symlinkPolicy === "skip") {
-                        continue;
-                    }
+                if (kind === "symlink" && options.symlinkPolicy === "skip")
+                    continue;
+                if (kind === "symlink" && options.symlinkPolicy === "follow-within-root") {
                     const resolved = await resolveRootPath({
                         absolutePath: path.resolve(root.rootReal, child),
                         rootPath: root.rootReal,
@@ -135,12 +175,23 @@ export async function* walkRoot(root, relativePath, options) {
                     if (!resolved.exists) {
                         continue;
                     }
-                    const target = await root.stat(path.relative(root.rootReal, resolved.canonicalPath));
+                    const target = await root.stat(`./${path.relative(root.rootReal, resolved.canonicalPath)}`);
                     kind = target.isDirectory ? "directory" : target.isFile ? "file" : "other";
                     size = target.size;
                 }
                 const walkEntry = { relativePath: child, kind, size };
-                const filterResult = options.entryFilter?.(walkEntry) ?? "include";
+                let filterResult = filterEntry(options, walkEntry);
+                if (typeof filterResult !== "string") {
+                    filterResult = (await filterResult) ?? "include";
+                    options.signal?.throwIfAborted();
+                    try {
+                        await listing.assertCurrent();
+                    }
+                    catch (error) {
+                        yield onDirectoryError(directory, error);
+                        return;
+                    }
+                }
                 if (!["include", "skip", "skip-subtree"].includes(filterResult)) {
                     throw new TypeError(`invalid root walk entryFilter result: ${String(filterResult)}`);
                 }
@@ -157,7 +208,7 @@ export async function* walkRoot(root, relativePath, options) {
                     yield onLimit(child);
                     return;
                 }
-                yield* visit(child, depth + 1);
+                yield* visit(child, depth + 1, options.symlinkPolicy === "include" ? path.join(canonicalDirectory, name) : undefined);
                 if (truncated)
                     return;
             }

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

@@ -1,7 +1,7 @@
 import type { BigIntStats } from "node:fs";
 import { type DenyMutationPolicy } from "./deny-mutations.js";
 import { type AnyAsyncDirectoryGuard } from "./directory-guard.js";
-import type { PinnedWriteMutationAdmission } from "./pinned-write.js";
+import type { PinnedWriteMutationAdmission } from "./pinned-write-types.js";
 import type { RootContext } from "./root-context.js";
 import { resolvePathInRoot } from "./root-context.js";
 import { type MutationSymlinkPolicy } from "./root-symlink-policy.js";
@@ -34,9 +34,7 @@ export type RootWritePathSelection = Readonly<{
 export type RetainedRootWriteSelection = RootWritePathSelection & Readonly<{
     identity: Readonly<Pick<BigIntStats, "dev" | "ino">>;
 }>;
-export declare function retainRootWriteSelection(owner: object, selection: RetainedRootWriteSelection): void;
 export declare function createRootWriteSelectionForFd(selection: RootWritePathSelection, fd: number): RetainedRootWriteSelection;
-export declare function takeRootWriteSelection(owner: object): RetainedRootWriteSelection | undefined;
 export declare function assertRootWritePathSelectionSync(root: RootContext, selection: RootWritePathSelection): void;
 export declare function assertRootWriteSelectionSync(root: RootContext, selection: RetainedRootWriteSelection, verifyBinding: boolean, fd?: number): void;
 export declare function prepareRootWritePathSelection(params: Omit<RootWritePathSelection, "parentGuard"> & Readonly<{
@@ -65,4 +63,3 @@ export declare function resolveGuardedWritePathInRoot(root: RootContext, params:
 export declare function resolveGuardedWriteTargetInRoot(root: RootContext, params: GuardedWritePathOptions): Promise<GuardedRootWriteTarget>;
 export declare function resolvePinnedWriteTargetInRoot(root: RootContext, relativePath: string, requestedMode?: number, denyMutations?: DenyMutationPolicy, overwrite?: boolean, mutationSymlinks?: MutationSymlinkPolicy): Promise<PinnedWriteTarget>;
 export {};
-//# sourceMappingURL=root-write-admission.d.ts.map

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

@@ -6,19 +6,15 @@ import { FsSafeError } from "./errors.js";
 import { isNotFoundPathError } from "./path.js";
 import { assertNoPathAliasEscape } from "./path-policy.js";
 import { preparePinnedWriteMutationAdmission, snapshotPinnedMutationPolicy, } from "./pinned-mutation-admission.js";
-import { admitPathInsideRoot } from "./root-boundary.js";
+import { admitPathInsideRoot, sameNormalizedPathSpelling } from "./root-boundary.js";
 import { resolvePathInRoot } from "./root-context.js";
-import { hardlinkedPathNotAllowedError, outsideWorkspaceError } from "./root-errors.js";
+import { errorCauseOptions, hardlinkedPathNotAllowedError, outsideWorkspaceError } from "./root-errors.js";
 import { inheritWriteTargetMode } from "./root-write-mode.js";
 import { mutationSymlinkResolution, } from "./root-symlink-policy.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { realpathSync } from "./realpath.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
-import { assertPreparedRootWriteParentCurrent, } from "./root-write-complete-parent.js";
-const retainedRootWriteSelections = new WeakMap();
-export function retainRootWriteSelection(owner, selection) {
-    retainedRootWriteSelections.set(owner, selection);
-}
+import { assertPreparedRootWriteParentCurrent, writeSelectionChanged, } from "./root-write-complete-parent.js";
 export function createRootWriteSelectionForFd(selection, fd) {
     const stat = inspectFileIdentitySync(() => fsSync.fstatSync(fd, { bigint: true }));
     return Object.freeze({
@@ -26,16 +22,6 @@ export function createRootWriteSelectionForFd(selection, fd) {
         identity: Object.freeze({ dev: stat.dev, ino: stat.ino }),
     });
 }
-export function takeRootWriteSelection(owner) {
-    const selection = retainedRootWriteSelections.get(owner);
-    retainedRootWriteSelections.delete(owner);
-    return selection;
-}
-function writeSelectionChanged(cause) {
-    return new FsSafeError("path-mismatch", "write target changed during operation", {
-        cause: cause instanceof Error ? cause : undefined,
-    });
-}
 function inspectRegularSelectionPath(pathname, expected, follow) {
     let observed;
     try {
@@ -55,11 +41,6 @@ function inspectRegularSelectionPath(pathname, expected, follow) {
         throw hardlinkedPathNotAllowedError();
     return observed;
 }
-function sameNormalizedPathSpelling(left, right) {
-    // Windows can expose case-sensitive directories, so normalize separators
-    // and roots without using path.relative's case-folding comparison.
-    return path.resolve(left) === path.resolve(right);
-}
 function inspectSelectionBindingSync(root, selection, fd) {
     inspectRegularSelectionPath(selection.selectedPath, selection.identity, false);
     if (!sameNormalizedPathSpelling(selection.operationTargetPath, selection.selectedPath)) {
@@ -200,9 +181,7 @@ export async function resolveGuardedWritePathInRoot(root, params) {
             });
         }
         catch (error) {
-            throw new FsSafeError("path-alias", "path alias escape blocked", {
-                cause: error instanceof Error ? error : undefined,
-            });
+            throw new FsSafeError("path-alias", "path alias escape blocked", errorCauseOptions(error));
         }
     }
     return resolvedPath;
@@ -222,7 +201,6 @@ export async function resolveGuardedWriteTargetInRoot(root, params) {
     const relativeParent = path.relative(resolvedPath.rootReal, path.dirname(resolvedPath.resolved));
     const prepared = await preparePinnedWriteMutationAdmission({
         rootReal: resolvedPath.rootReal,
-        rootWithSep: resolvedPath.rootWithSep,
         rootIdentity: root.rootIdentity,
         resolvedTargetPath: resolvedPath.resolved,
         originalPath: params.relativePath,
@@ -309,7 +287,6 @@ export async function resolvePinnedWriteTargetInRoot(root, relativePath, request
     if (policy) {
         ({ relativeParentPath, mutationAdmission } = await preparePinnedWriteMutationAdmission({
             rootReal,
-            rootWithSep,
             rootIdentity: root.rootIdentity,
             resolvedTargetPath: resolved,
             originalPath: relativePath,

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

@@ -1,5 +1,4 @@
-import { type RootBoundaryIdentity } from "./root-boundary.js";
-export declare function assertRootFallbackWritePath(expected: string | undefined, actual: string): void;
+import type { RootBoundaryIdentity } from "./root-boundary.js";
 export declare function withRootFallbackCompatibilityLock<T>(params: {
     rootPath: string;
     targetPath: string;
@@ -10,4 +9,3 @@ export declare function withRootFallbackCompatibilityLock<T>(params: {
     relativePath: string;
     assertBeforeMutation: () => void;
 }) => Promise<T>): Promise<T>;
-//# sourceMappingURL=root-write-compatibility.d.ts.map

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

@@ -1,74 +1,23 @@
-import fs from "node:fs";
-import path from "node:path";
-import { FsSafeError } from "./errors.js";
-import { isNotFoundPathError } from "./path.js";
-import { admitPathInsideRoot } from "./root-boundary.js";
 import { withPinnedWriteRenameIdentityLock } from "./pinned-write.js";
-import { realpathSync } from "./realpath.js";
+import { createRootWriteLockBinding } from "./root-write-lock-binding.js";
 import { serializePathWrite } from "./write-queue.js";
-function unsupportedSpelling() {
-    return new FsSafeError("path-alias", "Windows compatibility writes require lower-case ASCII destination components");
-}
-// The caller first applies the Root's ordinary path and mutation policies. This
-// extra admission rule is deliberately narrower than general Windows filenames:
-// the existing lock protocol has no portable case/Unicode equivalence key for a
-// missing name. Do not guess one, or switch keys when a placeholder appears.
-function effectiveDestination(rootPath, targetPath, rootIdentity) {
-    let effective;
+export async function withRootFallbackCompatibilityLock(params, run) {
+    const binding = createRootWriteLockBinding(params);
+    const callerAssertion = params.assertBeforeMutation;
+    const assertBeforeMutation = callerAssertion === undefined
+        ? binding.assertCurrent
+        : () => { callerAssertion.call(params); binding.assertCurrent(); };
+    // Keep the alias queue and historical lock hash before admitting the writer.
     try {
-        effective = realpathSync.native(targetPath);
-    }
-    catch (error) {
-        if (!isNotFoundPathError(error))
-            throw error;
-        let cursor = targetPath;
-        const missing = [];
-        for (;;) {
-            try {
-                fs.lstatSync(cursor);
-                break;
-            }
-            catch (error) {
-                if (!isNotFoundPathError(error) || cursor === rootPath)
-                    throw error;
-                const parent = path.dirname(cursor);
-                if (parent === cursor)
-                    throw error;
-                missing.unshift(path.basename(cursor));
-                cursor = parent;
-            }
-        }
-        // An existing dangling link must fail resolution, not become a missing
-        // lexical component. Keep the fallback bounded by the retained Root.
-        effective = path.join(realpathSync.native(cursor), ...missing);
+        return await serializePathWrite(binding.targetPath, async () => await withPinnedWriteRenameIdentityLock({
+            rootPath: params.rootPath, targetPath: binding.targetPath, relativeTargetPath: binding.relativeLockPath,
+        }, async () => await run({
+            targetPath: binding.targetPath,
+            relativePath: binding.relativePath,
+            assertBeforeMutation,
+        })));
     }
-    const admitted = admitPathInsideRoot({ rootPath, candidatePath: effective, rootIdentity });
-    if (!admitted)
-        throw unsupportedSpelling();
-    const relative = admitted.relativePath;
-    if (!relative || !relative.split(path.sep).every(component => /^[a-z0-9._-]+$/.test(component) && !component.endsWith(".")))
-        throw unsupportedSpelling();
-    return admitted.path;
-}
-export function assertRootFallbackWritePath(expected, actual) {
-    if (expected !== undefined && actual !== expected) {
-        throw new FsSafeError("path-mismatch", "compatibility write destination changed after lock selection");
+    finally {
+        binding.dispose();
     }
 }
-export async function withRootFallbackCompatibilityLock(params, run) {
-    const targetPath = effectiveDestination(params.rootPath, params.targetPath, params.rootIdentity);
-    const relativePath = path.relative(params.rootPath, targetPath).split(path.sep).join("/");
-    const assertCurrent = () => assertRootFallbackWritePath(targetPath, effectiveDestination(params.rootPath, targetPath, params.rootIdentity));
-    // Sidecars are reentrant within one manager; aliases also need the same local
-    // queue before acquisition. The outer Root queue uses the caller's spelling.
-    return await serializePathWrite(targetPath, async () => await withPinnedWriteRenameIdentityLock({
-        rootPath: params.rootPath, targetPath, relativeTargetPath: relativePath,
-    }, async () => {
-        // The guarded open resolves again under the lock; each mutation rechecks
-        // below. Lock selection is never reused as post-lock filesystem authority.
-        return await run({
-            targetPath, relativePath,
-            assertBeforeMutation: () => { params.assertBeforeMutation?.(); assertCurrent(); },
-        });
-    }));
-}

package/node_modules/@openclaw/fs-safe/dist/root-write-complete-parent.d.ts

@@ -1,5 +1,6 @@
 import type { BigIntStats } from "node:fs";
 import { type AsyncDirectoryGuard } from "./directory-guard.js";
+import { FsSafeError } from "./errors.js";
 import type { RootContext } from "./root-context.js";
 import type { GuardedRootWriteTarget } from "./root-write-admission.js";
 type PreparedWriteTargetObservation = Readonly<{
@@ -36,7 +37,7 @@ export type SharedRootWriteTarget = Readonly<{
     mutationAdmission: GuardedRootWriteTarget["mutationAdmission"];
     preparedParent?: PreparedRootWriteParent;
 }>;
+export declare function writeSelectionChanged(cause?: unknown): FsSafeError;
 export declare function assertPreparedRootWriteParentCurrent(prepared: PreparedRootWriteParent, verifyTarget?: boolean): void;
 export declare function prepareSharedRootWriteTarget(root: RootContext, params: SharedRootWriteTargetParams): Promise<SharedRootWriteTarget>;
 export {};
-//# sourceMappingURL=root-write-complete-parent.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/root-write-complete-parent.js

@@ -1,45 +1,29 @@
 import fsSync from "node:fs";
 import path from "node:path";
 import { assertDirectoryIdentitySync, createAsyncDirectoryGuard, inspectDirectoryIdentitySync, } from "./directory-guard.js";
-import { WINDOWS_RESERVED_DEVICE_NAMES } from "./device-path.js";
 import { FsSafeError } from "./errors.js";
 import { getFsSafeNativeConfig } from "./native-config.js";
 import { hasNodeErrorCode } from "./path.js";
 import { realpathSync } from "./realpath.js";
-import { admitPathInsideRoot } from "./root-boundary.js";
+import { admitPathInsideRoot, sameNormalizedPathSpelling } from "./root-boundary.js";
+import { ordinaryWindowsSegments } from "./pinned-mutation-shared-route.js";
 import { prepareRootWriteTarget } from "./root-directory-creation.js";
-import { isSafePathSegment } from "./safe-path-segment.js";
+import { errorCauseOptions } from "./root-errors.js";
+import { canReuseParentWithMutationAssertion } from "./root-write-lock-binding.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
-function writeSelectionChanged(cause) {
-    return new FsSafeError("path-mismatch", "write target changed during operation", {
-        cause: cause instanceof Error ? cause : undefined,
-    });
-}
-function sameNormalizedPathSpelling(left, right) {
-    // Windows can expose case-sensitive directories, so normalize separators
-    // and roots without using path.relative's case-folding comparison.
-    return path.resolve(left) === path.resolve(right);
-}
-function windowsReservedDeviceSegment(segment) {
-    const extension = segment.indexOf(".");
-    const stem = segment.slice(0, extension < 0 ? segment.length : extension).toUpperCase();
-    return WINDOWS_RESERVED_DEVICE_NAMES.has(stem);
+export function writeSelectionChanged(cause) {
+    return new FsSafeError("path-mismatch", "write target changed during operation", errorCauseOptions(cause));
 }
 function ordinarySharedWriteRoute(root, relativePath, operationTargetPath) {
     if (process.versions.bun || relativePath === "" || relativePath.startsWith("~") ||
         relativePath.includes("\0") || path.isAbsolute(relativePath))
         return false;
-    const separator = process.platform === "win32" ? "\\" : "/";
-    const alternateSeparator = process.platform === "win32" ? "/" : "\\";
-    if (relativePath.includes(alternateSeparator))
-        return false;
-    const segments = relativePath.split(separator);
-    if (segments.some((segment) => segment === "" || segment === "." || segment === ".." ||
-        (process.platform === "win32" &&
-            (!isSafePathSegment(segment, { allowDotPrefix: true }) ||
-                segment.endsWith(".") || segment.endsWith(" ") ||
-                windowsReservedDeviceSegment(segment)))))
+    if (process.platform === "win32") {
+        if (!ordinaryWindowsSegments(relativePath))
+            return false;
+    }
+    else if (relativePath.includes("\\") || relativePath.split("/").some(segment => segment === "" || segment === "." || segment === ".."))
         return false;
     const routed = path.resolve(root.rootReal, relativePath);
     const admitted = admitPathInsideRoot({
@@ -185,7 +169,8 @@ export async function prepareSharedRootWriteTarget(root, params) {
     if (mutationAdmission)
         await beforeParentAdmission?.(resolvedPath);
     const preparedParent = params.mkdir !== false &&
-        params.assertBeforeMutation === undefined && beforeParentAdmission === undefined
+        canReuseParentWithMutationAssertion(params.assertBeforeMutation, root.rootReal, guardedTarget.targetPath) &&
+        beforeParentAdmission === undefined
         ? await prepareCompleteRootWriteParent(root, guardedTarget, params.relativePath)
         : undefined;
     const targetPath = params.mkdir === false

package/node_modules/@openclaw/fs-safe/dist/root-write-lock-binding.d.ts

@@ -0,0 +1,14 @@
+import { type RootBoundaryIdentity } from "./root-boundary.js";
+export declare function canReuseParentWithMutationAssertion(assertion: (() => void) | undefined, rootPath: string, targetPath: string): boolean;
+export declare function assertRootFallbackWritePath(expected: string | undefined, actual: string): void;
+export declare function createRootWriteLockBinding(params: Readonly<{
+    rootPath: string;
+    targetPath: string;
+    rootIdentity?: RootBoundaryIdentity;
+}>): Readonly<{
+    targetPath: string;
+    relativePath: string;
+    relativeLockPath: string;
+    assertCurrent: () => void;
+    dispose(): void;
+}>;