@openclaw/fs-safe 0.8.6 → 0.10.0

package/dist/root-options.d.ts

@@ -0,0 +1,66 @@
+import type { DenyMutationPolicy } from "./deny-mutations.js";
+import type { RenameIdentityPolicy } from "./pinned-write.js";
+import type { MutationSymlinkPolicy, SymlinkPolicy } from "./root-symlink-policy.js";
+import type { CopyCloneMode } from "./copy-policy.js";
+import type { RootCopyPublicationReceipt } from "./copy-publication.js";
+import type { Root } from "./root-impl.js";
+export declare const DEFAULT_ROOT_MAX_BYTES: number;
+export type RootOptions = {
+    rootDir: string;
+    defaults?: RootDefaults;
+};
+export type HardlinkPolicy = "reject" | "allow";
+export type WritableOpenMode = "replace" | "append" | "update";
+export type RootDefaults = {
+    assertBeforeMutation?: () => void;
+    durable?: boolean;
+    hardlinks?: HardlinkPolicy;
+    maxBytes?: number;
+    mkdir?: boolean;
+    mode?: number;
+    denyMutations?: DenyMutationPolicy;
+    nonBlockingRead?: boolean;
+    renameIdentity?: RenameIdentityPolicy;
+    symlinks?: SymlinkPolicy;
+    mutationSymlinks?: MutationSymlinkPolicy;
+};
+export type RootReadOptions = Pick<RootDefaults, "hardlinks" | "maxBytes" | "nonBlockingRead" | "symlinks">;
+export type RootOpenOptions = Omit<RootReadOptions, "maxBytes">;
+export type RootWriteOptions = Pick<RootDefaults, "assertBeforeMutation" | "denyMutations" | "mutationSymlinks" | "durable" | "mkdir" | "mode" | "renameIdentity"> & {
+    encoding?: BufferEncoding;
+    overwrite?: boolean;
+};
+export type RootOpenWritableOptions = Pick<RootDefaults, "assertBeforeMutation" | "denyMutations" | "mutationSymlinks" | "mkdir" | "mode"> & {
+    writeMode?: WritableOpenMode;
+};
+export type RootCopyOptions = Pick<RootDefaults, "assertBeforeMutation" | "denyMutations" | "mutationSymlinks" | "durable" | "maxBytes" | "mkdir" | "mode"> & {
+    sourceHardlinks?: HardlinkPolicy;
+    overwrite?: boolean;
+    clone?: CopyCloneMode;
+    signal?: AbortSignal;
+    preserveSourceMode?: boolean;
+    onDestinationPublished?: (receipt: RootCopyPublicationReceipt) => void;
+};
+export type RootCopySource = string | {
+    root: Pick<Root, "open" | "stat">;
+    relativePath: string;
+};
+export type RootWriteJsonOptions = RootWriteOptions & {
+    replacer?: Parameters<typeof JSON.stringify>[1];
+    space?: Parameters<typeof JSON.stringify>[2];
+    trailingNewline?: boolean;
+};
+export type RootCreateOptions = Omit<RootWriteOptions, "overwrite">;
+export type RootCreateJsonOptions = Omit<RootWriteJsonOptions, "overwrite">;
+export type RootAppendOptions = RootWriteOptions & {
+    prependNewlineIfNeeded?: boolean;
+};
+export type RootMoveOptions = Pick<RootDefaults, "assertBeforeMutation" | "denyMutations" | "mutationSymlinks"> & {
+    overwrite?: boolean;
+};
+export type RootRemoveOptions = Pick<RootDefaults, "assertBeforeMutation" | "denyMutations" | "mutationSymlinks">;
+export type RootMkdirOptions = Pick<RootDefaults, "assertBeforeMutation" | "denyMutations" | "mutationSymlinks">;
+export type RootReadParams = Omit<RootReadOptions, "nonBlockingRead">;
+export declare function readDefaults(defaults: RootDefaults): RootReadParams;
+export declare function mergeReadOptions(defaults: RootDefaults, options: RootReadOptions): RootReadParams;
+//# sourceMappingURL=root-options.d.ts.map

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

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

package/dist/root-options.js

