@poe-platform/safe-fs 0.1.145 → 0.1.146

package/dist/safe-fs/contracts/filesystem.d.ts

@@ -96,6 +96,7 @@ export interface ReadStreamOptions extends FsOptions {
 }
 export interface FileSystem {
     readonly capabilities: FileSystemCapabilities;
+    canonicalizeMissingTarget?(path: string, options?: FsOptions): string | undefined;
     capabilitiesFor?(path: string, options?: FsOptions): Promise<FileSystemCapabilities>;
     readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
     writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;

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

@@ -38,6 +38,7 @@ export declare class MemoryFileSystem implements FileSystem {
     private readonly root;
     constructor();
     compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<EntryComparison>;
+    canonicalizeMissingTarget(path: string, options?: FsOptions): string | undefined;
     private metadata;
     private directory;
     private fail;

package/dist/safe-fs/fs/memory/index.js

@@ -3,6 +3,7 @@ import { assertCallbackAuthorityAllowed, compareEntries, registerEntryAuthority
 import { getOwnedS3Entry } from "../s3/registry.js";
 import { getOwnedWebDavEntry } from "../webdav/resource-id.js";
 import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
+import { resolveMissingTarget } from "./missing-target.js";
 const typeModes = { file: 0o100000, directory: 0o040000, symlink: 0o120000 };
 const ownedStats = new WeakMap();
 const ownedStores = new WeakMap();
@@ -80,6 +81,22 @@ export class MemoryFileSystem {
     compareEntry(path, peer, peerPath, options = {}) {
         return compareEntries(this, path, peer, peerPath, options);
     }
+    canonicalizeMissingTarget(path, options = {}) {
+        options.signal?.throwIfAborted();
+        const owner = ownedStores.get(this);
+        if (!owner || Object.getPrototypeOf(this) !== MemoryFileSystem.prototype
+            || Object.getOwnPropertyDescriptor(this, "root")?.value !== owner.root)
+            return undefined;
+        for (const name of ["realpath", "lstat", "resolve", "permission", "validatePath", "fail", "snapshot"]) {
+            const descriptor = Object.getOwnPropertyDescriptor(this, name)
+                ?? Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, name);
+            if (!descriptor || !("value" in descriptor) || descriptor.value !== memoryImplementation[name]?.value)
+                return undefined;
+        }
+        if (path !== "")
+            this.validatePath(path, "realpath");
+        return resolveMissingTarget(owner.root, path || ".", options.signal);
+    }
     metadata(mode) {
         const now = Date.now();
         return {

package/dist/safe-fs/fs/memory/missing-target.d.ts

@@ -0,0 +1,14 @@
+type Node = {
+    type: "file";
+    mode: number;
+} | {
+    type: "symlink";
+    mode: number;
+    target: string;
+} | {
+    type: "directory";
+    mode: number;
+    entries: ReadonlyMap<string, Node>;
+};
+export declare function resolveMissingTarget(root: Node, path: string, signal?: AbortSignal): string;
+export {};

package/dist/safe-fs/fs/memory/missing-target.js

@@ -0,0 +1,117 @@
+import { FsError } from "../../contracts/errors.js";
+function components(path, signal) {
+    const result = [];
+    let start = 0;
+    for (let offset = 0; offset <= path.length; offset++) {
+        signal?.throwIfAborted();
+        if (offset !== path.length && path.charCodeAt(offset) !== 47)
+            continue;
+        if (offset > start)
+            result.push({ name: path.slice(start, offset), start });
+        start = offset + 1;
+    }
+    return result;
+}
+export function resolveMissingTarget(root, path, signal) {
+    const fail = (code, failedPath = path) => {
+        throw new FsError(code, { syscall: "realpath", path: failedPath });
+    };
+    const origin = components(path, signal);
+    const initial = { node: root, name: "" };
+    let position = initial;
+    let links = 0;
+    let missing = origin.length;
+    let missingLink = false;
+    for (let index = 0; index <= origin.length; index++) {
+        const token = origin[index];
+        if (!token && path.length > 0 && !path.endsWith("/"))
+            break;
+        const before = position;
+        const frames = [{ names: [token ?? { name: ".", start: path.length }], next: 0 }];
+        let first = true;
+        let originLink = false;
+        let found = true;
+        while (frames.length > 0) {
+            signal?.throwIfAborted();
+            const frame = frames.at(-1);
+            if (!frame)
+                break;
+            const component = frame.names[frame.next++];
+            if (!component) {
+                frames.pop();
+                continue;
+            }
+            const current = position.node;
+            if (current.type !== "directory")
+                return fail("ENOTDIR");
+            if (((current.mode >> 6) & 1) !== 1)
+                return fail("EACCES");
+            const name = component.name;
+            if (name === ".") {
+                first = false;
+                continue;
+            }
+            if (name === "..") {
+                position = position.parent ?? initial;
+                first = false;
+                continue;
+            }
+            if (new TextEncoder().encode(name).byteLength > 255)
+                return fail("ENAMETOOLONG");
+            const node = current.entries.get(name);
+            if (!node) {
+                found = false;
+                break;
+            }
+            if (first)
+                originLink = node.type === "symlink";
+            first = false;
+            if (node.type === "symlink") {
+                if (++links > 40)
+                    return fail("ELOOP");
+                const names = components(node.target, signal);
+                if (node.target.endsWith("/"))
+                    names.push({ name: ".", start: node.target.length });
+                if (node.target.startsWith("/"))
+                    position = initial;
+                frames.push({ names, next: 0 });
+            }
+            else
+                position = { node, name, parent: position };
+        }
+        if (!found) {
+            position = before;
+            missing = index;
+            missingLink = originLink;
+            break;
+        }
+    }
+    if (missingLink) {
+        let end = path.length;
+        for (let count = origin.length; count > missing; count--) {
+            signal?.throwIfAborted();
+            if (count === missing + 1 && path[end - 1] !== "/")
+                return fail("ENOENT", path.slice(0, end));
+            const last = origin[count - 1];
+            if (!last)
+                break;
+            const boundary = last.start - 1;
+            end = boundary <= 0 ? 1 : boundary === 1 && path.startsWith("/") ? 2 : boundary;
+        }
+    }
+    const names = [];
+    for (let current = position; current?.parent; current = current.parent) {
+        signal?.throwIfAborted();
+        names.push(current.name);
+    }
+    names.reverse();
+    for (let index = missing; index < origin.length; index++) {
+        signal?.throwIfAborted();
+        const name = origin[index]?.name;
+        if (name === "..")
+            names.pop();
+        else if (name && name !== ".")
+            names.push(name);
+    }
+    return `/${names.join("/")}`;
+}

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

@@ -1,6 +1,8 @@
 import type { FileSystem } from "../../contracts/filesystem.js";
 export interface FileSystemQuotaOptions {
     readonly maxBytes: number;
+    readonly maxScanEntries?: number;
+    readonly maxScanDepth?: number;
 }
 export declare class FileSystemQuotaError extends Error {
     readonly maxBytes: number;

package/dist/safe-fs/fs/quota/index.js

@@ -1,5 +1,6 @@
 import { FsError } from "../../contracts/errors.js";
 import { quotaCapabilities } from "../capabilities.js";
+import { admitDirectoryEntries } from "../directory-admission.js";
 export class FileSystemQuotaError extends Error {
     maxBytes;
     constructor(maxBytes) {
@@ -8,18 +9,37 @@ export class FileSystemQuotaError extends Error {
         this.name = "FileSystemQuotaError";
     }
 }
-async function usedBytes(fs, options, change) {
+async function usedBytes(fs, limits, options, change) {
     let total = 0;
     let possibleAliases = 0;
-    const pending = ["/"];
+    let remaining = limits.maxScanEntries;
+    const pending = [{ path: "/", depth: 0 }];
     while (pending.length) {
         options?.signal?.throwIfAborted();
         const directory = pending.pop();
-        for (const entry of await fs.readdir(directory, options)) {
+        if (!directory)
+            break;
+        const signal = options?.signal;
+        const entries = await fs.readdir(directory.path, { ...options, ...(signal ? { signal } : {}), maxEntries: remaining });
+        options?.signal?.throwIfAborted();
+        const count = entries.length;
+        admitDirectoryEntries(count, remaining, directory.path);
+        remaining -= count;
+        let processed = 0;
+        for (const entry of entries) {
             options?.signal?.throwIfAborted();
-            const path = `${directory === "/" ? "" : directory}/${entry.name}`;
-            if (entry.type === "directory")
-                pending.push(path);
+            if (processed >= count) {
+                admitDirectoryEntries(1, remaining, directory.path);
+                remaining--;
+            }
+            processed++;
+            const path = `${directory.path === "/" ? "" : directory.path}/${entry.name}`;
+            if (entry.type === "directory") {
+                const depth = directory.depth + 1;
+                if (depth > limits.maxScanDepth)
+                    throw new FsError("EFBIG", { syscall: "readdir", path, message: "quota scan depth limit exceeded" });
+                pending.push({ path, depth });
+            }
             else {
                 const stat = await fs.lstat(path, options);
                 total += stat.size;
@@ -64,6 +84,14 @@ async function existingBytes(fs, path, options) {
 export function withFileSystemQuota(fs, options) {
     if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0)
         throw new RangeError("maxBytes must be a nonnegative safe integer");
+    const scanLimits = {
+        maxScanEntries: options.maxScanEntries === undefined ? 4096 : options.maxScanEntries,
+        maxScanDepth: options.maxScanDepth === undefined ? 64 : options.maxScanDepth,
+    };
+    for (const [name, value] of Object.entries(scanLimits)) {
+        if (!Number.isSafeInteger(value) || value < 0)
+            throw new RangeError(`${name} must be a nonnegative safe integer`);
+    }
     let queue = Promise.resolve();
     const mutate = (operation) => {
         const result = queue.then(operation);
@@ -81,8 +109,8 @@ export function withFileSystemQuota(fs, options) {
                 throw error;
         }
         const projected = current?.type === "file" && nextBytes > current.size
-            ? await usedBytes(fs, fsOptions, { path, stat: current, delta: nextBytes - current.size })
-            : await usedBytes(fs, fsOptions) - (current?.type === "directory" ? 0 : current?.size ?? 0) + nextBytes;
+            ? await usedBytes(fs, scanLimits, fsOptions, { path, stat: current, delta: nextBytes - current.size })
+            : await usedBytes(fs, scanLimits, fsOptions) - (current?.type === "directory" ? 0 : current?.size ?? 0) + nextBytes;
         fsOptions?.signal?.throwIfAborted();
         if (projected > options.maxBytes)
             throw new FileSystemQuotaError(options.maxBytes);
@@ -142,6 +170,8 @@ export function withFileSystemQuota(fs, options) {
     // capabilities and methods without violating invariants on own properties.
     return new Proxy(Object.create(fs), {
         get(_target, property) {
+            if (property === "canonicalizeMissingTarget")
+                return undefined;
             if (property === "capabilities")
                 return quotaCapabilities(fs.capabilities);
             if (property === "capabilitiesFor")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-fs",
-  "version": "0.1.145",
+  "version": "0.1.146",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",