@openclaw/fs-safe 0.11.0 → 0.12.0

package/dist/root-impl.js

@@ -69,15 +69,17 @@ import { runPinnedWriteHelper, runPinnedWriteWithRenamePolicy, } from "./pinned-
 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 { assertNoNulPathInput, assertNoUnsafeDeviceReadPath, 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 { realpathSync } from "./realpath.js";
 import { isNonRegularWriteOpenError, resolveNonblockingWriteFlag } from "./write-open-flags.js";
 import { resolveRootPath } from "./root-path.js";
+import { admitPathInsideRoot } from "./root-boundary.js";
 import { openRootDirectoryListing, listDirectoryPath, pathStatFromStats } from "./root-directory-list.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";
@@ -478,7 +480,7 @@ export function rootFromDirectoryGuard(guard, defaults = {}) {
     }, 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),
@@ -491,10 +493,16 @@ async function openFileInRoot(root, params) {
         await opened.handle.close().catch(() => { });
         throw hardlinkedPathNotAllowedError();
     }
-    if (!isPathInside(rootWithSep, opened.realPath)) {
+    const admittedRealPath = admitPathInsideRoot({
+        rootPath: root.rootReal,
+        candidatePath: opened.realPath,
+        rootIdentity: root.rootIdentity,
+    });
+    if (!admittedRealPath) {
         await opened.handle.close().catch(() => { });
         throw outsideWorkspaceError();
     }
+    opened.realPath = admittedRealPath.path;
     return opened;
 }
 async function readFileInRoot(root, params) {
@@ -538,9 +546,10 @@ function buildAtomicWriteTempPath(targetPath) {
 function rootWriteQueueKey(root, relativePath) {
     return `${root.rootReal}\0${relativePath}`;
 }
-async function prepareRootWriteTarget(rootReal, targetPath, assertBeforeMutation) {
+async function prepareRootWriteTarget(root, targetPath, assertBeforeMutation) {
     const parentPath = await mkdirPathComponentsWithGuards({
-        rootReal,
+        rootReal: root.rootReal,
+        rootIdentity: root.rootIdentity,
         targetPath: path.dirname(targetPath),
         assertBeforeMutation,
     });
@@ -573,21 +582,26 @@ async function resolveGuardedWritePathInRoot(root, params) {
     return resolvedPath;
 }
 async function openWritableFileInRoot(root, params) {
-    const { rootReal, rootWithSep, resolved } = await resolveGuardedWritePathInRoot(root, {
+    const { resolved } = await resolveGuardedWritePathInRoot(root, {
         relativePath: params.relativePath,
         denyMutations: params.denyMutations,
         mutationSymlinks: params.mutationSymlinks,
     });
     let ioPath = params.mkdir === false
         ? resolved
-        : await prepareRootWriteTarget(rootReal, resolved, params.assertBeforeMutation);
+        : await prepareRootWriteTarget(root, resolved, params.assertBeforeMutation);
     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) {
@@ -657,8 +671,7 @@ async function openWritableFileInRoot(root, params) {
                 throw err;
             }
         }
-        const realPath = await resolveOpenedFileRealPathForHandle(handle, ioPath);
-        realPathForCleanup = realPath;
+        let realPath = await resolveOpenedFileRealPathForHandle(handle, ioPath);
         const realStat = fsSync.statSync(realPath);
         if (!sameFileIdentity(stat, realStat)) {
             throw new FsSafeError("path-mismatch", "path mismatch");
@@ -666,9 +679,16 @@ async function openWritableFileInRoot(root, params) {
         if (realStat.nlink > 1) {
             throw hardlinkedPathNotAllowedError();
         }
-        if (!isPathInside(rootWithSep, realPath)) {
+        const admittedRealPath = admitPathInsideRoot({
+            rootPath: root.rootReal,
+            candidatePath: realPath,
+            rootIdentity: root.rootIdentity,
+        });
+        if (!admittedRealPath) {
             throw outsideWorkspaceError();
         }
+        realPath = admittedRealPath.path;
+        realPathForCleanup = realPath;
         // 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) {
@@ -785,7 +805,7 @@ async function mkdirPathInRoot(root, params) {
     validatePinnedOperationPayload({ relativePath: params.relativePath });
     const resolved = await resolvePinnedPathInRoot(root, params);
     try {
-        await mkdirPathFallback(resolved, params.assertBeforeMutation, params.mutationSymlinks !== undefined);
+        await mkdirPathFallback(root, resolved, params.assertBeforeMutation, params.mutationSymlinks !== undefined);
     }
     catch (error) {
         throw normalizePinnedPathError(error);
@@ -948,8 +968,8 @@ async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode,
         denyMutations,
         mutationSymlinks,
     });
-    // resolvePathInRoot already enforces isPathInside, so any actual escape
-    // is rejected upstream.
+    // resolvePathInRoot already admits and rebases the path at the exact Root
+    // boundary, so any actual escape is rejected upstream.
     const relativeResolved = path.relative(rootReal, resolved);
     if (path.isAbsolute(relativeResolved)) {
         throw outsideWorkspaceError();
@@ -978,7 +998,12 @@ async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode,
         }
     }
     const mode = overwrite
-        ? await inheritWriteTargetMode({ targetPath: resolved, rootWithSep, requestedMode })
+        ? await inheritWriteTargetMode({
+            targetPath: resolved,
+            rootWithSep,
+            rootIdentity: root.rootIdentity,
+            requestedMode,
+        })
         : requestedMode ?? 0o600;
     return {
         rootReal,
@@ -1017,9 +1042,15 @@ 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,
     });
@@ -1037,6 +1068,7 @@ async function resolvePinnedRootPathInRoot(root, params) {
                 : `${ensureTrailingSep(rootReal)}${expandedPath}`,
             rootPath: rootReal,
             rootCanonicalPath: rootReal,
+            rootIdentity: root.rootIdentity,
             boundaryLabel: "root",
             policy: params.policy,
             ...mutationSymlinkResolution(params.mutationSymlinks),
@@ -1054,9 +1086,10 @@ async function resolvePinnedRootPathInRoot(root, params) {
         canonicalPath: resolved.canonicalPath,
     };
 }
-async function mkdirPathFallback(resolved, assertBeforeMutation, rejectSymlinks = false) {
+async function mkdirPathFallback(root, resolved, assertBeforeMutation, rejectSymlinks = false) {
     await mkdirPathComponentsWithGuards({
         rootReal: resolved.rootReal, targetPath: resolved.resolved, assertBeforeMutation,
+        rootIdentity: root.rootIdentity,
         rejectSymlinks,
         beforeComponent: async (componentPath) => await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("mkdir", componentPath),
     });
@@ -1079,20 +1112,6 @@ 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 });
-}
 async function movePathFallback(root, params) {
     const source = await resolvePathInRoot(root, params.fromRelative, {
         aliasErrorCode: "path-alias",
@@ -1297,14 +1316,14 @@ async function writeFileFallback(root, params) {
     }
 }
 async function writeMissingFileFallback(root, params) {
-    const { rootReal, resolved } = await resolveGuardedWritePathInRoot(root, {
+    const { resolved } = await resolveGuardedWritePathInRoot(root, {
         relativePath: params.relativePath,
         denyMutations: params.denyMutations,
         mutationSymlinks: params.mutationSymlinks,
     });
     const targetPath = params.mkdir === false
         ? resolved
-        : await prepareRootWriteTarget(rootReal, resolved, params.assertBeforeMutation);
+        : await prepareRootWriteTarget(root, resolved, params.assertBeforeMutation);
     const parentGuard = await createAsyncDirectoryGuard(path.dirname(targetPath), { bigint: true });
     let created = false;
     let createdIdentity;

package/dist/root-move-preflight.d.ts

@@ -0,0 +1,8 @@
+import { type DenyMutationPolicy } from "./deny-mutations.js";
+import { type RootContext } from "./root-context.js";
+export declare function assertMoveMutationAllowed(root: RootContext, params: {
+    fromRelative: string;
+    toRelative: string;
+    denyMutations?: DenyMutationPolicy;
+}): Promise<void>;
+//# sourceMappingURL=root-move-preflight.d.ts.map

package/dist/root-move-preflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-move-preflight.d.ts","sourceRoot":"","sources":["../src/root-move-preflight.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAExE,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE;IACN,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,kBAAkB,CAAC;CACpC,GACA,OAAO,CAAC,IAAI,CAAC,CAaf"}

package/dist/root-move-preflight.js

@@ -0,0 +1,16 @@
+import { assertMutationNotDenied, } from "./deny-mutations.js";
+import { resolvePathInRoot } from "./root-context.js";
+export 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 });
+}

package/dist/root-path-existing.d.ts

@@ -1,7 +1,9 @@
+import { type RootBoundaryIdentity } from "./root-boundary.js";
 export declare function absolutePathWithRawSegments(candidate: string): string;
 export declare function rawPathRelativeToCanonicalRoot(candidate: string, rootCanonicalPath: string, options?: {
     rejectSymlinks?: boolean;
     rejectFinalSymlink?: boolean;
+    rootIdentity?: RootBoundaryIdentity;
 }): string | undefined;
 export declare function resolvePathViaExistingAncestor(targetPath: string): Promise<string>;
 export declare function resolvePathViaExistingAncestorSync(targetPath: string): string;

package/dist/root-path-existing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root-path-existing.d.ts","sourceRoot":"","sources":["../src/root-path-existing.ts"],"names":[],"mappings":"AAOA,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAKrE;AAED,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,MAAM,EACzB,OAAO,GAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAC;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAAO,GACvE,MAAM,GAAG,SAAS,CAuCpB;AAkBD,wBAAsB,8BAA8B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA0BxF;AAED,wBAAgB,kCAAkC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CA0B7E"}
+{"version":3,"file":"root-path-existing.d.ts","sourceRoot":"","sources":["../src/root-path-existing.ts"],"names":[],"mappings":"AAMA,OAAO,EAAuB,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAEpF,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAKrE;AAED,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,MAAM,EACzB,OAAO,GAAE;IACP,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,YAAY,CAAC,EAAE,oBAAoB,CAAC;CAChC,GACL,MAAM,GAAG,SAAS,CA8CpB;AAkBD,wBAAsB,8BAA8B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA0BxF;AAED,wBAAgB,kCAAkC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CA0B7E"}

package/dist/root-path-existing.js

@@ -4,6 +4,7 @@ import { FsSafeError } from "./errors.js";
 import { formatErrorDetail } from "./error-detail.js";
 import { isNotFoundPathError, isPathInside } from "./path.js";
 import { realpathSync } from "./realpath.js";
+import { admitPathInsideRoot } from "./root-boundary.js";
 export function absolutePathWithRawSegments(candidate) {
     if (path.isAbsolute(candidate))
         return candidate;
@@ -19,6 +20,7 @@ export function rawPathRelativeToCanonicalRoot(candidate, rootCanonicalPath, opt
     const finalComponentIndex = segments.findLastIndex(segment => segment !== "" && segment !== ".");
     let prefix = filesystemRoot;
     let traversedSymlink = false;
+    const identityCache = process.platform === "win32" ? new Map() : undefined;
     for (let index = 0; index < segments.length; index += 1) {
         prefix += `${prefix.endsWith(path.sep) ? "" : path.sep}${segments[index]}`;
         let canonical;
@@ -47,12 +49,18 @@ export function rawPathRelativeToCanonicalRoot(candidate, rootCanonicalPath, opt
                 return undefined;
             continue;
         }
-        if (!isPathInside(rootCanonicalPath, canonical))
+        const admitted = admitPathInsideRoot({
+            rootPath: rootCanonicalPath,
+            candidatePath: canonical,
+            rootIdentity: options.rootIdentity,
+            identityCache,
+        });
+        if (!admitted)
             continue;
         if (options.rejectSymlinks && traversedSymlink) {
             throw new FsSafeError("symlink", "symlink path component not allowed");
         }
-        return [path.relative(rootCanonicalPath, canonical), ...segments.slice(index + 1)]
+        return [admitted.relativePath, ...segments.slice(index + 1)]
             .filter(Boolean).join(path.sep);
     }
     return undefined;

package/dist/root-path.d.ts

@@ -1,3 +1,4 @@
+import { type RootBoundaryIdentity } from "./root-boundary.js";
 export { resolvePathViaExistingAncestorSync } from "./root-path-existing.js";
 type RootPathIntent = "read" | "write" | "create" | "delete" | "stat";
 export type RootPathAliasPolicy = {
@@ -25,6 +26,7 @@ type ResolveRootPathParams = {
     rejectUnresolvedSymlinks?: boolean;
     skipLexicalRootCheck?: boolean;
     rootCanonicalPath?: string;
+    rootIdentity?: RootBoundaryIdentity;
 };
 type ResolvedRootPathKind = "missing" | "file" | "directory" | "symlink" | "other";
 export type ResolvedRootPath = {

package/dist/root-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root-path.d.ts","sourceRoot":"","sources":["../src/root-path.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAE7E,KAAK,cAAc,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEtE,MAAM,MAAM,mBAAmB,GAAG;IAChC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,wBAAwB;aACnC,MAAM;;;;aAIN,YAAY;;;;CAIJ,CAAC;AAEX,KAAK,qBAAqB,GAAG;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,KAAK,oBAAoB,GAAG,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEnF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,oBAAoB,CAAC;CAC5B,CAAC;AAEF,wBAAsB,eAAe,CACnC,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AAeD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CAMnF"}
+{"version":3,"file":"root-path.d.ts","sourceRoot":"","sources":["../src/root-path.ts"],"names":[],"mappings":"AAeA,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAE7E,KAAK,cAAc,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEtE,MAAM,MAAM,mBAAmB,GAAG;IAChC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,wBAAwB;aACnC,MAAM;;;;aAIN,YAAY;;;;CAIJ,CAAC;AAEX,KAAK,qBAAqB,GAAG;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,oBAAoB,CAAC;CACrC,CAAC;AAEF,KAAK,oBAAoB,GAAG,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEnF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,oBAAoB,CAAC;CAC5B,CAAC;AAEF,wBAAsB,eAAe,CACnC,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AAcD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CAMnF"}

package/dist/root-path.js

@@ -2,8 +2,9 @@ import fs from "node:fs";
 import path from "node:path";
 import { formatErrorDetail, shortPath } from "./error-detail.js";
 import { FsSafeError } from "./errors.js";
-import { assertNoNulPathInput, isNotFoundPathError, isPathInside, isPathRelativeEscape, } from "./path.js";
+import { assertNoNulPathInput, isNotFoundPathError, isPathRelativeEscape, } from "./path.js";
 import { absolutePathWithRawSegments, rawPathRelativeToCanonicalRoot, resolvePathViaExistingAncestor, resolvePathViaExistingAncestorSync, } from "./root-path-existing.js";
+import { admitPathInsideRoot, } from "./root-boundary.js";
 import { resolveSymlinkHopPath, resolveSymlinkHopPathSync } from "./root-path-symlink.js";
 import { assertNoDriveRelativePathSegments } from "./safe-path-segment.js";
 export { resolvePathViaExistingAncestorSync } from "./root-path-existing.js";
@@ -29,11 +30,10 @@ async function resolveRootPathInternal(params) {
     assertValidRootPathInputs(params);
     params = { ...params, absolutePath: absolutePathWithRawSegments(params.absolutePath) };
     const rootPath = path.resolve(params.rootPath);
-    const absolutePath = path.resolve(params.absolutePath);
     const rootCanonicalPath = params.rootCanonicalPath
         ? path.resolve(params.rootCanonicalPath)
         : await resolvePathViaExistingAncestor(rootPath);
-    return resolveRootPathLexicalAsync(prepareRootTraversal(params, rootPath, rootCanonicalPath, absolutePath));
+    return resolveRootPathLexicalAsync(prepareRootTraversal(params, rootPath, rootCanonicalPath));
 }
 export function resolveRootPathSync(params) {
     try {
@@ -47,25 +47,38 @@ function resolveRootPathSyncInternal(params) {
     assertValidRootPathInputs(params);
     params = { ...params, absolutePath: absolutePathWithRawSegments(params.absolutePath) };
     const rootPath = path.resolve(params.rootPath);
-    const absolutePath = path.resolve(params.absolutePath);
     const rootCanonicalPath = params.rootCanonicalPath
         ? path.resolve(params.rootCanonicalPath)
         : resolvePathViaExistingAncestorSync(rootPath);
-    return resolveRootPathLexicalSync(prepareRootTraversal(params, rootPath, rootCanonicalPath, absolutePath));
+    return resolveRootPathLexicalSync(prepareRootTraversal(params, rootPath, rootCanonicalPath));
 }
-function prepareRootTraversal(params, rootPath, rootCanonicalPath, absolutePath) {
+function prepareRootTraversal(params, rootPath, rootCanonicalPath) {
+    const callerAbsolutePath = path.resolve(params.absolutePath);
     let raw = params.absolutePath;
-    if (rawPathRelativeToRoot(rootPath, raw) === undefined) {
-        const relative = rawPathRelativeToRoot(rootCanonicalPath, raw)
+    let trustedAbsolutePath = false;
+    const direct = admitRawPathInsideRoot(rootPath, raw, params.rootIdentity);
+    if (direct) {
+        raw = direct.path;
+        trustedAbsolutePath = direct.admission === "identity";
+    }
+    else {
+        const canonical = admitRawPathInsideRoot(rootCanonicalPath, raw, params.rootIdentity);
+        const relative = canonical?.relativePath
             ?? rawPathRelativeToCanonicalRoot(raw, rootCanonicalPath, params);
         if (relative === undefined) {
             throw pathEscapeError({ rootPath, absolutePath: raw, boundaryLabel: params.boundaryLabel });
         }
-        raw = `${rootPath}${path.sep}${relative}`;
+        trustedAbsolutePath = canonical?.admission === "identity";
+        raw = relative === "" ? rootPath : `${rootPath}${path.sep}${relative}`;
     }
     return {
         params: raw === params.absolutePath ? params : { ...params, absolutePath: raw },
-        rootPath, rootCanonicalPath, absolutePath,
+        rootPath,
+        rootCanonicalPath,
+        // Preserve the caller-spelling receipt for ordinary aliases. Only a
+        // Windows case-fold admission must return the identity-gated Root spelling,
+        // because downstream I/O must not reuse the ambiguous caller prefix.
+        absolutePath: trustedAbsolutePath ? path.resolve(raw) : callerAbsolutePath,
     };
 }
 function sanitizeRootPathError(error) {
@@ -93,7 +106,7 @@ function assertNoEmbeddedDriveRelativeSegment(filePath, label) {
 }
 function createLexicalTraversalState(params) {
     const rawAbsolutePath = params.params.absolutePath;
-    const relative = rawPathRelativeToRoot(params.rootPath, rawAbsolutePath);
+    const relative = admitRawPathInsideRoot(params.rootPath, rawAbsolutePath, params.params.rootIdentity)?.relativePath;
     if (relative === undefined)
         throw new Error("Path traversal must begin at the root");
     const segments = splitTraversalSegments(relative);
@@ -124,7 +137,7 @@ function splitTraversalSegments(value) {
         segments.push(".");
     return segments;
 }
-function rawPathRelativeToRoot(rootPath, candidatePath) {
+function admitRawPathInsideRoot(rootPath, candidatePath, rootIdentity) {
     if (!path.isAbsolute(candidatePath)) {
         return undefined;
     }
@@ -132,30 +145,36 @@ function rawPathRelativeToRoot(rootPath, candidatePath) {
     const candidate = process.platform === "win32"
         ? candidatePath.replaceAll("/", path.sep)
         : candidatePath;
+    if (process.platform === "win32") {
+        return admitPathInsideRoot({ rootPath: root, candidatePath: candidate, rootIdentity });
+    }
     if (candidate === root) {
-        return "";
+        return { admission: "exact", path: candidate, relativePath: "" };
     }
     const rootWithSep = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
     const candidatePrefix = candidate.slice(0, rootWithSep.length);
-    const prefixMatches = process.platform === "win32"
-        ? candidatePrefix.toLowerCase() === rootWithSep.toLowerCase()
-        : candidatePrefix === rootWithSep;
-    return prefixMatches ? candidate.slice(rootWithSep.length) : undefined;
+    return candidatePrefix === rootWithSep
+        ? {
+            admission: "exact",
+            path: candidate,
+            relativePath: candidate.slice(rootWithSep.length),
+        }
+        : undefined;
 }
 function assertLexicalCursorInsideBoundary(context, candidatePath) {
-    assertInsideBoundary({
+    return assertInsideBoundary({
         boundaryLabel: context.resolveParams.boundaryLabel,
         rootCanonicalPath: context.rootCanonicalPath,
+        rootIdentity: context.resolveParams.rootIdentity,
         candidatePath,
         absolutePath: context.absolutePath,
     });
 }
 function advanceCanonicalCursorForSegment(context, segment) {
-    context.state.canonicalCursor = path.resolve(context.state.canonicalCursor, segment);
-    assertLexicalCursorInsideBoundary(context, context.state.canonicalCursor);
+    context.state.canonicalCursor = assertLexicalCursorInsideBoundary(context, path.resolve(context.state.canonicalCursor, segment));
 }
 function finalizeLexicalResolution(context, kind) {
-    assertLexicalCursorInsideBoundary(context, context.state.canonicalCursor);
+    context.state.canonicalCursor = assertLexicalCursorInsideBoundary(context, context.state.canonicalCursor);
     return buildResolvedRootPath({
         absolutePath: context.absolutePath,
         canonicalPath: context.state.canonicalCursor,
@@ -181,15 +200,19 @@ function lexicalStatDisposition(params) {
     return params.allowFinalSymlink && params.isLast ? "break" : "resolve-link";
 }
 function applyResolvedSymlinkHop(context, linkCanonical) {
-    if (!isPathInside(context.rootCanonicalPath, linkCanonical)) {
+    let admitted;
+    try {
+        admitted = assertLexicalCursorInsideBoundary(context, linkCanonical);
+    }
+    catch {
         throw symlinkEscapeError({
             boundaryLabel: context.resolveParams.boundaryLabel,
             rootCanonicalPath: context.rootCanonicalPath,
             symlinkPath: context.state.lexicalCursor,
         });
     }
-    context.state.canonicalCursor = linkCanonical;
-    context.state.lexicalCursor = linkCanonical;
+    context.state.canonicalCursor = admitted;
+    context.state.lexicalCursor = admitted;
 }
 function applyParentTraversalStep(context) {
     context.state.lexicalCursor = path.resolve(context.state.lexicalCursor, "..");
@@ -380,8 +403,13 @@ function relativeInsideRoot(rootPath, targetPath) {
     return relative;
 }
 function assertInsideBoundary(params) {
-    if (isPathInside(params.rootCanonicalPath, params.candidatePath)) {
-        return;
+    const admitted = admitPathInsideRoot({
+        rootPath: params.rootCanonicalPath,
+        candidatePath: params.candidatePath,
+        rootIdentity: params.rootIdentity,
+    });
+    if (admitted) {
+        return admitted.path;
     }
     throw new Error(`Path resolves outside ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.absolutePath)}`);
 }

package/dist/root-paths.d.ts

@@ -1,4 +1,5 @@
 import { FsSafeError } from "./errors.js";
+import { type ResolvePathWithinRootParams } from "./path-scope-lexical.js";
 type InvalidPathResult = {
     ok: false;
     error: string;
@@ -50,12 +51,7 @@ export type PathScope = {
         mode?: number;
     }): Promise<DirectoryResult>;
 };
-export declare function resolvePathWithinRoot(params: {
-    rootDir: string;
-    requestedPath: string;
-    scopeLabel: string;
-    defaultFileName?: string;
-}): {
+export declare function resolvePathWithinRoot(params: ResolvePathWithinRootParams): {
     ok: true;
     path: string;
 } | {

package/dist/root-paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root-paths.d.ts","sourceRoot":"","sources":["../src/root-paths.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"root-paths.d.ts","sourceRoot":"","sources":["../src/root-paths.ts"],"names":[],"mappings":"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"}

package/dist/root-paths.js

@@ -6,19 +6,13 @@ import { FsSafeError } from "./errors.js";
 import { assertNoNulPathInput, hasNodeErrorCode, isNodeError, isNotFoundPathError, isPathInside, isPathRelativeEscape, } from "./path.js";
 import { root as openRoot } from "./root.js";
 import { realpathSync } from "./realpath.js";
+import { resolvePathWithinNormalizedRoot } from "./path-scope-lexical.js";
 function invalidPath(scopeLabel) {
     return {
         ok: false,
         error: `Invalid path: must stay within ${scopeLabel}`,
     };
 }
-function pathStaysWithinRoot(rootDir, candidatePath) {
-    if (process.platform !== "win32") {
-        return candidatePath !== rootDir && isPathInside(rootDir, candidatePath);
-    }
-    const relative = path.relative(rootDir, candidatePath);
-    return Boolean(relative) && !isPathRelativeEscape(relative);
-}
 async function resolveRealPathIfExists(targetPath) {
     try {
         return realpathSync.native(targetPath);
@@ -62,23 +56,7 @@ async function validateCanonicalPathWithinRoot(params) {
     }
 }
 export function resolvePathWithinRoot(params) {
-    const root = path.resolve(params.rootDir);
-    const raw = params.requestedPath.trim();
-    if (!raw) {
-        if (!params.defaultFileName) {
-            return { ok: false, error: "path is required" };
-        }
-        const defaultPath = path.resolve(root, params.defaultFileName);
-        if (!pathStaysWithinRoot(root, defaultPath)) {
-            return { ok: false, error: `Invalid path: must stay within ${params.scopeLabel}` };
-        }
-        return { ok: true, path: defaultPath };
-    }
-    const resolved = path.resolve(root, raw);
-    if (!pathStaysWithinRoot(root, resolved)) {
-        return { ok: false, error: `Invalid path: must stay within ${params.scopeLabel}` };
-    }
-    return { ok: true, path: resolved };
+    return resolvePathWithinNormalizedRoot(params, path.resolve(params.rootDir));
 }
 export async function resolveWritablePathWithinRoot(params) {
     const lexical = resolvePathWithinRoot(params);
@@ -233,12 +211,22 @@ export async function ensureDirectoryWithinRoot(params) {
 }
 export function resolvePathsWithinRoot(params) {
     const resolvedPaths = [];
+    let previousRootDir;
+    let previousResolvedRoot = "";
     for (const raw of params.requestedPaths) {
-        const pathResult = resolvePathWithinRoot({
+        const request = {
             rootDir: params.rootDir,
             requestedPath: raw,
             scopeLabel: params.scopeLabel,
-        });
+        };
+        // Relative roots may follow cwd changes made by an input iterator or getter.
+        const resolvedRoot = process.platform !== "win32" && typeof request.rootDir === "string" &&
+            request.rootDir.startsWith("/") && request.rootDir === previousRootDir
+            ? previousResolvedRoot
+            : path.resolve(request.rootDir);
+        previousRootDir = request.rootDir;
+        previousResolvedRoot = resolvedRoot;
+        const pathResult = resolvePathWithinNormalizedRoot(request, resolvedRoot);
         if (!pathResult.ok) {
             return { ok: false, error: pathResult.error };
         }

package/dist/root-walk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root-walk.d.ts","sourceRoot":"","sources":["../src/root-walk.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAClG,OAAO,KAAK,EAAY,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGrD,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,oBAAoB,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,OAAO,CAAC;AACzD,MAAM,MAAM,8BAA8B,GAAG,OAAO,GAAG,iBAAiB,CAAC;AACzE,MAAM,MAAM,yBAAyB,GAAG,SAAS,GAAG,MAAM,GAAG,cAAc,CAAC;AAC5E,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC;AACnE,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,GAAG,iBAAiB,GAAG,WAAW,CAAC;AAExF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,qBAAqB,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,aAAa,GACrB,iBAAiB,GACjB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GACpD;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAE/E,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,yBAAyB,CAAC;AAE1F,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,QAAQ,GAAG,YAAY,CAAC;IAChC,aAAa,EAAE,qBAAqB,CAAC;IACrC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,aAAa,CAAC,EAAE,qBAAqB,CAAC;IACtC,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAClC,gBAAgB,CAAC,EAAE,8BAA8B,CAAC;CACnD,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC9C,IAAI,CACF,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,oBAAoB,CAAC,CAAC;CAClC,CAAC;AAqBF,wBAAuB,QAAQ,CAC7B,IAAI,EAAE,kBAAkB,EACxB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,eAAe,GACvB,cAAc,CAAC,aAAa,CAAC,CAqK/B"}
+{"version":3,"file":"root-walk.d.ts","sourceRoot":"","sources":["../src/root-walk.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAClG,OAAO,KAAK,EAAY,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGrD,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,oBAAoB,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,OAAO,CAAC;AACzD,MAAM,MAAM,8BAA8B,GAAG,OAAO,GAAG,iBAAiB,CAAC;AACzE,MAAM,MAAM,yBAAyB,GAAG,SAAS,GAAG,MAAM,GAAG,cAAc,CAAC;AAC5E,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC;AACnE,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,GAAG,iBAAiB,GAAG,WAAW,CAAC;AAExF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,qBAAqB,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,aAAa,GACrB,iBAAiB,GACjB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GACpD;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAE/E,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,yBAAyB,CAAC;AAE1F,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,QAAQ,GAAG,YAAY,CAAC;IAChC,aAAa,EAAE,qBAAqB,CAAC;IACrC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,aAAa,CAAC,EAAE,qBAAqB,CAAC;IACtC,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAClC,gBAAgB,CAAC,EAAE,8BAA8B,CAAC;CACnD,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC9C,IAAI,CACF,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,oBAAoB,CAAC,CAAC;CAClC,CAAC;AAqBF,wBAAuB,QAAQ,CAC7B,IAAI,EAAE,kBAAkB,EACxB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,eAAe,GACvB,cAAc,CAAC,aAAa,CAAC,CAsK/B"}

package/dist/root-walk.js

@@ -98,6 +98,7 @@ export async function* walkRoot(root, relativePath, options) {
         let failed = false;
         let operationError;
         try {
+            const relativeDirectory = directory.split(path.sep).join(path.posix.sep);
             while (true) {
                 let next;
                 try {
@@ -112,7 +113,7 @@ export async function* walkRoot(root, relativePath, options) {
                     return;
                 const name = next.kind === "entry" ? next.entry.name : next.name;
                 const child = directory
-                    ? path.posix.join(directory.split(path.sep).join(path.posix.sep), name)
+                    ? path.posix.join(relativeDirectory, name)
                     : name;
                 if (next.kind === "limit") {
                     yield onLimit(child);

package/dist/root-write-mode.d.ts

@@ -1,6 +1,8 @@
+import { type RootBoundaryIdentity } from "./root-boundary.js";
 export declare function inheritWriteTargetMode(params: {
     targetPath: string;
     rootWithSep: string;
+    rootIdentity?: RootBoundaryIdentity;
     requestedMode?: number;
 }): Promise<number>;
 //# sourceMappingURL=root-write-mode.d.ts.map