@@ -0,0 +1,18 @@
+import { normalizeMaxBytes } from "./byte-budget.js";
+export const DEFAULT_ROOT_MAX_BYTES = 16 * 1024 * 1024;
+export function readDefaults(defaults) {
+    return {
+        hardlinks: defaults.hardlinks,
+        maxBytes: normalizeMaxBytes(defaults.maxBytes, { defaultValue: DEFAULT_ROOT_MAX_BYTES }),
+        symlinks: defaults.symlinks,
+    };
+}
+export function mergeReadOptions(defaults, options) {
+    const merged = readDefaults(defaults);
+    if (options.hardlinks !== undefined)
+        merged.hardlinks = options.hardlinks;
+    merged.maxBytes = normalizeMaxBytes(options.maxBytes, { defaultValue: merged.maxBytes });
+    if (options.symlinks !== undefined)
+        merged.symlinks = options.symlinks;
+    return merged;
+}

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

@@ -1,3 +1,8 @@
+export declare function absolutePathWithRawSegments(candidate: string): string;
+export declare function rawPathRelativeToCanonicalRoot(candidate: string, rootCanonicalPath: string, options?: {
+    rejectSymlinks?: boolean;
+    rejectFinalSymlink?: boolean;
+}): string | undefined;
 export declare function resolvePathViaExistingAncestor(targetPath: string): Promise<string>;
 export declare function resolvePathViaExistingAncestorSync(targetPath: string): string;
 //# sourceMappingURL=root-path-existing.d.ts.map

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":"AAoBA,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,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"}

package/dist/root-path-existing.js

@@ -1,6 +1,61 @@
 import fs from "node:fs";
 import path from "node:path";
