@poe-platform/safe-fs 0.1.512 → 0.1.513

package/dist/safe-fs/bridge/stats.js

@@ -19,7 +19,7 @@ export function bridgeStats(stat) {
         gid: stat.gid ?? 0,
         rdev: 0,
         size: stat.size,
-        blksize: 4096,
+        blksize: stat.preferredIoBlockSize ?? 4096,
         blocks: Math.ceil(stat.size / 512),
         atimeMs: stat.atimeMs,
         mtimeMs: stat.mtimeMs,

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

@@ -27,6 +27,7 @@ declare const descriptions: {
     readonly EPERM: "operation not permitted";
     readonly EPIPE: "broken pipe";
     readonly EROFS: "read-only file system";
+    readonly ESPIPE: "invalid seek";
     readonly ETIMEDOUT: "operation timed out";
     readonly EXDEV: "cross-device link not permitted";
 };

package/dist/safe-fs/contracts/errors.js

@@ -26,6 +26,7 @@ const descriptions = {
     EPERM: "operation not permitted",
     EPIPE: "broken pipe",
     EROFS: "read-only file system",
+    ESPIPE: "invalid seek",
     ETIMEDOUT: "operation timed out",
     EXDEV: "cross-device link not permitted",
 };

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

@@ -5,6 +5,7 @@ export interface FileStat {
     readonly type: FileType;
     readonly size: number;
     readonly allocatedBytes?: number;
+    readonly preferredIoBlockSize?: number;
     readonly mode: number;
     readonly mtimeMs: number;
     readonly atimeMs: number;
@@ -54,6 +55,7 @@ export interface FileSystemCapabilities {
     readonly snapshotRmdir?: boolean;
     readonly streamingRead?: boolean;
     readonly retainedRead?: boolean;
+    readonly retainedResize?: boolean;
     readonly streamingWrite?: boolean;
     readonly descriptorWriteStream?: boolean;
     readonly [capability: string]: boolean | undefined;
@@ -61,9 +63,26 @@ export interface FileSystemCapabilities {
 export interface FsOptions {
     readonly signal?: AbortSignal;
 }
+export interface OpenReadFileOptions extends FsOptions {
+    readonly allowDirectory?: boolean;
+}
+export interface CapabilityQueryOptions extends OpenReadFileOptions {
+    readonly create?: boolean;
+}
 export interface FileReadHandle {
     stat(options?: FsOptions): Promise<FileStat>;
     read(position: number, maxBytes: number, options?: FsOptions): Promise<Uint8Array>;
+    seekEnd?: ((options?: FsOptions) => Promise<bigint>) | undefined;
+    close(): Promise<void>;
+}
+export interface OpenResizeFileOptions extends FsOptions {
+    readonly create?: boolean;
+    readonly mode?: number;
+}
+export interface FileResizeHandle {
+    stat(options?: FsOptions): Promise<FileStat>;
+    truncate(length: number, options?: FsOptions): Promise<void>;
+    seekEnd?: ((options?: FsOptions) => Promise<bigint>) | undefined;
     close(): Promise<void>;
 }
 export interface RenameOptions extends FsOptions {
@@ -107,9 +126,10 @@ export interface ReadStreamOptions extends FsOptions {
 }
 export interface FileSystem {
     readonly capabilities: FileSystemCapabilities;
-    openReadFile?(path: string, options?: FsOptions): Promise<FileReadHandle>;
+    openReadFile?(path: string, options?: OpenReadFileOptions): Promise<FileReadHandle>;
+    openResizeFile?(path: string, options?: OpenResizeFileOptions): Promise<FileResizeHandle>;
     canonicalizeMissingTarget?(path: string, options?: FsOptions): string | undefined;
-    capabilitiesFor?(path: string, options?: FsOptions): Promise<FileSystemCapabilities>;
+    capabilitiesFor?(path: string, options?: CapabilityQueryOptions): Promise<FileSystemCapabilities>;
     readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
     writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
     appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;

package/dist/safe-fs/fs/capabilities.d.ts

@@ -1,6 +1,8 @@
-import type { FileReadHandle, FileSystem, FileSystemCapabilities, FsOptions } from "../contracts/filesystem.js";
+import type { FileReadHandle, FileResizeHandle, FileSystem, FileSystemCapabilities, OpenReadFileOptions, OpenResizeFileOptions } from "../contracts/filesystem.js";
 export declare function retainedReadCapabilities(filesystem: FileSystem, capabilities?: FileSystemCapabilities): FileSystemCapabilities;
-export declare function openRetainedReadFile(filesystem: FileSystem, path: string, options: FsOptions): Promise<FileReadHandle>;
+export declare function openRetainedReadFile(filesystem: FileSystem, path: string, options: OpenReadFileOptions): Promise<FileReadHandle>;
 export declare function requireCapabilities(...values: readonly (boolean | undefined)[]): boolean | undefined;
+export declare function retainedResizeCapabilities(filesystem: FileSystem, capabilities?: FileSystemCapabilities): FileSystemCapabilities;
+export declare function openRetainedResizeFile(filesystem: FileSystem, path: string, options: OpenResizeFileOptions): Promise<FileResizeHandle>;
 export declare function readOnlyCapabilities(capabilities: FileSystemCapabilities): FileSystemCapabilities;
 export declare function quotaCapabilities(capabilities: FileSystemCapabilities): FileSystemCapabilities;

package/dist/safe-fs/fs/capabilities.js

@@ -4,29 +4,100 @@ export function retainedReadCapabilities(filesystem, capabilities = filesystem.c
     return typeof filesystem.openReadFile === "function" ? capabilities : { ...capabilities, retainedRead: false };
 }
 export async function openRetainedReadFile(filesystem, path, options) {
+    const signal = options.signal;
     let handle;
     try {
-        options.signal?.throwIfAborted();
-        if (typeof filesystem.openReadFile !== "function")
+        signal?.throwIfAborted();
+        const available = typeof filesystem.openReadFile === "function";
+        signal?.throwIfAborted();
+        if (!available)
             throw new FsError("ENOTSUP", { syscall: "openReadFile", path });
-        const capabilities = await filesystem.capabilitiesFor?.(path, options) ?? filesystem.capabilities;
-        options.signal?.throwIfAborted();
-        if (retainedReadCapabilities(filesystem, capabilities).retainedRead !== true)
+        const query = filesystem.capabilitiesFor;
+        signal?.throwIfAborted();
+        const metadata = Promise.resolve(query == null ? undefined : Reflect.apply(query, filesystem, [path, options]));
+        const queried = await (signal ? new Promise((resolve, reject) => {
+            const abort = () => { signal.removeEventListener("abort", abort); reject(signal.reason); };
+            signal.addEventListener("abort", abort, { once: true });
+            metadata.then(value => { signal.removeEventListener("abort", abort); resolve(value); }, error => { signal.removeEventListener("abort", abort); reject(error); });
+            if (signal.aborted)
+                abort();
+        }) : metadata);
+        signal?.throwIfAborted();
+        const capabilities = queried ?? filesystem.capabilities;
+        signal?.throwIfAborted();
+        const supported = capabilities.retainedRead;
+        signal?.throwIfAborted();
+        if (supported !== true)
             throw new FsError("ENOTSUP", { syscall: "openReadFile", path });
-        handle = await filesystem.openReadFile(path, options);
-        options.signal?.throwIfAborted();
+        const acquire = filesystem.openReadFile;
+        signal?.throwIfAborted();
+        if (typeof acquire !== "function")
+            throw new FsError("ENOTSUP", { syscall: "openReadFile", path });
+        handle = await Reflect.apply(acquire, filesystem, [path, options]);
+        signal?.throwIfAborted();
         return handle;
     }
     catch (error) {
         if (handle)
             await finishCleanup(() => handle.close(), true);
-        options.signal?.throwIfAborted();
+        signal?.throwIfAborted();
         throw error;
     }
 }
 export function requireCapabilities(...values) {
     return values.some(value => value === false) ? false : values.every(value => value === true) ? true : undefined;
 }
+export function retainedResizeCapabilities(filesystem, capabilities = filesystem.capabilities) {
+    if (capabilities.retainedResize !== true)
+        return capabilities;
+    return typeof filesystem.openResizeFile === "function" && capabilities.readOnly !== true
+        ? capabilities : { ...capabilities, retainedResize: false };
+}
+export async function openRetainedResizeFile(filesystem, path, options) {
+    const signal = options.signal;
+    let handle;
+    try {
+        signal?.throwIfAborted();
+        const available = typeof filesystem.openResizeFile === "function";
+        signal?.throwIfAborted();
+        if (!available)
+            throw new FsError("ENOTSUP", { syscall: "openResizeFile", path });
+        const query = filesystem.capabilitiesFor;
+        signal?.throwIfAborted();
+        const intent = { ...(signal === undefined ? {} : { signal }), create: options.create === true };
+        signal?.throwIfAborted();
+        const metadata = Promise.resolve(query === undefined ? filesystem.capabilities : Reflect.apply(query, filesystem, [path, intent]));
+        const capabilities = await (signal ? new Promise((resolve, reject) => {
+            const abort = () => { signal.removeEventListener("abort", abort); reject(signal.reason); };
+            signal.addEventListener("abort", abort, { once: true });
+            metadata.then(value => { signal.removeEventListener("abort", abort); resolve(value); }, error => { signal.removeEventListener("abort", abort); reject(error); });
+            if (signal.aborted)
+                abort();
+        }) : metadata);
+        signal?.throwIfAborted();
+        const readOnly = capabilities.readOnly;
+        signal?.throwIfAborted();
+        if (readOnly === true)
+            throw new FsError("EROFS", { syscall: "openResizeFile", path });
+        const supported = capabilities.retainedResize;
+        signal?.throwIfAborted();
+        if (supported !== true)
+            throw new FsError("ENOTSUP", { syscall: "openResizeFile", path });
+        const acquire = filesystem.openResizeFile;
+        signal?.throwIfAborted();
+        if (typeof acquire !== "function")
+            throw new FsError("ENOTSUP", { syscall: "openResizeFile", path });
+        handle = await Reflect.apply(acquire, filesystem, [path, options]);
+        signal?.throwIfAborted();
+        return handle;
+    }
+    catch (error) {
+        if (handle)
+            await finishCleanup(() => handle.close(), true);
+        signal?.throwIfAborted();
+        throw error;
+    }
+}
 export function readOnlyCapabilities(capabilities) {
     const inspection = Object.fromEntries([
         "read", "stat", "readdir", "realpath", "access", "readlink", "explicitDirectories", "implicitDirectories",
@@ -37,7 +108,7 @@ export function readOnlyCapabilities(capabilities) {
         mkdir: false, recursiveMkdir: false, remove: false, removeDirectory: false, recursiveRemove: false,
         rename: false, copy: false, exclusiveCopy: false, truncate: false, streamingAppend: false,
         randomAccessWrite: false, hardlinks: false, permissions: false, timestamps: false,
-        descriptorWriteStream: false,
+        descriptorWriteStream: false, retainedResize: false,
         atomicRename: false, atomicRenameNoReplace: false, streamingWrite: false,
     });
 }

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

@@ -1,18 +1,19 @@
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileReadHandle, FileStat, FileSystem, FileSystemCapabilities, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CapabilityQueryOptions, CopyFileOptions, DirectoryEntry, FileReadHandle, FileResizeHandle, FileStat, FileSystem, OpenReadFileOptions, OpenResizeFileOptions, FileSystemCapabilities, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 import type { ByteSource } from "../../contracts/io.js";
 export declare class DeviceFileSystem implements FileSystem {
     #private;
     readonly capabilities: FileSystemCapabilities;
     constructor(filesystem: FileSystem);
     canonicalizeMissingTarget(path: string, options?: FsOptions): string | undefined;
-    capabilitiesFor(path: string, options?: FsOptions): Promise<FileSystemCapabilities>;
+    capabilitiesFor(path: string, options?: CapabilityQueryOptions): Promise<FileSystemCapabilities>;
     stat(path: string, options?: FsOptions): Promise<FileStat>;
     lstat(path: string, options?: FsOptions): Promise<FileStat>;
     compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<import("../../contracts/filesystem.js").EntryComparison>;
     realpath(path: string, options?: FsOptions): Promise<string>;
     readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
     readStream(path: string, options?: ReadStreamOptions): ByteSource;
-    openReadFile(path: string, options?: FsOptions): Promise<FileReadHandle>;
+    openReadFile(path: string, options?: OpenReadFileOptions): Promise<FileReadHandle>;
+    openResizeFile(path: string, options?: OpenResizeFileOptions): Promise<FileResizeHandle>;
     writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
     appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
     writeStream(path: string, source: ByteSource, options?: WriteFileOptions): Promise<void>;

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

@@ -3,6 +3,8 @@ import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admissi
 import { compareEntries, registerEntryView } from "../mount/comparison.js";
 import { deviceDirectory, lexicalDevicePath, nullPath, resolveDevicePath } from "./path.js";
 import { deviceReadStream, drainDeviceFile, drainDeviceInput } from "./stream.js";
+import { openRetainedReadFile, openRetainedResizeFile, retainedResizeCapabilities } from "../capabilities.js";
+import { pathNamespace } from "../path-namespace.js";
 const views = new WeakMap();
 const deviceCapabilities = Object.freeze({
     readOnly: false, read: true, stat: true, realpath: true, access: true, readdir: false,
@@ -11,13 +13,13 @@ const deviceCapabilities = Object.freeze({
     remove: false, removeDirectory: false, recursiveRemove: false, rename: false,
     mkdir: false, recursiveMkdir: false, symlinks: false, hardlinks: false, readlink: false,
     permissions: false, timestamps: false, truncate: false, randomAccessWrite: false,
-    atomicRename: false, atomicRenameNoReplace: false, descriptorWriteStream: true,
+    atomicRename: false, atomicRenameNoReplace: false, descriptorWriteStream: true, retainedResize: true,
 });
 function globalCapabilities(filesystem) {
     const capabilities = { readOnly: false };
     const optional = {
         streamingRead: ["readStream"], streamingWrite: ["writeStream"], retainedRead: ["openReadFile"],
-        streamingAppend: ["writeStream"], descriptorWriteStream: ["writeStream"],
+        streamingAppend: ["writeStream"], descriptorWriteStream: ["writeStream"], retainedResize: ["openResizeFile"],
         symlinks: ["symlink", "readlink"], hardlinks: ["link"], permissions: ["chmod"],
         timestamps: ["utimes"], readlink: ["readlink"], truncate: ["truncate"], removeDirectory: ["rmdir"],
     };
@@ -30,6 +32,8 @@ function globalCapabilities(filesystem) {
                 let declared = filesystem.capabilities[key];
                 if (declared === true && optional[key]?.some(method => typeof filesystem[method] !== "function"))
                     declared = false;
+                if (key === "retainedResize" && filesystem.capabilities.readOnly === true)
+                    declared = false;
                 if (key === "descriptorWriteStream" && filesystem.capabilities.streamingWrite === false)
                     declared = false;
                 return declared === deviceCapabilities[key] ? declared : undefined;
@@ -49,11 +53,13 @@ export class DeviceFileSystem {
     #directoryStat;
     constructor(filesystem) {
         this.#filesystem = filesystem;
+        Object.defineProperty(this, pathNamespace, { get: () => Reflect.get(filesystem, pathNamespace) });
         this.capabilities = globalCapabilities(filesystem);
         const identityScope = Object.freeze({});
-        this.#nullStat = Object.freeze({ type: "character", mode: 0o020666, size: 0, allocatedBytes: 0,
-            mtimeMs: 0, atimeMs: 0, ctimeMs: 0, birthtimeMs: 0, identityScope, ino: 1, dev: 0, nlink: 1 });
-        this.#directoryStat = Object.freeze({ ...this.#nullStat, type: "directory", mode: 0o040755, ino: 2 });
+        const stat = { mode: 0o020666, size: 0, allocatedBytes: 0,
+            mtimeMs: 0, atimeMs: 0, ctimeMs: 0, birthtimeMs: 0, identityScope, ino: 1, dev: 0, nlink: 1 };
+        this.#nullStat = Object.freeze({ ...stat, type: "character", preferredIoBlockSize: 4096 });
+        this.#directoryStat = Object.freeze({ ...stat, type: "directory", mode: 0o040755, ino: 2 });
         const methods = new Map();
         const view = new Proxy(this, {
             set: (_target, property, value) => Reflect.set(filesystem, property, value, filesystem),
@@ -80,8 +86,8 @@ export class DeviceFileSystem {
             });
         return view;
     }
-    #resolve(path, options, followFinal = true) {
-        return resolveDevicePath(this.#filesystem, path, options, followFinal);
+    #resolve(path, options, followFinal = true, resizeCreate) {
+        return resolveDevicePath(this.#filesystem, path, options, followFinal, resizeCreate);
     }
     async #mutable(path, options, followFinal = true) {
         if (reserved(await this.#resolve(path, options, followFinal)))
@@ -106,14 +112,23 @@ export class DeviceFileSystem {
         return reserved(resolved) ? resolved : this.#filesystem.canonicalizeMissingTarget?.(path, options);
     }
     async capabilitiesFor(path, options = {}) {
-        const resolved = await this.#resolve(path, options);
+        const resolved = await this.#resolve(path, options, true, options.create);
+        options.signal?.throwIfAborted();
+        if (options.create !== undefined && (resolved === deviceDirectory || resolved === "/"))
+            throw new FsError("EISDIR", { syscall: "capabilitiesFor", path });
         if (resolved === nullPath)
             return deviceCapabilities;
         if (resolved === deviceDirectory)
             return { ...deviceCapabilities, readdir: true, write: false, append: false,
                 exclusiveCreate: false, streamingWrite: false, streamingAppend: false, descriptorWriteStream: false,
-                retainedRead: false, streamingRead: false, copy: false, exclusiveCopy: false };
-        const capabilities = await this.#filesystem.capabilitiesFor?.(path, options) ?? this.#filesystem.capabilities;
+                retainedRead: false, retainedResize: false, streamingRead: false, copy: false, exclusiveCopy: false };
+        const query = this.#filesystem.capabilitiesFor;
+        options.signal?.throwIfAborted();
+        const selected = query === undefined || query === null ? undefined : await Reflect.apply(query, this.#filesystem, [path, options]);
+        options.signal?.throwIfAborted();
+        const observed = selected ?? this.#filesystem.capabilities;
+        options.signal?.throwIfAborted();
+        const capabilities = observed.retainedResize === true ? retainedResizeCapabilities(this.#filesystem, observed) : observed;
         const unavailable = {};
         if (typeof this.#filesystem.readStream !== "function")
             unavailable.streamingRead = false;
@@ -124,24 +139,36 @@ export class DeviceFileSystem {
         }
         if (typeof this.#filesystem.openReadFile !== "function")
             unavailable.retainedRead = false;
-        return Object.keys(unavailable).some(key => capabilities[key] !== false)
+        const result = Object.keys(unavailable).some(key => capabilities[key] !== false)
             ? { ...capabilities, ...unavailable } : capabilities;
+        options.signal?.throwIfAborted();
+        return result;
     }
     async stat(path, options = {}) {
         const resolved = await this.#resolve(path, options);
+        options.signal?.throwIfAborted();
         if (resolved === nullPath)
             return { ...this.#nullStat };
         if (resolved === deviceDirectory)
             return { ...this.#directoryStat };
-        return this.#filesystem.stat(path, options);
+        const stat = this.#filesystem.stat;
+        options.signal?.throwIfAborted();
+        const result = await Reflect.apply(stat, this.#filesystem, [path, options]);
+        options.signal?.throwIfAborted();
+        return result;
     }
     async lstat(path, options = {}) {
         const resolved = await this.#resolve(path, options, false);
+        options.signal?.throwIfAborted();
         if (resolved === nullPath)
             return { ...this.#nullStat };
         if (resolved === deviceDirectory)
             return { ...this.#directoryStat };
-        return this.#filesystem.lstat(path, options);
+        const lstat = this.#filesystem.lstat;
+        options.signal?.throwIfAborted();
+        const result = await Reflect.apply(lstat, this.#filesystem, [path, options]);
+        options.signal?.throwIfAborted();
+        return result;
     }
     compareEntry(path, peer, peerPath, options = {}) {
         return compareEntries(this, path, peer, peerPath, options);
@@ -183,9 +210,7 @@ export class DeviceFileSystem {
         if (resolved !== nullPath) {
             if (resolved === deviceDirectory)
                 throw new FsError("EISDIR", { path });
-            if (!this.#filesystem.openReadFile)
-                throw new FsError("ENOTSUP", { path });
-            return this.#filesystem.openReadFile(path, options);
+            return openRetainedReadFile(this.#filesystem, path, options);
         }
         const stat = this.#nullStat;
         let closed = false;
@@ -194,9 +219,43 @@ export class DeviceFileSystem {
         return {
             async stat(settings = {}) { check(settings); return { ...stat }; },
             async read(position, maxBytes, settings = {}) { check(settings); nonnegative(position, path); nonnegative(maxBytes, path); return new Uint8Array(); },
+            async seekEnd(settings = {}) { check(settings); return 0n; },
             async close() { closed = true; },
         };
     }
+    async openResizeFile(path, options = {}) {
+        options.signal?.throwIfAborted();
+        const resolution = this.#resolve(path, options, true, options.create ?? false);
+        const signal = options.signal;
+        const resolved = await (signal ? new Promise((resolve, reject) => {
+            const abort = () => { signal.removeEventListener("abort", abort); reject(signal.reason); };
+            signal.addEventListener("abort", abort, { once: true });
+            resolution.then(value => { signal.removeEventListener("abort", abort); resolve(value); }, error => { signal.removeEventListener("abort", abort); reject(error); });
+            if (signal.aborted)
+                abort();
+        }) : resolution);
+        options.signal?.throwIfAborted();
+        if (resolved === deviceDirectory || resolved === "/")
+            throw new FsError("EISDIR", { syscall: "openResizeFile", path });
+        if (resolved !== nullPath)
+            return openRetainedResizeFile(this.#filesystem, path, options);
+        const stat = this.#nullStat;
+        let closing;
+        const check = (settings, syscall) => {
+            settings.signal?.throwIfAborted();
+            if (closing)
+                throw new FsError("EBADF", { syscall, path });
+        };
+        return {
+            async stat(settings = {}) { check(settings, "fstat"); return { ...stat }; },
+            async seekEnd(settings = {}) { check(settings, "lseek"); return 0n; },
+            async truncate(_length, settings = {}) {
+                check(settings, "ftruncate");
+                throw new FsError("EINVAL", { syscall: "ftruncate", path });
+            },
+            close: () => closing ??= Promise.resolve(),
+        };
+    }
     async writeFile(path, data, options = {}) {
         if (await this.#writeTarget(path, options)) {
             if (!(data instanceof Uint8Array))

package/dist/safe-fs/fs/devices/path.d.ts

@@ -2,4 +2,4 @@ import type { FileSystem, FsOptions } from "../../contracts/filesystem.js";
 export declare const nullPath = "/dev/null";
 export declare const deviceDirectory = "/dev";
 export declare function lexicalDevicePath(path: string): string;
-export declare function resolveDevicePath(filesystem: FileSystem, path: string, options: FsOptions, followFinal?: boolean): Promise<string>;
+export declare function resolveDevicePath(filesystem: FileSystem, path: string, options: FsOptions, followFinal?: boolean, resizeCreate?: boolean): Promise<string>;

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

@@ -1,5 +1,6 @@
 import { FsError, isFsError } from "../../contracts/errors.js";
 import { validatePath } from "../../contracts/virtual-path.js";
+import { capturePathNamespace } from "../path-namespace.js";
 export const nullPath = "/dev/null";
 export const deviceDirectory = "/dev";
 export function lexicalDevicePath(path) {
@@ -15,10 +16,104 @@ export function lexicalDevicePath(path) {
     }
     return `/${parts.join("/")}`;
 }
-export async function resolveDevicePath(filesystem, path, options, followFinal = true) {
+async function resolveResizeDevicePath(filesystem, path, options, create, namespace) {
+    validatePath(path);
+    const components = (value) => {
+        const result = value.split("/").filter(Boolean);
+        if (value.endsWith("/"))
+            result.push("");
+        return result;
+    };
+    const pending = components(path);
+    const parts = [];
+    let links = 0;
+    let expanded = path.length;
+    let boundary;
+    while (pending.length) {
+        options.signal?.throwIfAborted();
+        const component = pending.shift();
+        const current = `/${parts.join("/")}`;
+        if (current === nullPath)
+            throw new FsError("ENOTDIR", { path });
+        if (current !== deviceDirectory) {
+            const observe = filesystem.stat;
+            options.signal?.throwIfAborted();
+            const stat = await Reflect.apply(observe, filesystem, [current, options]);
+            options.signal?.throwIfAborted();
+            if (stat.type !== "directory")
+                throw new FsError("ENOTDIR", { path });
+            if (!(component === "" && pending.length === 0)) {
+                const access = filesystem.access;
+                options.signal?.throwIfAborted();
+                await Reflect.apply(access, filesystem, [current, 1, options]);
+                options.signal?.throwIfAborted();
+            }
+        }
+        if (component === "." || component === "")
+            continue;
+        if (component === "..") {
+            if (boundary !== undefined && current === boundary)
+                throw new FsError("EACCES", { path });
+            parts.pop();
+            continue;
+        }
+        if (new TextEncoder().encode(component).byteLength > 255)
+            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 (create && pending.length === 1 && pending[0] === "")
+            throw new FsError("EISDIR", { path });
+        if (candidate !== deviceDirectory && candidate !== nullPath) {
+            let stat;
+            const lstat = filesystem.lstat;
+            options.signal?.throwIfAborted();
+            try {
+                stat = await Reflect.apply(lstat, filesystem, [candidate, options]);
+            }
+            catch (error) {
+                options.signal?.throwIfAborted();
+                if (!(isFsError(error, "ENOENT") && create && pending.length === 0))
+                    throw error;
+            }
+            options.signal?.throwIfAborted();
+            if (stat?.type === "symlink") {
+                boundary ??= selected;
+                const readlink = filesystem.readlink;
+                options.signal?.throwIfAborted();
+                if (typeof readlink !== "function")
+                    throw new FsError("ENOTSUP", { path });
+                if (++links > 40)
+                    throw new FsError("ELOOP", { path });
+                const target = await Reflect.apply(readlink, filesystem, [candidate, options]);
+                options.signal?.throwIfAborted();
+                validatePath(target);
+                expanded += target.length;
+                if (expanded > 65536)
+                    throw new FsError("ENAMETOOLONG", { path });
+                if (target.startsWith("/"))
+                    parts.splice(0, parts.length, ...(boundary ?? "/").split("/").filter(Boolean));
+                const targetParts = components(target);
+                if (targetParts.at(-1) === "" && pending[0] === "")
+                    targetParts.pop();
+                pending.unshift(...targetParts);
+                continue;
+            }
+        }
+        parts.push(component);
+    }
+    return `/${parts.join("/")}`;
+}
+export async function resolveDevicePath(filesystem, path, options, followFinal = true, resizeCreate) {
     options.signal?.throwIfAborted();
+    const namespace = capturePathNamespace(filesystem, options);
+    if (resizeCreate !== undefined)
+        return resolveResizeDevicePath(filesystem, path, options, resizeCreate, namespace);
     const lexical = lexicalDevicePath(path);
-    const aliases = typeof filesystem.lstat === "function";
+    const lstat = filesystem.lstat;
+    options.signal?.throwIfAborted();
+    const aliases = typeof lstat === "function";
     if (!aliases && lexical !== nullPath && lexical !== deviceDirectory && lexical !== "/")
         return lexical;
     const pending = path.split("/");
@@ -27,6 +122,7 @@ export async function resolveDevicePath(filesystem, path, options, followFinal =
     let expanded = path.length;
     let absolute = path.startsWith("/");
     let traversalFailure;
+    let boundary;
     while (pending.length) {
         options.signal?.throwIfAborted();
         if (`/${parts.join("/")}` === nullPath)
@@ -35,17 +131,22 @@ export async function resolveDevicePath(filesystem, path, options, followFinal =
         if (!component || component === ".")
             continue;
         if (component === "..") {
+            if (boundary !== undefined && `/${parts.join("/")}` === boundary)
+                throw new FsError("EACCES", { path });
             parts.pop();
             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)) {
             const lookup = absolute ? candidate : candidate.slice(1);
             let stat;
             try {
-                if (typeof filesystem.lstat !== "function")
+                if (typeof lstat !== "function")
                     throw new FsError("ENOTSUP", { path });
-                stat = await filesystem.lstat(lookup, options);
+                stat = await Reflect.apply(lstat, filesystem, [lookup, options]);
             }
             catch (error) {
                 options.signal?.throwIfAborted();
@@ -58,18 +159,21 @@ export async function resolveDevicePath(filesystem, path, options, followFinal =
             }
             options.signal?.throwIfAborted();
             if (stat?.type === "symlink") {
-                if (typeof filesystem.readlink !== "function")
+                boundary ??= selected;
+                const readlink = filesystem.readlink;
+                options.signal?.throwIfAborted();
+                if (typeof readlink !== "function")
                     throw new FsError("ENOTSUP", { path });
                 if (++links > 40)
                     throw new FsError("ELOOP", { path });
-                const target = await filesystem.readlink(lookup, options);
+                const target = await Reflect.apply(readlink, filesystem, [lookup, options]);
                 options.signal?.throwIfAborted();
                 validatePath(target);
                 expanded += target.length;
                 if (expanded > 65536)
                     throw new FsError("ENAMETOOLONG", { path });
                 if (target.startsWith("/")) {
-                    parts.length = 0;
+                    parts.splice(0, parts.length, ...(boundary ?? "/").split("/").filter(Boolean));
                     absolute = true;
                 }
                 pending.unshift(...target.split("/"));

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

@@ -1,4 +1,4 @@
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileReadHandle, FileStat, FileSystem, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileReadHandle, FileResizeHandle, FileStat, FileSystem, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, OpenReadFileOptions, OpenResizeFileOptions, WriteFileOptions } 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";
@@ -35,6 +35,7 @@ export declare class MemoryFileSystem implements FileSystem {
         atomicRename: true;
         streamingRead: true;
         retainedRead: true;
+        readonly retainedResize: boolean;
         streamingWrite: true;
         readonly descriptorWriteStream: boolean;
     }>;
@@ -87,7 +88,9 @@ export declare class MemoryFileSystem implements FileSystem {
     chmod(path: string, mode: number, options?: FsOptions): Promise<void>;
     utimes(path: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
     truncate(path: string, length?: number, options?: FsOptions): Promise<void>;
-    openReadFile(path: string, options?: FsOptions): Promise<FileReadHandle>;
+    private resizeNode;
+    openResizeFile(path: string, options?: OpenResizeFileOptions): Promise<FileResizeHandle>;
+    openReadFile(path: string, options?: OpenReadFileOptions): Promise<FileReadHandle>;
     readStream(path: string, options?: ReadStreamOptions): ByteSource;
     writeStream(path: string, source: ByteSource, options?: WriteFileOptions): Promise<void>;
 }