@poe-platform/safe-fs 0.1.727 → 0.1.728

package/dist/safe-fs/fs/devices/path.js

@@ -1,13 +1,19 @@
 import { FsError, isFsError } from "../../contracts/errors.js";
-import { validatePath } from "../../contracts/virtual-path.js";
-import { capturePathNamespace } from "../path-namespace.js";
+import { MAX_PATH_COMPONENTS, validatePath } from "../../contracts/virtual-path.js";
+import { capturePathNamespace, pathNamespace } from "../path-namespace.js";
+import { isCleanAbsolutePath, tryResolveMemoryDevicePath } from "../memory/index.js";
 export const nullPath = "/dev/null";
 export const deviceDirectory = "/dev";
+function isNullParts(parts) {
+    return parts.length === 2 && parts[0] === "dev" && parts[1] === "null";
+}
 export function lexicalDevicePath(path) {
     validatePath(path);
+    if (isCleanAbsolutePath(path) && !path.startsWith("/dev/null/"))
+        return path;
     const parts = [];
     for (const component of path.split("/")) {
-        if (`/${parts.join("/")}` === nullPath)
+        if (isNullParts(parts))
             throw new FsError("ENOTDIR", { path });
         if (component === "..")
             parts.pop();
@@ -16,7 +22,7 @@ export function lexicalDevicePath(path) {
     }
     return `/${parts.join("/")}`;
 }
-async function resolveResizeDevicePath(filesystem, path, options, create, namespace) {
+async function resolveResizeDevicePath(filesystem, path, options, create, namespace, traversal) {
     validatePath(path);
     const components = (value) => {
         const result = value.split("/").filter(Boolean);
@@ -25,6 +31,9 @@ async function resolveResizeDevicePath(filesystem, path, options, create, namesp
         return result;
     };
     const pending = components(path);
+    let remainingComponents = MAX_PATH_COMPONENTS - pending.length;
+    if (remainingComponents < 0)
+        throw new FsError("ENAMETOOLONG", { path });
     const parts = [];
     let links = 0;
     let expanded = path.length;
@@ -57,12 +66,14 @@ async function resolveResizeDevicePath(filesystem, path, options, create, namesp
             parts.pop();
             continue;
         }
-        if (new TextEncoder().encode(component).byteLength > 255)
+        if (exceedsComponentByteLimit(component))
             throw new FsError("ENAMETOOLONG", { path });
         const candidate = `/${[...parts, component].join("/")}`;
         const selected = namespace === undefined ? undefined : candidate === deviceDirectory || candidate === nullPath ? "/" : namespace(candidate);
         if (boundary !== undefined && selected !== boundary)
             throw new FsError("EACCES", { path });
+        if (traversal && (candidate === deviceDirectory || candidate === nullPath))
+            traversal.virtual = true;
         if (create && pending.length === 1 && pending[0] === "")
             throw new FsError("EISDIR", { path });
         if (candidate !== deviceDirectory && candidate !== nullPath) {
@@ -97,6 +108,9 @@ async function resolveResizeDevicePath(filesystem, path, options, create, namesp
                 const targetParts = components(target);
                 if (targetParts.at(-1) === "" && pending[0] === "")
                     targetParts.pop();
+                if (targetParts.length > remainingComponents)
+                    throw new FsError("ENAMETOOLONG", { path });
+                remainingComponents -= targetParts.length;
                 pending.unshift(...targetParts);
                 continue;
             }
@@ -105,11 +119,36 @@ async function resolveResizeDevicePath(filesystem, path, options, create, namesp
     }
     return `/${parts.join("/")}`;
 }
-export async function resolveDevicePath(filesystem, path, options, followFinal = true, resizeCreate) {
+function utf8ByteLength(value) {
+    let bytes = 0;
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && i + 1 < value.length && value.charCodeAt(i + 1) >= 0xdc00 && value.charCodeAt(i + 1) <= 0xdfff) {
+            bytes += 4;
+            i++;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
+function exceedsComponentByteLimit(value) {
+    return value.length > 85 && (value.length > 255 || utf8ByteLength(value) > 255);
+}
+export async function resolveDevicePath(filesystem, path, options, followFinal = true, resizeCreate, traversal) {
     options.signal?.throwIfAborted();
+    if (Reflect.get(filesystem, pathNamespace) === undefined) {
+        const fast = tryResolveMemoryDevicePath(filesystem, path, resizeCreate);
+        if (fast !== undefined)
+            return fast;
+    }
     const namespace = capturePathNamespace(filesystem, options);
     if (resizeCreate !== undefined)
-        return resolveResizeDevicePath(filesystem, path, options, resizeCreate, namespace);
+        return resolveResizeDevicePath(filesystem, path, options, resizeCreate, namespace, traversal);
     const lexical = lexicalDevicePath(path);
     const lstat = filesystem.lstat;
     options.signal?.throwIfAborted();
@@ -117,15 +156,19 @@ export async function resolveDevicePath(filesystem, path, options, followFinal =
     if (!aliases && lexical !== nullPath && lexical !== deviceDirectory && lexical !== "/")
         return lexical;
     const pending = path.split("/");
+    let remainingComponents = MAX_PATH_COMPONENTS - pending.filter(Boolean).length;
+    if (remainingComponents < 0)
+        throw new FsError("ENAMETOOLONG", { path });
     const parts = [];
     let links = 0;
     let expanded = path.length;
     let absolute = path.startsWith("/");
     let traversalFailure;
+    let failedDepth = Infinity;
     let boundary;
     while (pending.length) {
         options.signal?.throwIfAborted();
-        if (`/${parts.join("/")}` === nullPath)
+        if (isNullParts(parts))
             throw new FsError("ENOTDIR", { path });
         const component = pending.shift();
         if (!component || component === ".")
@@ -134,13 +177,18 @@ export async function resolveDevicePath(filesystem, path, options, followFinal =
             if (boundary !== undefined && `/${parts.join("/")}` === boundary)
                 throw new FsError("EACCES", { path });
             parts.pop();
+            if (parts.length < failedDepth) {
+                failedDepth = Infinity;
+            }
             continue;
         }
         const candidate = `/${[...parts, component].join("/")}`;
         const selected = namespace === undefined ? undefined : candidate === deviceDirectory || candidate === nullPath ? "/" : namespace(candidate);
         if (boundary !== undefined && selected !== boundary)
             throw new FsError("EACCES", { path });
-        if (candidate !== deviceDirectory && candidate !== nullPath && ((followFinal && aliases) || pending.length)) {
+        if (traversal && (candidate === deviceDirectory || candidate === nullPath))
+            traversal.virtual = true;
+        if (parts.length < failedDepth && candidate !== deviceDirectory && candidate !== nullPath && ((followFinal && aliases) || pending.length)) {
             const lookup = absolute ? candidate : candidate.slice(1);
             let stat;
             try {
@@ -154,8 +202,10 @@ export async function resolveDevicePath(filesystem, path, options, followFinal =
                     return lexical;
                 if (!isFsError(error, "ENOENT"))
                     throw error;
-                if (pending.length)
+                if (pending.length) {
                     traversalFailure ??= error;
+                    failedDepth = Math.min(failedDepth, parts.length + 1);
+                }
             }
             options.signal?.throwIfAborted();
             if (stat?.type === "symlink") {
@@ -172,15 +222,23 @@ export async function resolveDevicePath(filesystem, path, options, followFinal =
                 expanded += target.length;
                 if (expanded > 65536)
                     throw new FsError("ENAMETOOLONG", { path });
+                const targetSplit = target.split("/");
+                const nonEmptyCount = targetSplit.filter(Boolean).length;
+                if (nonEmptyCount > remainingComponents)
+                    throw new FsError("ENAMETOOLONG", { path });
+                remainingComponents -= nonEmptyCount;
                 if (target.startsWith("/")) {
                     parts.splice(0, parts.length, ...(boundary ?? "/").split("/").filter(Boolean));
                     absolute = true;
+                    failedDepth = Infinity;
                 }
-                pending.unshift(...target.split("/"));
+                pending.unshift(...targetSplit);
                 continue;
             }
-            if (stat && pending.length && stat.type !== "directory")
+            if (stat && pending.length && stat.type !== "directory") {
                 traversalFailure ??= new FsError("ENOTDIR", { path });
+                failedDepth = Math.min(failedDepth, parts.length + 1);
+            }
         }
         parts.push(component);
     }

package/dist/safe-fs/fs/memory/index.d.ts

@@ -1,56 +1,23 @@
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileReadHandle, FileResizeHandle, FileStat, FileSystem, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, FileDescriptor, OpenFileOptions, OpenReadFileOptions, OpenResizeFileOptions, WriteFileOptions, ConditionalWriteFileOptions, ConditionalRemoveFileOptions, ConditionalRemoveEntryOptions, CreateStagedFileOptions, FileStaging, PublishStagedFileOptions, PrepareDirectoryOptions, StagedFileContent } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileReadHandle, FileResizeHandle, FileStat, FileSystem, FileSystemCapabilities, FsOptions, ChmodOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, FileDescriptor, OpenFileOptions, OpenReadFileOptions, OpenResizeFileOptions, WriteFileOptions, ConditionalWriteFileOptions, ConditionalRemoveFileOptions, ConditionalRemoveEntryOptions, ConditionalRemoveEntryReceiptOptions, CreateStagedFileOptions, FileStaging, FileStagingEntry, FileStagingResolution, PublishStagedFileOptions, PrepareDirectoryOptions, StagedFileContent } from "../../contracts/filesystem.js";
 import type { ByteSource } from "../../contracts/io.js";
 import { type MemoryFileSystemOptions } from "./limits.js";
 export { defaultMemoryFileSystemLimits, type MemoryFileSystemLimits, type MemoryFileSystemOptions } from "./limits.js";
+export interface ConditionalMutationBinding {
+    readonly path: string;
+    readonly parent: FileStat;
+    readonly expected: FileStat;
+    readonly ancestors: readonly FileStagingEntry[];
+}
+export declare function bindConditionalMutation<Result>(identityScope: object | symbol | undefined, binding: ConditionalMutationBinding, action: () => Promise<Result>): Promise<Result>;
 export declare class MemoryFileSystem implements FileSystem {
-    readonly capabilities: Readonly<{
-        read: true;
-        stat: true;
-        readdir: true;
-        realpath: true;
-        access: true;
-        open: true;
-        write: true;
-        append: true;
-        exclusiveCreate: true;
-        explicitDirectories: true;
-        implicitDirectories: false;
-        mkdir: true;
-        recursiveMkdir: true;
-        remove: true;
-        removeDirectory: true;
-        recursiveRemove: true;
-        rename: true;
-        atomicRenameNoReplace: true;
-        copy: true;
-        exclusiveCopy: true;
-        readlink: true;
-        truncate: true;
-        streamingAppend: true;
-        randomAccessWrite: true;
-        readOnly: false;
-        symlinks: true;
-        hardlinks: true;
-        permissions: true;
-        timestamps: true;
-        atomicRename: true;
-        atomicFileStaging: true;
-        atomicStagingAncestry: true;
-        atomicFileMutation: true;
-        atomicEntryRemoval: true;
-        atomicTreeRemoval: true;
-        atomicDirectoryMetadata: true;
-        streamingRead: true;
-        retainedRead: true;
-        readonly retainedResize: boolean;
-        streamingWrite: true;
-        readonly descriptorWriteStream: boolean;
-    }>;
+    capabilitiesFor?: NonNullable<FileSystem["capabilitiesFor"]>;
+    readonly capabilities: FileSystemCapabilities;
     private readonly identityScope;
     private nextInode;
     private readonly ledger;
     private readonly root;
     private totalBytes;
+    symlinkCount: number;
     constructor(options?: MemoryFileSystemOptions);
     compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<EntryComparison>;
     canonicalizeMissingTarget(path: string, options?: FsOptions): string | undefined;
@@ -68,10 +35,12 @@ export declare class MemoryFileSystem implements FileSystem {
     private mode;
     private integer;
     private changed;
+    private resolveNode;
     private resolve;
     private file;
     private entry;
     private terminalDot;
+    private directoryNlink;
     private snapshot;
     private bytes;
     private allocate;
@@ -80,15 +49,24 @@ export declare class MemoryFileSystem implements FileSystem {
     private openWrite;
     private writeData;
     private writeAt;
+    writeMemoryFileFast(path: string, data: Uint8Array, append: boolean, mode: number): void;
     readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
     private expectEntry;
     private stagingLocations;
     createStagedFile(directoryPath: string, name: string, content: StagedFileContent, options: CreateStagedFileOptions): Promise<FileStaging>;
-    publishStagedFile(staging: FileStaging, destination: string, options: PublishStagedFileOptions): Promise<void>;
+    private retainStagingCleanup;
+    prepareDirectoryAncestry(ancestors: readonly FileStagingEntry[], options?: FsOptions): Promise<() => true>;
+    prepareStagingResolution(path: string, options?: FsOptions): Promise<FileStagingResolution>;
+    private verifyDirectoryAncestry;
+    publishStagedFile(receipt: FileStaging, destination: string, options: PublishStagedFileOptions): Promise<void>;
     removeStagedFile(staging: FileStaging, options?: FsOptions): Promise<void>;
+    private removeStagingLocations;
     prepareDirectory(path: string, options: PrepareDirectoryOptions): Promise<FileStat>;
     writeFileConditional(path: string, data: Uint8Array, options: ConditionalWriteFileOptions): Promise<FileStat>;
-    removeEntryConditional(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;
+    removeEntryConditional(path: string, options: ConditionalRemoveEntryOptions & {
+        readonly returnRemainingStat?: false | undefined;
+    }): Promise<void>;
+    removeEntryConditional(path: string, options: ConditionalRemoveEntryReceiptOptions): Promise<void | FileStat>;
     removeFileConditional(path: string, options: ConditionalRemoveFileOptions): Promise<void>;
     removeTreeConditional(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;
     writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
@@ -98,7 +76,7 @@ export declare class MemoryFileSystem implements FileSystem {
     readdir(path: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
     mkdir(path: string, options?: MkdirOptions): Promise<void>;
     rmdir(path: string, options?: FsOptions): Promise<void>;
-    rm(path: string, options?: RemoveOptions): Promise<void>;
+    rm(path: string, options?: RemoveOptions & Partial<ConditionalMutationBinding>): Promise<void>;
     private removeLocation;
     unlink(path: string, options?: FsOptions): Promise<void>;
     rename(source: string, destination: string, options?: RenameOptions): Promise<void>;
@@ -108,7 +86,7 @@ export declare class MemoryFileSystem implements FileSystem {
     readlink(path: string, options?: FsOptions): Promise<string>;
     symlink(target: string, path: string, options?: FsOptions): Promise<void>;
     link(existingPath: string, newPath: string, options?: FsOptions): Promise<void>;
-    chmod(path: string, mode: number, options?: FsOptions): Promise<void>;
+    chmod(path: string, mode: number, options?: ChmodOptions): Promise<void>;
     utimes(path: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
     truncate(path: string, length?: number, options?: FsOptions): Promise<void>;
     private resizeNode;
@@ -118,3 +96,11 @@ export declare class MemoryFileSystem implements FileSystem {
     writeStream(path: string, source: ByteSource, options?: WriteFileOptions): Promise<void>;
 }
 export declare function createMemoryFileSystem(options?: MemoryFileSystemOptions | Readonly<Record<string, unknown>>): MemoryFileSystem;
+export declare function utf8ByteLength(value: string): number;
+export declare function isCleanAbsolutePath(path: string): boolean;
+export declare function tryResolveMemoryDevicePath(filesystem: FileSystem, path: string, resizeCreate?: boolean): string | undefined;
+export declare function tryReadMemoryFileViewSync(filesystem: FileSystem, path: string, maxBytes?: number, signal?: AbortSignal): Uint8Array | undefined;
+export declare function tryGetMemoryDirectoryEntryNamesSync(filesystem: FileSystem, path: string): ReadonlyMap<string, {
+    readonly type: "file" | "directory" | "symlink";
+}> | undefined;
+export declare function tryWriteMemoryFileSync(filesystem: FileSystem, path: string, data: Uint8Array, append: boolean, mode: number, signal?: AbortSignal): boolean;