-import { isNotFoundPathError } from "./path.js";
+import { FsSafeError } from "./errors.js";
+import { formatErrorDetail } from "./error-detail.js";
+import { isNotFoundPathError, isPathInside } from "./path.js";
+export function absolutePathWithRawSegments(candidate) {
+    if (path.isAbsolute(candidate))
+        return candidate;
+    const drive = path.parse(candidate).root;
+    const base = drive ? path.resolve(drive) : process.cwd();
+    return `${base}${path.sep}${candidate.slice(drive.length)}`;
+}
+export function rawPathRelativeToCanonicalRoot(candidate, rootCanonicalPath, options = {}) {
+    const absolute = absolutePathWithRawSegments(candidate);
+    const raw = process.platform === "win32" ? absolute.replaceAll("/", path.sep) : absolute;
+    const filesystemRoot = path.parse(raw).root;
+    const segments = raw.slice(filesystemRoot.length).split(path.sep);
+    const finalComponentIndex = segments.findLastIndex(segment => segment !== "" && segment !== ".");
+    let prefix = filesystemRoot;
+    let traversedSymlink = false;
+    for (let index = 0; index < segments.length; index += 1) {
+        prefix += `${prefix.endsWith(path.sep) ? "" : path.sep}${segments[index]}`;
+        let canonical;
+        let isSymlink = false;
+        try {
+            const stat = fs.lstatSync(prefix);
+            isSymlink = stat.isSymbolicLink();
+            // Check the original leaf before canonicalization can erase an entry alias.
+            if (isSymlink && options.rejectFinalSymlink && index === finalComponentIndex) {
+                throw new FsSafeError("symlink", "final symlink not allowed");
+            }
+            if (!isSymlink && !stat.isDirectory() && index < segments.length - 1)
+                return undefined;
+            traversedSymlink ||= isSymlink;
+            canonical = fs.realpathSync.native(prefix);
+            if (isSymlink && index < segments.length - 1 && !fs.statSync(canonical).isDirectory())
+                return undefined;
+            if (isSymlink && !isPathInside(rootCanonicalPath, canonical) && !isPathInside(canonical, rootCanonicalPath)) {
+                throw new FsSafeError("outside-workspace", `symlink prefix resolves outside the root ancestry: ${formatErrorDetail(candidate)}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof FsSafeError)
+                throw error;
+            if (isSymlink)
+                return undefined;
+            continue;
+        }
+        if (!isPathInside(rootCanonicalPath, canonical))
+            continue;
+        if (options.rejectSymlinks && traversedSymlink) {
+            throw new FsSafeError("symlink", "symlink path component not allowed");
+        }
+        return [path.relative(rootCanonicalPath, canonical), ...segments.slice(index + 1)]
+            .filter(Boolean).join(path.sep);
+    }
+    return undefined;
+}
 function isFilesystemRoot(candidate) {
     return path.parse(candidate).root === candidate;
 }

package/dist/root-path.d.ts

@@ -21,6 +21,7 @@ type ResolveRootPathParams = {
     intent?: RootPathIntent;
     policy?: RootPathAliasPolicy;
     rejectSymlinks?: boolean;
+    rejectFinalSymlink?: boolean;
     rejectUnresolvedSymlinks?: boolean;
     skipLexicalRootCheck?: boolean;
     rootCanonicalPath?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"root-path.d.ts","sourceRoot":"","sources":["../src/root-path.ts"],"names":[],"mappings":"AAiBA,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,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;AAsCD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CAMnF"}
+{"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"}

package/dist/root-path.js

@@ -3,7 +3,7 @@ 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 { resolvePathViaExistingAncestor, resolvePathViaExistingAncestorSync, } from "./root-path-existing.js";
+import { absolutePathWithRawSegments, rawPathRelativeToCanonicalRoot, resolvePathViaExistingAncestor, resolvePathViaExistingAncestorSync, } from "./root-path-existing.js";
 import { resolveSymlinkHopPath, resolveSymlinkHopPathSync } from "./root-path-symlink.js";
 import { assertNoDriveRelativePathSegments } from "./safe-path-segment.js";
 export { resolvePathViaExistingAncestorSync } from "./root-path-existing.js";
@@ -27,34 +27,13 @@ export async function resolveRootPath(params) {
 }
 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);
-    const context = createBoundaryResolutionContext({
-        resolveParams: params,
-        rootPath,
-        absolutePath,
-        rootCanonicalPath,
-        outsideLexicalCanonicalPath: await resolveOutsideLexicalCanonicalPathAsync({
-            rootPath,
-            absolutePath,
-        }),
-    });
-    const outsideResult = await resolveOutsideRootPathAsync({
-        boundaryLabel: params.boundaryLabel,
-        context,
-    });
-    if (outsideResult) {
-        return outsideResult;
-    }
-    return resolveRootPathLexicalAsync({
-        params,
-        absolutePath: context.absolutePath,
-        rootPath: context.rootPath,
-        rootCanonicalPath: context.rootCanonicalPath,
-    });
+    return resolveRootPathLexicalAsync(prepareRootTraversal(params, rootPath, rootCanonicalPath, absolutePath));
 }
 export function resolveRootPathSync(params) {
     try {
@@ -66,34 +45,28 @@ export function resolveRootPathSync(params) {
 }
 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);
-    const context = createBoundaryResolutionContext({
-        resolveParams: params,
-        rootPath,
-        absolutePath,
-        rootCanonicalPath,
-        outsideLexicalCanonicalPath: resolveOutsideLexicalCanonicalPathSync({
-            rootPath,
-            absolutePath,
-        }),
-    });
-    const outsideResult = resolveOutsideRootPathSync({
-        boundaryLabel: params.boundaryLabel,
-        context,
-    });
-    if (outsideResult) {
-        return outsideResult;
+    return resolveRootPathLexicalSync(prepareRootTraversal(params, rootPath, rootCanonicalPath, absolutePath));
+}
+function prepareRootTraversal(params, rootPath, rootCanonicalPath, absolutePath) {
+    let raw = params.absolutePath;
+    if (rawPathRelativeToRoot(rootPath, raw) === undefined) {
+        const relative = rawPathRelativeToRoot(rootCanonicalPath, raw)
+            ?? rawPathRelativeToCanonicalRoot(raw, rootCanonicalPath, params);
+        if (relative === undefined) {
+            throw pathEscapeError({ rootPath, absolutePath: raw, boundaryLabel: params.boundaryLabel });
+        }
+        raw = `${rootPath}${path.sep}${relative}`;
     }
-    return resolveRootPathLexicalSync({
-        params,
-        absolutePath: context.absolutePath,
-        rootPath: context.rootPath,
-        rootCanonicalPath: context.rootCanonicalPath,
-    });
+    return {
+        params: raw === params.absolutePath ? params : { ...params, absolutePath: raw },
+        rootPath, rootCanonicalPath, absolutePath,
+    };
 }
 function sanitizeRootPathError(error) {
     if (error instanceof Error) {
@@ -120,14 +93,18 @@ function assertNoEmbeddedDriveRelativeSegment(filePath, label) {
 }
 function createLexicalTraversalState(params) {
     const rawAbsolutePath = params.params.absolutePath;
-    const rawRelativePath = rawPathRelativeToRoot(params.rootPath, rawAbsolutePath);
-    const relative = rawRelativePath ?? path.relative(params.rootPath, params.absolutePath);
+    const relative = rawPathRelativeToRoot(params.rootPath, rawAbsolutePath);
+    if (relative === undefined)
+        throw new Error("Path traversal must begin at the root");
+    const segments = splitTraversalSegments(relative);
     return {
-        segments: splitTraversalSegments(relative),
+        segments,
+        finalComponentIndex: segments.findLastIndex((segment) => segment !== "."),
         allowFinalSymlink: params.params.policy?.allowFinalSymlinkForUnlink === true,
         canonicalCursor: params.rootCanonicalPath,
         lexicalCursor: params.rootPath,
         preserveFinalSymlink: false,
+        missingDepth: 0,
     };
 }
 function createLexicalTraversalContext(params) {
@@ -140,9 +117,12 @@ function createLexicalTraversalContext(params) {
     };
 }
 function splitTraversalSegments(value) {
-    return value
+    const segments = value
         .split(process.platform === "win32" ? /[\\/]+/ : /\/+/)
-        .filter((segment) => Boolean(segment) && segment !== ".");
+        .filter(Boolean);
+    if (value.endsWith("/") || (process.platform === "win32" && value.endsWith("\\")))
+        segments.push(".");
+    return segments;
 }
 function rawPathRelativeToRoot(rootPath, candidatePath) {
     if (!path.isAbsolute(candidatePath)) {
@@ -170,12 +150,6 @@ function assertLexicalCursorInsideBoundary(context, candidatePath) {
         absolutePath: context.absolutePath,
     });
 }
-function applyMissingSuffixToCanonicalCursor(context, missingFromIndex) {
-    const missingSuffix = context.state.segments.slice(missingFromIndex);
-    for (const segment of missingSuffix) {
-        advanceCanonicalCursorForSegment(context, segment);
-    }
-}
 function advanceCanonicalCursorForSegment(context, segment) {
     context.state.canonicalCursor = path.resolve(context.state.canonicalCursor, segment);
     assertLexicalCursorInsideBoundary(context, context.state.canonicalCursor);
@@ -190,17 +164,18 @@ function finalizeLexicalResolution(context, kind) {
         kind,
     });
 }
-function handleLexicalLstatFailure(context, error, missingFromIndex) {
+function handleLexicalLstatFailure(context, error, segment) {
     if (!isNotFoundPathError(error)) {
         return false;
     }
-    applyMissingSuffixToCanonicalCursor(context, missingFromIndex);
+    advanceCanonicalCursorForSegment(context, segment);
+    context.state.missingDepth = 1;
     return true;
 }
 function lexicalStatDisposition(params) {
     if (!params.isSymbolicLink)
         return "continue";
-    if (params.rejectSymlinks === true && params.isLast) {
+    if (params.rejectFinalSymlink || (params.rejectSymlinks === true && params.isLast)) {
         throw new FsSafeError("symlink", "symlink path component not allowed");
     }
     return params.allowFinalSymlink && params.isLast ? "break" : "resolve-link";
@@ -219,6 +194,19 @@ function applyResolvedSymlinkHop(context, linkCanonical) {
 function applyParentTraversalStep(context) {
     context.state.lexicalCursor = path.resolve(context.state.lexicalCursor, "..");
     advanceCanonicalCursorForSegment(context, "..");
+    if (context.state.missingDepth > 0)
+        context.state.missingDepth -= 1;
+}
+function assertDirectoryBeforeMoreSegments(stat, pathname, isLast) {
+    if (!isLast && !stat.isDirectory()) {
+        throw Object.assign(new Error(`Path component is not a directory: ${pathname}`), { code: "ENOTDIR" });
+    }
+}
+function assertResolvedLinkDirectory(pathname, isLast) {
+    if (isLast)
+        return;
+    const stat = fs.statSync(pathname);
+    assertDirectoryBeforeMoreSegments(stat, pathname, isLast);
 }
 async function resolveRootPathLexicalAsync(params) {
     const context = createLexicalTraversalContext(params);
@@ -226,25 +214,35 @@ async function resolveRootPathLexicalAsync(params) {
     for (let idx = 0; idx < state.segments.length; idx += 1) {
         const segment = state.segments[idx] ?? "";
         const isLast = idx === state.segments.length - 1;
+        if (segment === ".")
+            continue;
         if (segment === "..") {
             applyParentTraversalStep(context);
             continue;
         }
         state.lexicalCursor = path.join(state.lexicalCursor, segment);
+        if (state.missingDepth > 0) {
+            advanceCanonicalCursorForSegment(context, segment);
+            state.missingDepth += 1;
+            continue;
+        }
         let stat;
         try {
             stat = fs.lstatSync(state.lexicalCursor);
         }
         catch (error) {
-            if (handleLexicalLstatFailure(context, error, idx))
-                break;
+            if (handleLexicalLstatFailure(context, error, segment))
+                continue;
             throw error;
         }
         const isSymbolicLink = stat.isSymbolicLink();
+        if (!isSymbolicLink)
+            assertDirectoryBeforeMoreSegments(stat, state.lexicalCursor, isLast);
         const disposition = lexicalStatDisposition({
             isSymbolicLink,
             isLast,
             rejectSymlinks: isSymbolicLink ? context.resolveParams.rejectSymlinks : undefined,
+            rejectFinalSymlink: context.resolveParams.rejectFinalSymlink === true && idx === state.finalComponentIndex,
             allowFinalSymlink: state.allowFinalSymlink,
         });
         if (disposition !== "resolve-link") {
@@ -261,6 +259,7 @@ async function resolveRootPathLexicalAsync(params) {
         if (context.resolveParams.rejectSymlinks === true) {
             throw new FsSafeError("symlink", "symlink path component not allowed");
         }
+        assertResolvedLinkDirectory(linkCanonical, isLast);
     }
     const kind = await getPathKind(state.canonicalCursor, state.preserveFinalSymlink);
     return finalizeLexicalResolution(context, kind);
@@ -271,25 +270,35 @@ function resolveRootPathLexicalSync(params) {
     for (let idx = 0; idx < state.segments.length; idx += 1) {
         const segment = state.segments[idx] ?? "";
         const isLast = idx === state.segments.length - 1;
+        if (segment === ".")
+            continue;
         if (segment === "..") {
             applyParentTraversalStep(context);
             continue;
         }
         state.lexicalCursor = path.join(state.lexicalCursor, segment);
+        if (state.missingDepth > 0) {
+            advanceCanonicalCursorForSegment(context, segment);
+            state.missingDepth += 1;
+            continue;
+        }
         let stat;
         try {
             stat = fs.lstatSync(state.lexicalCursor);
         }
         catch (error) {
-            if (handleLexicalLstatFailure(context, error, idx))
-                break;
+            if (handleLexicalLstatFailure(context, error, segment))
+                continue;
             throw error;
         }
         const isSymbolicLink = stat.isSymbolicLink();
+        if (!isSymbolicLink)
+            assertDirectoryBeforeMoreSegments(stat, state.lexicalCursor, isLast);
         const disposition = lexicalStatDisposition({
             isSymbolicLink,
             isLast,
             rejectSymlinks: isSymbolicLink ? context.resolveParams.rejectSymlinks : undefined,
+            rejectFinalSymlink: context.resolveParams.rejectFinalSymlink === true && idx === state.finalComponentIndex,
             allowFinalSymlink: state.allowFinalSymlink,
         });
         if (disposition !== "resolve-link") {
@@ -306,108 +315,11 @@ function resolveRootPathLexicalSync(params) {
         if (context.resolveParams.rejectSymlinks === true) {
             throw new FsSafeError("symlink", "symlink path component not allowed");
         }
+        assertResolvedLinkDirectory(linkCanonical, isLast);
     }
     const kind = getPathKindSync(state.canonicalCursor, state.preserveFinalSymlink);
     return finalizeLexicalResolution(context, kind);
 }
-function resolveCanonicalOutsideLexicalPath(params) {
-    return params.outsideLexicalCanonicalPath ?? params.absolutePath;
-}
-function createBoundaryResolutionContext(params) {
-    const lexicalInside = isPathInside(params.rootPath, params.absolutePath);
-    const canonicalOutsideLexicalPath = resolveCanonicalOutsideLexicalPath({
-        absolutePath: params.absolutePath,
-        outsideLexicalCanonicalPath: params.outsideLexicalCanonicalPath,
-    });
-    assertLexicalBoundaryOrCanonicalAlias({
-        skipLexicalRootCheck: params.resolveParams.skipLexicalRootCheck,
-        lexicalInside,
-        canonicalOutsideLexicalPath,
-        rootCanonicalPath: params.rootCanonicalPath,
-        boundaryLabel: params.resolveParams.boundaryLabel,
-        rootPath: params.rootPath,
-        absolutePath: params.absolutePath,
-    });
-    return {
-        rootPath: params.rootPath,
-        absolutePath: params.absolutePath,
-        rootCanonicalPath: params.rootCanonicalPath,
-        lexicalInside,
-        canonicalOutsideLexicalPath,
-    };
-}
-async function resolveOutsideRootPathAsync(params) {
-    if (params.context.lexicalInside) {
-        return null;
-    }
-    const kind = await getPathKind(params.context.absolutePath, false);
-    return buildOutsideRootPathFromContext({
-        boundaryLabel: params.boundaryLabel,
-        context: params.context,
-        kind,
-    });
-}
-function resolveOutsideRootPathSync(params) {
-    if (params.context.lexicalInside) {
-        return null;
-    }
-    const kind = getPathKindSync(params.context.absolutePath, false);
-    return buildOutsideRootPathFromContext({
-        boundaryLabel: params.boundaryLabel,
-        context: params.context,
-        kind,
-    });
-}
-function buildOutsideRootPathFromContext(params) {
-    return buildOutsideLexicalRootPath({
-        boundaryLabel: params.boundaryLabel,
-        rootCanonicalPath: params.context.rootCanonicalPath,
-        absolutePath: params.context.absolutePath,
-        canonicalOutsideLexicalPath: params.context.canonicalOutsideLexicalPath,
-        rootPath: params.context.rootPath,
-        kind: params.kind,
-    });
-}
-async function resolveOutsideLexicalCanonicalPathAsync(params) {
-    if (isPathInside(params.rootPath, params.absolutePath)) {
-        return undefined;
-    }
-    return await resolvePathViaExistingAncestor(params.absolutePath);
-}
-function resolveOutsideLexicalCanonicalPathSync(params) {
-    if (isPathInside(params.rootPath, params.absolutePath)) {
-        return undefined;
-    }
-    return resolvePathViaExistingAncestorSync(params.absolutePath);
-}
-function buildOutsideLexicalRootPath(params) {
-    assertInsideBoundary({
-        boundaryLabel: params.boundaryLabel,
-        rootCanonicalPath: params.rootCanonicalPath,
-        candidatePath: params.canonicalOutsideLexicalPath,
-        absolutePath: params.absolutePath,
-    });
-    return buildResolvedRootPath({
-        absolutePath: params.absolutePath,
-        canonicalPath: params.canonicalOutsideLexicalPath,
-        rootPath: params.rootPath,
-        rootCanonicalPath: params.rootCanonicalPath,
-        kind: params.kind,
-    });
-}
-function assertLexicalBoundaryOrCanonicalAlias(params) {
-    if (params.skipLexicalRootCheck || params.lexicalInside) {
-        return;
-    }
-    if (isPathInside(params.rootCanonicalPath, params.canonicalOutsideLexicalPath)) {
-        return;
-    }
-    throw pathEscapeError({
-        boundaryLabel: params.boundaryLabel,
-        rootPath: params.rootPath,
-        absolutePath: params.absolutePath,
-    });
-}
 function buildResolvedRootPath(params) {
     return {
         absolutePath: params.absolutePath,

package/dist/root-symlink-policy.d.ts

@@ -0,0 +1,13 @@
+export type SymlinkPolicy = "reject" | "follow-within-root" | "follow-parents-within-root";
+export type MutationSymlinkPolicy = "reject" | "follow-parents-within-root";
+export declare function readSymlinkResolution(symlinks: SymlinkPolicy | undefined): {
+    rejectSymlinks: boolean;
+    rejectFinalSymlink: boolean;
+};
+export declare function mutationSymlinkResolution(symlinks: MutationSymlinkPolicy | undefined): {
+    rejectSymlinks: boolean;
+    rejectFinalSymlink: boolean;
+    resolveCanonical: boolean;
+};
+export declare function assertFinalSymlinkRejected(targetPath: string, reject: boolean | undefined): void;
+//# sourceMappingURL=root-symlink-policy.d.ts.map

package/dist/root-symlink-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-symlink-policy.d.ts","sourceRoot":"","sources":["../src/root-symlink-policy.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,oBAAoB,GAAG,4BAA4B,CAAC;AAC3F,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,4BAA4B,CAAC;AAE5E,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,SAAS;IAErE,cAAc;IACd,kBAAkB;EAErB;AAED,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,qBAAqB,GAAG,SAAS;IAKjF,cAAc;IACd,kBAAkB;IAClB,gBAAgB;EAEnB;AAID,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAShG"}

package/dist/root-symlink-policy.js

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import { FsSafeError } from "./errors.js";
+import { isNotFoundPathError } from "./path.js";
+export function readSymlinkResolution(symlinks) {
+    return {
+        rejectSymlinks: symlinks !== "follow-within-root" && symlinks !== "follow-parents-within-root",
+        rejectFinalSymlink: symlinks === "follow-parents-within-root",
+    };
+}
+export function mutationSymlinkResolution(symlinks) {
+    if (symlinks !== undefined && symlinks !== "reject" && symlinks !== "follow-parents-within-root") {
+        throw new RangeError("mutationSymlinks must be reject or follow-parents-within-root");
+    }
+    return {
+        rejectSymlinks: symlinks === "reject",
+        rejectFinalSymlink: symlinks !== undefined,
+        resolveCanonical: symlinks !== undefined,
+    };
+}
+// Call after parent fences and immediately before the mutation. This is a
+// final-component check, not an atomic conditional rename against another process.
+export function assertFinalSymlinkRejected(targetPath, reject) {
+    if (!reject)
+        return;
+    try {
+        if (fs.lstatSync(targetPath).isSymbolicLink()) {
+            throw new FsSafeError("symlink", "final symlink not allowed");
+        }
+    }
+    catch (error) {
+        if (!isNotFoundPathError(error))
+            throw error;
+    }
+}

package/dist/root-walk.d.ts

@@ -1,4 +1,5 @@
-import type { DirEntry } from "./types.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 RootWalkLimitBehavior = "truncate" | "throw";
 export type RootWalkDirectoryErrorBehavior = "throw" | "skip-and-report";
@@ -24,6 +25,7 @@ export type RootWalkEntryFilter = (entry: RootWalkDataEntry) => RootWalkEntryFil
 export type RootWalkOptions = {
     maxDepth?: number;
     maxEntries?: number;
+    order?: "sorted" | "filesystem";
     symlinkPolicy: RootWalkSymlinkPolicy;
     signal?: AbortSignal;
     limitBehavior?: RootWalkLimitBehavior;
@@ -32,9 +34,8 @@ export type RootWalkOptions = {
 };
 type RootWalkCapability = {
     rootReal: string;
-    list(relativePath: string, options: {
-        withFileTypes: true;
-    }): Promise<DirEntry[]>;
+    stat(relativePath: string): Promise<PathStat>;
+    list(relativePath: string, options: RootDirectoryListingOptions): Promise<RootDirectoryListing>;
 };
 export declare function walkRoot(root: RootWalkCapability, relativePath: string, options: RootWalkOptions): AsyncGenerator<RootWalkEntry>;
 export {};

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,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,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,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,EAAE,OAAO,EAAE;QAAE,aAAa,EAAE,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;CACnF,CAAC;AAqBF,wBAAuB,QAAQ,CAC7B,IAAI,EAAE,kBAAkB,EACxB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,eAAe,GACvB,cAAc,CAAC,aAAa,CAAC,CAyH/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,CAqK/B"}