@poe-platform/safe-fs 0.1.501 → 0.1.503

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

@@ -4,7 +4,7 @@ function predicates(type) {
         isDirectory: () => type === "directory",
         isSymbolicLink: () => type === "symlink",
         isBlockDevice: () => false,
-        isCharacterDevice: () => false,
+        isCharacterDevice: () => type === "character",
         isFIFO: () => false,
         isSocket: () => false,
     };
@@ -13,7 +13,7 @@ export function bridgeStats(stat) {
     return {
         dev: stat.dev ?? 0,
         ino: stat.ino ?? 0,
-        mode: (stat.mode & 0o7777) | (stat.type === "directory" ? 0o040000 : stat.type === "symlink" ? 0o120000 : 0o100000),
+        mode: (stat.mode & 0o7777) | (stat.type === "directory" ? 0o040000 : stat.type === "symlink" ? 0o120000 : stat.type === "character" ? 0o020000 : 0o100000),
         nlink: stat.nlink ?? 1,
         uid: stat.uid ?? 0,
         gid: stat.gid ?? 0,

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

@@ -1,5 +1,5 @@
 import type { ByteSource } from "./io.js";
-export type FileType = "file" | "directory" | "symlink";
+export type FileType = "file" | "directory" | "symlink" | "character";
 export type EntryComparison = "same" | "distinct" | "unknown";
 export interface FileStat {
     readonly type: FileType;
@@ -50,6 +50,7 @@ export interface FileSystemCapabilities {
     readonly permissions?: boolean;
     readonly timestamps?: boolean;
     readonly atomicRename?: boolean;
+    readonly atomicRenameNoReplace?: boolean;
     readonly snapshotRmdir?: boolean;
     readonly streamingRead?: boolean;
     readonly retainedRead?: boolean;
@@ -65,6 +66,9 @@ export interface FileReadHandle {
     read(position: number, maxBytes: number, options?: FsOptions): Promise<Uint8Array>;
     close(): Promise<void>;
 }
+export interface RenameOptions extends FsOptions {
+    readonly noReplace?: boolean;
+}
 export interface ReadFileOptions extends FsOptions {
     readonly maxBytes?: number;
 }
@@ -116,7 +120,7 @@ export interface FileSystem {
     mkdir(path: string, options?: MkdirOptions): Promise<void>;
     rm(path: string, options?: RemoveOptions): Promise<void>;
     rmdir?(path: string, options?: FsOptions): Promise<void>;
-    rename(source: string, destination: string, options?: FsOptions): Promise<void>;
+    rename(source: string, destination: string, options?: RenameOptions): Promise<void>;
     copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
     realpath(path: string, options?: FsOptions): Promise<string>;
     access(path: string, mode?: number, options?: FsOptions): Promise<void>;

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

@@ -4,6 +4,7 @@ export * from "./contracts/io.js";
 export { assertPathWithin, isPathWithin, normalizePath, relativePath, resolvePath, validatePath } from "./contracts/virtual-path.js";
 export { basename, dirname, extname, isAbsolutePath, joinPath, posixPath } from "./contracts/portable-path.js";
 export * from "./fs/memory/index.js";
+export * from "./fs/devices/index.js";
 export * from "./fs/readonly/index.js";
 export * from "./fs/mount/index.js";
 export * from "./fs/overlay/index.js";

package/dist/safe-fs/core.js

@@ -4,6 +4,7 @@ export * from "./contracts/io.js";
 export { assertPathWithin, isPathWithin, normalizePath, relativePath, resolvePath, validatePath } from "./contracts/virtual-path.js";
 export { basename, dirname, extname, isAbsolutePath, joinPath, posixPath } from "./contracts/portable-path.js";
 export * from "./fs/memory/index.js";
+export * from "./fs/devices/index.js";
 export * from "./fs/readonly/index.js";
 export * from "./fs/mount/index.js";
 export * from "./fs/overlay/index.js";

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

@@ -38,7 +38,7 @@ export function readOnlyCapabilities(capabilities) {
         rename: false, copy: false, exclusiveCopy: false, truncate: false, streamingAppend: false,
         randomAccessWrite: false, hardlinks: false, permissions: false, timestamps: false,
         descriptorWriteStream: false,
-        atomicRename: false, streamingWrite: false,
+        atomicRename: false, atomicRenameNoReplace: false, streamingWrite: false,
     });
 }
 export function quotaCapabilities(capabilities) {

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

@@ -0,0 +1,33 @@
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileReadHandle, FileStat, FileSystem, 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>;
+    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>;
+    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>;
+    readdir(path: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    rm(path: string, options?: RemoveOptions): Promise<void>;
+    rmdir(path: string, options?: FsOptions): Promise<void>;
+    rename(source: string, destination: string, options?: RenameOptions): Promise<void>;
+    copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
+    access(path: string, mode?: number, options?: FsOptions): Promise<void>;
+    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>;
+    utimes(path: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
+    truncate(path: string, length?: number, options?: FsOptions): Promise<void>;
+}
+export declare function createDeviceFileSystem(filesystem: FileSystem): DeviceFileSystem;

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

@@ -0,0 +1,379 @@
+import { FsError, isFsError } from "../../contracts/errors.js";
+import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
+import { compareEntries, registerEntryView } from "../mount/comparison.js";
+import { deviceDirectory, lexicalDevicePath, nullPath, resolveDevicePath } from "./path.js";
+import { deviceReadStream, drainDeviceFile, drainDeviceInput } from "./stream.js";
+const views = new WeakMap();
+const deviceCapabilities = Object.freeze({
+    readOnly: false, read: true, stat: true, realpath: true, access: true, readdir: false,
+    write: true, append: true, exclusiveCreate: true, streamingRead: true, retainedRead: true,
+    streamingWrite: true, streamingAppend: true, copy: true, exclusiveCopy: true,
+    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,
+});
+function globalCapabilities(filesystem) {
+    const capabilities = { readOnly: false };
+    const optional = {
+        streamingRead: ["readStream"], streamingWrite: ["writeStream"], retainedRead: ["openReadFile"],
+        streamingAppend: ["writeStream"], descriptorWriteStream: ["writeStream"],
+        symlinks: ["symlink", "readlink"], hardlinks: ["link"], permissions: ["chmod"],
+        timestamps: ["utimes"], readlink: ["readlink"], truncate: ["truncate"], removeDirectory: ["rmdir"],
+    };
+    for (const key of new Set([...Object.keys(filesystem.capabilities), ...Object.keys(deviceCapabilities)])) {
+        if (key === "readOnly")
+            continue;
+        Object.defineProperty(capabilities, key, { enumerable: true, get() {
+                if (key === "copy" || key === "exclusiveCopy")
+                    return undefined;
+                let declared = filesystem.capabilities[key];
+                if (declared === true && optional[key]?.some(method => typeof filesystem[method] !== "function"))
+                    declared = false;
+                if (key === "descriptorWriteStream" && filesystem.capabilities.streamingWrite === false)
+                    declared = false;
+                return declared === deviceCapabilities[key] ? declared : undefined;
+            } });
+    }
+    return Object.freeze(capabilities);
+}
+function reserved(path) { return path === "/" || path === deviceDirectory || path === nullPath; }
+function nonnegative(value, path) {
+    if (value !== undefined && (!Number.isSafeInteger(value) || value < 0))
+        throw new FsError("EINVAL", { path });
+}
+export class DeviceFileSystem {
+    #filesystem;
+    capabilities;
+    #nullStat;
+    #directoryStat;
+    constructor(filesystem) {
+        this.#filesystem = filesystem;
+        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 methods = new Map();
+        const view = new Proxy(this, {
+            set: (_target, property, value) => Reflect.set(filesystem, property, value, filesystem),
+            get(target, property) {
+                const value = Reflect.get(target, property, target);
+                if (typeof value !== "function" || property === "constructor")
+                    return value;
+                const backing = Reflect.get(filesystem, property, filesystem);
+                const cached = methods.get(property);
+                if (cached && cached.backing === backing)
+                    return cached.bound;
+                const bound = value.bind(target);
+                methods.set(property, { backing, bound });
+                return bound;
+            },
+        });
+        for (const identity of [this, view])
+            registerEntryView(identity, async (path, options) => {
+                const resolved = await this.#resolve(path, options);
+                if (resolved === nullPath || resolved === deviceDirectory)
+                    return { filesystem: this, path: resolved,
+                        stat: resolved === nullPath ? this.#nullStat : this.#directoryStat, readOnly: false };
+                return { filesystem, path };
+            });
+        return view;
+    }
+    #resolve(path, options, followFinal = true) {
+        return resolveDevicePath(this.#filesystem, path, options, followFinal);
+    }
+    async #mutable(path, options, followFinal = true) {
+        if (reserved(await this.#resolve(path, options, followFinal)))
+            throw new FsError("EBUSY", { path });
+    }
+    async #writeTarget(path, options) {
+        const resolved = await this.#resolve(path, options);
+        if (resolved === nullPath) {
+            if (options.flag === "wx" || options.flag === "ax")
+                throw new FsError("EEXIST", { path });
+            if (options.flag !== undefined && options.flag !== "w" && options.flag !== "a")
+                throw new FsError("EINVAL", { path });
+            return true;
+        }
+        if (resolved === "/" || resolved === deviceDirectory)
+            throw new FsError("EISDIR", { path });
+        return false;
+    }
+    canonicalizeMissingTarget(path, options = {}) {
+        options.signal?.throwIfAborted();
+        const resolved = lexicalDevicePath(path);
+        return reserved(resolved) ? resolved : this.#filesystem.canonicalizeMissingTarget?.(path, options);
+    }
+    async capabilitiesFor(path, options = {}) {
+        const resolved = await this.#resolve(path, options);
+        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;
+        const unavailable = {};
+        if (typeof this.#filesystem.readStream !== "function")
+            unavailable.streamingRead = false;
+        if (typeof this.#filesystem.writeStream !== "function") {
+            unavailable.streamingWrite = false;
+            unavailable.streamingAppend = false;
+            unavailable.descriptorWriteStream = false;
+        }
+        if (typeof this.#filesystem.openReadFile !== "function")
+            unavailable.retainedRead = false;
+        return Object.keys(unavailable).some(key => capabilities[key] !== false)
+            ? { ...capabilities, ...unavailable } : capabilities;
+    }
+    async stat(path, options = {}) {
+        const resolved = await this.#resolve(path, options);
+        if (resolved === nullPath)
+            return { ...this.#nullStat };
+        if (resolved === deviceDirectory)
+            return { ...this.#directoryStat };
+        return this.#filesystem.stat(path, options);
+    }
+    async lstat(path, options = {}) {
+        const resolved = await this.#resolve(path, options, false);
+        if (resolved === nullPath)
+            return { ...this.#nullStat };
+        if (resolved === deviceDirectory)
+            return { ...this.#directoryStat };
+        return this.#filesystem.lstat(path, options);
+    }
+    compareEntry(path, peer, peerPath, options = {}) {
+        return compareEntries(this, path, peer, peerPath, options);
+    }
+    async realpath(path, options = {}) {
+        const resolved = await this.#resolve(path, options);
+        return reserved(resolved) ? resolved : this.#filesystem.realpath(path, options);
+    }
+    async readFile(path, options = {}) {
+        const resolved = await this.#resolve(path, options);
+        if (resolved === nullPath) {
+            nonnegative(options.maxBytes, path);
+            return new Uint8Array();
+        }
+        if (resolved === deviceDirectory)
+            throw new FsError("EISDIR", { path });
+        return this.#filesystem.readFile(path, options);
+    }
+    readStream(path, options = {}) {
+        return deviceReadStream(async () => {
+            const resolved = await this.#resolve(path, options);
+            if (resolved === nullPath) {
+                nonnegative(options.start, path);
+                nonnegative(options.endExclusive, path);
+                nonnegative(options.chunkSize, path);
+                if (options.chunkSize === 0 || (options.endExclusive !== undefined && options.endExclusive < (options.start ?? 0)))
+                    throw new FsError("EINVAL", { path });
+                return { [Symbol.asyncIterator]: () => ({ next: async () => ({ done: true, value: undefined }) }) };
+            }
+            if (resolved === deviceDirectory)
+                throw new FsError("EISDIR", { path });
+            if (!this.#filesystem.readStream)
+                throw new FsError("ENOTSUP", { path });
+            return this.#filesystem.readStream(path, options);
+        });
+    }
+    async openReadFile(path, options = {}) {
+        const resolved = await this.#resolve(path, options);
+        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);
+        }
+        const stat = this.#nullStat;
+        let closed = false;
+        const check = (settings) => { settings.signal?.throwIfAborted(); if (closed)
+            throw new FsError("EBADF", { path }); };
+        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 close() { closed = true; },
+        };
+    }
+    async writeFile(path, data, options = {}) {
+        if (await this.#writeTarget(path, options)) {
+            if (!(data instanceof Uint8Array))
+                throw new TypeError("File data must be Uint8Array");
+            return;
+        }
+        await this.#filesystem.writeFile(path, data, options);
+    }
+    async appendFile(path, data, options = {}) {
+        if (await this.#writeTarget(path, options)) {
+            if (!(data instanceof Uint8Array))
+                throw new TypeError("File data must be Uint8Array");
+            return;
+        }
+        await this.#filesystem.appendFile(path, data, options);
+    }
+    async writeStream(path, source, options = {}) {
+        if (await this.#writeTarget(path, options))
+            return drainDeviceInput(source, options.signal);
+        if (!this.#filesystem.writeStream)
+            throw new FsError("ENOTSUP", { path });
+        await this.#filesystem.writeStream(path, source, options);
+    }
+    async readdir(path, options = {}) {
+        const resolved = await this.#resolve(path, options);
+        if (resolved === nullPath)
+            throw new FsError("ENOTDIR", { path });
+        if (resolved !== "/" && resolved !== deviceDirectory)
+            return this.#filesystem.readdir(path, options);
+        const limit = directoryEntryLimit(options, path);
+        let entries;
+        try {
+            entries = await this.#filesystem.readdir(resolved, options);
+        }
+        catch (error) {
+            options.signal?.throwIfAborted();
+            if (!isFsError(error, "ENOENT") && !isFsError(error, "ENOTDIR"))
+                throw error;
+            entries = [];
+        }
+        options.signal?.throwIfAborted();
+        const merged = new Map();
+        for (const entry of entries) {
+            if (entry.name === "." || entry.name === "..")
+                continue;
+            if (!entry.name || entry.name.includes("/") || entry.name.includes("\0"))
+                throw new FsError("EIO", { path, message: "invalid directory entry" });
+            merged.set(entry.name, { name: entry.name, type: entry.type });
+            admitDirectoryEntries(merged.size, limit, path);
+        }
+        const name = resolved === "/" ? "dev" : "null";
+        merged.set(name, { name, type: resolved === "/" ? "directory" : "character" });
+        admitDirectoryEntries(merged.size, limit, path);
+        return [...merged.values()];
+    }
+    async mkdir(path, options = {}) {
+        const resolved = await this.#resolve(path, options);
+        if (reserved(resolved)) {
+            if (resolved !== nullPath && options.recursive)
+                return;
+            throw new FsError("EEXIST", { path });
+        }
+        await this.#filesystem.mkdir(path, options);
+    }
+    async rm(path, options = {}) {
+        await this.#mutable(path, options, false);
+        await this.#filesystem.rm(path, options);
+    }
+    async rmdir(path, options = {}) {
+        const resolved = await this.#resolve(path, options, false);
+        if (resolved === nullPath)
+            throw new FsError("ENOTDIR", { path });
+        if (reserved(resolved))
+            throw new FsError("EBUSY", { path });
+        if (!this.#filesystem.rmdir)
+            throw new FsError("ENOTSUP", { path });
+        await this.#filesystem.rmdir(path, options);
+    }
+    async rename(source, destination, options = {}) {
+        await this.#mutable(source, options, false);
+        await this.#mutable(destination, options, false);
+        if (options.noReplace) {
+            const capabilities = await this.#filesystem.capabilitiesFor?.(destination, options) ?? this.#filesystem.capabilities;
+            options.signal?.throwIfAborted();
+            if (capabilities.atomicRenameNoReplace !== true)
+                throw new FsError("ENOTSUP", { syscall: "rename", path: source, dest: destination });
+        }
+        await this.#filesystem.rename(source, destination, options);
+    }
+    async copyFile(source, destination, options = {}) {
+        const target = await this.#resolve(destination, options);
+        if (target === nullPath && options.exclusive)
+            throw new FsError("EEXIST", { path: destination });
+        const origin = await this.#resolve(source, options);
+        if (target !== nullPath && origin !== nullPath) {
+            if (target === "/" || target === deviceDirectory)
+                throw new FsError("EISDIR", { path: destination });
+            await this.#filesystem.copyFile(source, destination, options);
+            return;
+        }
+        if (target === nullPath) {
+            if (origin === nullPath)
+                return;
+            if (origin === "/" || origin === deviceDirectory)
+                throw new FsError("EISDIR", { path: source });
+            const capabilities = await this.capabilitiesFor(source, options);
+            if (this.#filesystem.readStream && capabilities.streamingRead !== false) {
+                await drainDeviceInput(this.#filesystem.readStream(source, options), options.signal);
+            }
+            else if (this.#filesystem.openReadFile && capabilities.retainedRead !== false) {
+                await drainDeviceFile(await this.#filesystem.openReadFile(source, options), options.signal);
+            }
+            else
+                throw new FsError("ENOTSUP", { path: source });
+            return;
+        }
+        if (reserved(target))
+            throw new FsError("EISDIR", { path: destination });
+        await this.#filesystem.writeFile(destination, new Uint8Array(), { ...options, flag: options.exclusive ? "wx" : "w" });
+    }
+    async access(path, mode = 0, options = {}) {
+        const resolved = await this.#resolve(path, options);
+        if (resolved === nullPath || resolved === deviceDirectory) {
+            if (!Number.isInteger(mode) || mode < 0 || mode > 7)
+                throw new FsError("EINVAL", { path });
+            if ((resolved === nullPath && (mode & 1)) || (resolved === deviceDirectory && (mode & 2)))
+                throw new FsError("EACCES", { path });
+            return;
+        }
+        await this.#filesystem.access(path, mode, options);
+    }
+    async readlink(path, options = {}) {
+        if (reserved(await this.#resolve(path, options, false)))
+            throw new FsError("EINVAL", { path });
+        if (!this.#filesystem.readlink)
+            throw new FsError("ENOTSUP", { path });
+        return this.#filesystem.readlink(path, options);
+    }
+    async symlink(target, path, options = {}) {
+        await this.#mutable(path, options, false);
+        if (!this.#filesystem.symlink)
+            throw new FsError("ENOTSUP", { path });
+        await this.#filesystem.symlink(target, path, options);
+    }
+    async link(existingPath, newPath, options = {}) {
+        await this.#mutable(existingPath, options, false);
+        await this.#mutable(newPath, options, false);
+        if (!this.#filesystem.link)
+            throw new FsError("ENOTSUP", { path: newPath });
+        await this.#filesystem.link(existingPath, newPath, options);
+    }
+    async chmod(path, mode, options = {}) {
+        await this.#mutable(path, options);
+        if (!this.#filesystem.chmod)
+            throw new FsError("ENOTSUP", { path });
+        await this.#filesystem.chmod(path, mode, options);
+    }
+    async utimes(path, atimeMs, mtimeMs, options = {}) {
+        await this.#mutable(path, options);
+        if (!this.#filesystem.utimes)
+            throw new FsError("ENOTSUP", { path });
+        await this.#filesystem.utimes(path, atimeMs, mtimeMs, options);
+    }
+    async truncate(path, length, options = {}) {
+        await this.#mutable(path, options);
+        if (!this.#filesystem.truncate)
+            throw new FsError("ENOTSUP", { path });
+        await this.#filesystem.truncate(path, length, options);
+    }
+}
+export function createDeviceFileSystem(filesystem) {
+    if (filesystem instanceof DeviceFileSystem)
+        return filesystem;
+    let view = views.get(filesystem);
+    if (!view) {
+        view = new DeviceFileSystem(filesystem);
+        views.set(filesystem, view);
+    }
+    return view;
+}

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

@@ -0,0 +1,5 @@
+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>;

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

@@ -0,0 +1,87 @@
+import { FsError, isFsError } from "../../contracts/errors.js";
+import { validatePath } from "../../contracts/virtual-path.js";
+export const nullPath = "/dev/null";
+export const deviceDirectory = "/dev";
+export function lexicalDevicePath(path) {
+    validatePath(path);
+    const parts = [];
+    for (const component of path.split("/")) {
+        if (`/${parts.join("/")}` === nullPath)
+            throw new FsError("ENOTDIR", { path });
+        if (component === "..")
+            parts.pop();
+        else if (component && component !== ".")
+            parts.push(component);
+    }
+    return `/${parts.join("/")}`;
+}
+export async function resolveDevicePath(filesystem, path, options, followFinal = true) {
+    options.signal?.throwIfAborted();
+    const lexical = lexicalDevicePath(path);
+    const aliases = typeof filesystem.lstat === "function";
+    if (!aliases && lexical !== nullPath && lexical !== deviceDirectory && lexical !== "/")
+        return lexical;
+    const pending = path.split("/");
+    const parts = [];
+    let links = 0;
+    let expanded = path.length;
+    let absolute = path.startsWith("/");
+    let traversalFailure;
+    while (pending.length) {
+        options.signal?.throwIfAborted();
+        if (`/${parts.join("/")}` === nullPath)
+            throw new FsError("ENOTDIR", { path });
+        const component = pending.shift();
+        if (!component || component === ".")
+            continue;
+        if (component === "..") {
+            parts.pop();
+            continue;
+        }
+        const candidate = `/${[...parts, component].join("/")}`;
+        if (candidate !== deviceDirectory && candidate !== nullPath && ((followFinal && aliases) || pending.length)) {
+            const lookup = absolute ? candidate : candidate.slice(1);
+            let stat;
+            try {
+                if (typeof filesystem.lstat !== "function")
+                    throw new FsError("ENOTSUP", { path });
+                stat = await filesystem.lstat(lookup, options);
+            }
+            catch (error) {
+                options.signal?.throwIfAborted();
+                if (isFsError(error, "ENOTSUP") && links === 0 && lexical !== nullPath && lexical !== deviceDirectory && lexical !== "/")
+                    return lexical;
+                if (!isFsError(error, "ENOENT"))
+                    throw error;
+                if (pending.length)
+                    traversalFailure ??= error;
+            }
+            options.signal?.throwIfAborted();
+            if (stat?.type === "symlink") {
+                if (typeof filesystem.readlink !== "function")
+                    throw new FsError("ENOTSUP", { path });
+                if (++links > 40)
+                    throw new FsError("ELOOP", { path });
+                const target = await filesystem.readlink(lookup, options);
+                options.signal?.throwIfAborted();
+                validatePath(target);
+                expanded += target.length;
+                if (expanded > 65536)
+                    throw new FsError("ENAMETOOLONG", { path });
+                if (target.startsWith("/")) {
+                    parts.length = 0;
+                    absolute = true;
+                }
+                pending.unshift(...target.split("/"));
+                continue;
+            }
+            if (stat && pending.length && stat.type !== "directory")
+                traversalFailure ??= new FsError("ENOTDIR", { path });
+        }
+        parts.push(component);
+    }
+    const resolved = `/${parts.join("/")}`;
+    if (traversalFailure && (resolved === nullPath || resolved === deviceDirectory || resolved === "/"))
+        throw traversalFailure;
+    return resolved;
+}

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

@@ -0,0 +1,5 @@
+import type { ByteSource } from "../../contracts/io.js";
+import type { FileReadHandle } from "../../contracts/filesystem.js";
+export declare function deviceReadStream(open: () => Promise<ByteSource>): ByteSource;
+export declare function drainDeviceFile(handle: FileReadHandle, signal?: AbortSignal): Promise<void>;
+export declare function drainDeviceInput(source: ByteSource, signal?: AbortSignal): Promise<void>;

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

@@ -0,0 +1,116 @@
+import { finishCleanup } from "../../contracts/cleanup.js";
+export function deviceReadStream(open) {
+    return { [Symbol.asyncIterator]() {
+            let opened;
+            let closing;
+            const iterator = () => opened ??= open().then(source => source[Symbol.asyncIterator]());
+            const close = () => closing ??= iterator().then(async (source) => source.return ? source.return() : { done: true, value: undefined });
+            return {
+                async next() {
+                    if (closing) {
+                        await closing;
+                        return { done: true, value: undefined };
+                    }
+                    try {
+                        return await (await iterator()).next();
+                    }
+                    catch (error) {
+                        await finishCleanup(close, true);
+                        throw error;
+                    }
+                },
+                return: close,
+            };
+        } };
+}
+export async function drainDeviceFile(handle, signal) {
+    let failed = false;
+    let position = 0;
+    try {
+        await drainDeviceInput({ [Symbol.asyncIterator]: () => ({ async next() {
+                    const value = await handle.read(position, 65536, signal ? { signal } : {});
+                    if (!(value instanceof Uint8Array) || value.byteLength > 65536)
+                        throw new TypeError("Retained reads must return bounded Uint8Array chunks");
+                    position += value.byteLength;
+                    if (!Number.isSafeInteger(position))
+                        throw new RangeError("Retained read position exceeds safe integer range");
+                    return { done: value.byteLength === 0, value };
+                } }) }, signal);
+    }
+    catch (error) {
+        failed = true;
+        throw error;
+    }
+    finally {
+        await finishCleanup(async () => {
+            try {
+                await handle.close();
+            }
+            catch (error) {
+                signal?.throwIfAborted();
+                throw error;
+            }
+        }, failed);
+    }
+    signal?.throwIfAborted();
+}
+function nextChunk(iterator, signal) {
+    signal?.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const aborted = () => { signal?.removeEventListener("abort", aborted); reject(signal?.reason); };
+        signal?.addEventListener("abort", aborted, { once: true });
+        try {
+            Promise.resolve(iterator.next()).then(result => {
+                signal?.removeEventListener("abort", aborted);
+                if (signal?.aborted)
+                    reject(signal.reason);
+                else
+                    resolve(result);
+            }, error => { signal?.removeEventListener("abort", aborted); reject(signal?.aborted ? signal.reason : error); });
+        }
+        catch (error) {
+            signal?.removeEventListener("abort", aborted);
+            reject(signal?.aborted ? signal.reason : error);
+        }
+    });
+}
+export async function drainDeviceInput(source, signal) {
+    signal?.throwIfAborted();
+    const iterator = source[Symbol.asyncIterator]();
+    let failed = false;
+    let bytes = 0;
+    let pulls = 0;
+    try {
+        for (;;) {
+            const result = await nextChunk(iterator, signal);
+            signal?.throwIfAborted();
+            if (result.done)
+                break;
+            if (!(result.value instanceof Uint8Array))
+                throw new TypeError("Byte sources must yield Uint8Array chunks");
+            bytes += result.value.byteLength;
+            if (++pulls >= 64 || bytes >= 65536) {
+                await new Promise(resolve => setTimeout(resolve, 0));
+                signal?.throwIfAborted();
+                bytes = 0;
+                pulls = 0;
+            }
+        }
+    }
+    catch (error) {
+        failed = true;
+        throw error;
+    }
+    finally {
+        await finishCleanup(async () => {
+            try {
+                await iterator.return?.();
+            }
+            catch (error) {
+                signal?.throwIfAborted();
+                throw error;
+            }
+        }, failed);
+    }
+    signal?.throwIfAborted();
+}

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

@@ -1,4 +1,4 @@
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileReadHandle, FileStat, FileSystem, FsOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileReadHandle, FileStat, FileSystem, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, 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";
@@ -20,6 +20,7 @@ export declare class MemoryFileSystem implements FileSystem {
         removeDirectory: true;
         recursiveRemove: true;
         rename: true;
+        atomicRenameNoReplace: true;
         copy: true;
         exclusiveCopy: true;
         readlink: true;
@@ -76,7 +77,7 @@ export declare class MemoryFileSystem implements FileSystem {
     mkdir(path: string, options?: MkdirOptions): Promise<void>;
     rmdir(path: string, options?: FsOptions): Promise<void>;
     rm(path: string, options?: RemoveOptions): Promise<void>;
-    rename(source: string, destination: string, options?: FsOptions): Promise<void>;
+    rename(source: string, destination: string, options?: RenameOptions): Promise<void>;
     copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
     realpath(path: string, options?: FsOptions): Promise<string>;
     access(path: string, mode?: number, options?: FsOptions): Promise<void>;

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

@@ -57,7 +57,7 @@ export class MemoryFileSystem {
             read: true, stat: true, readdir: true, realpath: true, access: true,
             write: true, append: true, exclusiveCreate: true, explicitDirectories: true, implicitDirectories: false,
             mkdir: true, recursiveMkdir: true, remove: true, removeDirectory: true, recursiveRemove: true,
-            rename: true, copy: true, exclusiveCopy: true, readlink: true, truncate: true,
+            rename: true, atomicRenameNoReplace: true, copy: true, exclusiveCopy: true, readlink: true, truncate: true,
             streamingAppend: true, randomAccessWrite: true,
             readOnly: false,
             symlinks: true,
@@ -515,6 +515,8 @@ export class MemoryFileSystem {
                 this.fail("EBUSY", "rename", source, destination);
             if (destination.endsWith("/") && node.type !== "directory")
                 this.fail("ENOTDIR", "rename", source, destination);
+            if (options.noReplace && target.node)
+                this.fail("EEXIST", "rename", source, destination);
             if (target.node === node)
                 return;
             if (node.type === "directory" && target.path.startsWith(`${origin.path}/`))

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

@@ -1,4 +1,4 @@
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileReadHandle, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileReadHandle, FileStat, FileSystem, FileSystemCapabilities, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 import type { ByteSource } from "../../contracts/io.js";
 export interface MountFileSystemOptions {
     readonly root: FileSystem;
@@ -29,7 +29,7 @@ export declare class MountFileSystem implements FileSystem {
     mkdir(path: string, options?: MkdirOptions): Promise<void>;
     rmdir(path: string, options?: FsOptions): Promise<void>;
     rm(path: string, options?: RemoveOptions): Promise<void>;
-    rename(source: string, destination: string, options?: FsOptions): Promise<void>;
+    rename(source: string, destination: string, options?: RenameOptions): Promise<void>;
     copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
     realpath(path: string, options?: FsOptions): Promise<string>;
     compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<import("../../contracts/filesystem.js").EntryComparison>;

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

@@ -96,14 +96,14 @@ export class MountFileSystem {
                     return false;
                 return declared === true && optional[capability]?.some(method => typeof backend[method] !== "function") ? false : declared;
             });
-            if (["rename", "copy", "exclusiveCopy"].includes(capability) && mounts.length > 1)
+            if (["rename", "atomicRenameNoReplace", "copy", "exclusiveCopy"].includes(capability) && mounts.length > 1)
                 return undefined;
             return values.every(value => value === true) ? true : values.every(value => value === false) ? false : undefined;
         };
         const semantics = Object.fromEntries([
             "read", "stat", "readdir", "realpath", "access",
             "write", "append", "exclusiveCreate", "explicitDirectories", "implicitDirectories", "mkdir", "recursiveMkdir",
-            "remove", "removeDirectory", "recursiveRemove", "rename", "copy", "exclusiveCopy", "readlink", "truncate",
+            "remove", "removeDirectory", "recursiveRemove", "rename", "atomicRenameNoReplace", "copy", "exclusiveCopy", "readlink", "truncate",
             "streamingAppend", "randomAccessWrite", "descriptorWriteStream", "symlinks", "hardlinks", "permissions", "timestamps",
         ].map(capability => [capability, common(capability)]).filter(([, value]) => value !== undefined));
         this.capabilities = Object.freeze({
@@ -455,6 +455,12 @@ export class MountFileSystem {
             this.mutable(target);
             this.entryPath(source);
             this.entryPath(destination);
+            if (options.noReplace) {
+                const capabilities = await target.mount.backend.capabilitiesFor?.(target.local, options) ?? target.mount.backend.capabilities;
+                options.signal?.throwIfAborted();
+                if (capabilities.atomicRenameNoReplace !== true)
+                    fail("ENOTSUP");
+            }
             await origin.mount.backend.rename(origin.local, target.local, options);
         }, destination);
     }

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

@@ -1,5 +1,5 @@
 import type { ByteSource } from "../../contracts/io.js";
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 export interface OverlayFileSystemOptions {
     readonly upper: FileSystem;
     readonly lower: FileSystem;
@@ -58,7 +58,7 @@ export declare class OverlayFileSystem implements FileSystem {
     rmdir(path: string, options?: FsOptions): Promise<void>;
     rm(path: string, options?: RemoveOptions): Promise<void>;
     private materialize;
-    rename(source: string, destination: string, options?: FsOptions): Promise<void>;
+    rename(source: string, destination: string, options?: RenameOptions): Promise<void>;
     copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
     readlink(path: string, options?: FsOptions): Promise<string>;
     symlink(target: string, path: string, options?: FsOptions): Promise<void>;

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

@@ -117,7 +117,7 @@ export class OverlayFileSystem {
                 : upper.readlink === false && this.#lower.capabilities.readlink === false ? false : undefined,
             ...(upper.readOnly === undefined ? {} : { readOnly: upper.readOnly }),
             ...(effectiveAppend === undefined ? {} : { append: effectiveAppend }),
-            atomicRename: false,
+            atomicRename: false, atomicRenameNoReplace: false,
             descriptorWriteStream: false,
             hardlinks: false,
             symlinks: writable && this.#upper.capabilities.symlinks === true
@@ -737,6 +737,8 @@ export class OverlayFileSystem {
     }
     async rename(source, destination, options = {}) {
         return this.run(options, async () => {
+            if (options.noReplace)
+                fail("ENOTSUP", source, "atomic no-replace rename is unsupported");
             this.writable(source);
             const original = await this.required(source, options, false);
             const target = await this.resolve(destination, options, false, true);

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

@@ -130,6 +130,16 @@ export function withFileSystemQuota(fs, options) {
                 await fs.appendFile(path, data, appendOptions);
             });
         },
+        async rename(source, destination, renameOptions) {
+            if (renameOptions?.noReplace) {
+                renameOptions.signal?.throwIfAborted();
+                const capabilities = await fs.capabilitiesFor?.(destination, renameOptions) ?? fs.capabilities;
+                renameOptions?.signal?.throwIfAborted();
+                if (capabilities.atomicRenameNoReplace !== true)
+                    throw new FsError("ENOTSUP", { syscall: "rename", path: source, dest: destination });
+            }
+            await fs.rename(source, destination, renameOptions);
+        },
         copyFile(source, destination, copyOptions) {
             return mutate(async () => {
                 await assertDelta(destination, (await fs.stat(source, copyOptions)).size, copyOptions);

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

@@ -1,5 +1,5 @@
 import type { ByteSource } from "../../contracts/io.js";
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 export declare class ReadOnlyFileSystem implements FileSystem {
     #private;
     constructor(filesystem: FileSystem);
@@ -22,7 +22,7 @@ export declare class ReadOnlyFileSystem implements FileSystem {
     rm(path: string, _options?: RemoveOptions): Promise<void>;
     unlink(path: string, _options?: FsOptions): Promise<void>;
     rmdir(path: string, _options?: FsOptions): Promise<void>;
-    rename(source: string, destination: string, _options?: FsOptions): Promise<void>;
+    rename(source: string, destination: string, _options?: RenameOptions): Promise<void>;
     copyFile(source: string, destination: string, _options?: CopyFileOptions): Promise<void>;
     symlink(target: string, path: string, _options?: FsOptions): Promise<void>;
     link(existingPath: string, newPath: string, _options?: FsOptions): Promise<void>;

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

@@ -1,4 +1,4 @@
-import type { AppendFileOptions, ByteSource, CopyFileOptions, DirectoryEntry, FileReadHandle, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/index.js";
+import type { AppendFileOptions, ByteSource, CopyFileOptions, DirectoryEntry, FileReadHandle, FileStat, FileSystem, FileSystemCapabilities, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/index.js";
 export interface RealFileSystemOptions {
     /** An existing, absolute host directory. It is never created implicitly. */
     readonly root: string;
@@ -59,7 +59,7 @@ export declare class RealFileSystem implements FileSystem {
     mkdir(path: string, options?: MkdirOptions): Promise<void>;
     rmdir(path: string, options?: FsOptions): Promise<void>;
     rm(path: string, options?: RemoveOptions): Promise<void>;
-    rename(source: string, destination: string, options?: FsOptions): Promise<void>;
+    rename(source: string, destination: string, options?: RenameOptions): Promise<void>;
     copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
     realpath(path: string, options?: FsOptions): Promise<string>;
     access(path: string, mode?: number, options?: FsOptions): Promise<void>;

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

@@ -84,7 +84,7 @@ export class RealFileSystem {
         read: true, stat: true, readdir: true, realpath: true, access: true,
         write: true, append: true, exclusiveCreate: true, explicitDirectories: true, implicitDirectories: false,
         mkdir: true, recursiveMkdir: true, remove: true, removeDirectory: true, recursiveRemove: true,
-        rename: true, copy: true, exclusiveCopy: true, readlink: true, truncate: true,
+        rename: true, atomicRenameNoReplace: false, copy: true, exclusiveCopy: true, readlink: true, truncate: true,
         streamingAppend: true, randomAccessWrite: true,
         readOnly: false, symlinks: true, hardlinks: true, permissions: true,
         timestamps: true, atomicRename: true, streamingRead: true, streamingWrite: true, retainedRead: true,
@@ -346,6 +346,8 @@ export class RealFileSystem {
     }
     async rename(source, destination, options = {}) {
         return this.operation("rename", source, options, async () => {
+            if (options.noReplace)
+                throw new FsError("ENOTSUP", { syscall: "rename", path: source, dest: destination });
             const from = await this.path(source, { ...options, followFinal: false });
             const to = await this.path(destination, { ...options, followFinal: false, missing: "final" });
             this.protectTerminal(source);

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

@@ -1,5 +1,5 @@
 import { FsError } from "../../contracts/errors.js";
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 import type { ByteSource } from "../../contracts/io.js";
 import type { S3Transport } from "./transport.js";
 export interface S3FileSystemOptions {
@@ -41,6 +41,7 @@ export declare class S3FileSystem implements FileSystem {
         append: boolean;
         exclusiveCreate: boolean;
         truncate: boolean;
+        atomicRenameNoReplace: false;
         rename: boolean;
         streamingAppend: boolean;
         randomAccessWrite: false;
@@ -99,7 +100,7 @@ export declare class S3FileSystem implements FileSystem {
     rm(input: string, options?: RemoveOptions): Promise<void>;
     private copy;
     copyFile(sourceInput: string, destinationInput: string, options?: CopyFileOptions): Promise<void>;
-    rename(sourceInput: string, destinationInput: string, options?: FsOptions): Promise<void>;
+    rename(sourceInput: string, destinationInput: string, options?: RenameOptions): Promise<void>;
     private copyWithPut;
     realpath(input: string, options?: FsOptions): Promise<string>;
     access(path: string, mode?: number, options?: FsOptions): Promise<void>;

package/dist/safe-fs/fs/s3/filesystem.js

@@ -112,6 +112,7 @@ export class S3FileSystem {
             append: options.transport.capabilities?.conditionalPut === true,
             exclusiveCreate: options.transport.capabilities?.conditionalPut === true,
             truncate: options.transport.capabilities?.conditionalPut === true,
+            atomicRenameNoReplace: false,
             rename: this.allowRename && options.transport.capabilities?.conditionalDelete === true
                 && (options.transport.capabilities?.conditionalCopy === true || options.transport.capabilities?.conditionalPut === true),
             streamingAppend: options.transport.capabilities?.streamingWrite === true
@@ -674,6 +675,10 @@ export class S3FileSystem {
         }
     }
     async rename(sourceInput, destinationInput, options = {}) {
+        if (options.noReplace) {
+            options.signal?.throwIfAborted();
+            this.unsupported("atomic no-replace rename", sourceInput);
+        }
         const source = this.path(sourceInput);
         const destination = this.path(destinationInput);
         this.writable(destination);

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

@@ -1,3 +1,4 @@
+import { FsError } from "../contracts/errors.js";
 import { finishCleanup } from "../contracts/cleanup.js";
 import { registerEntryView } from "./mount/comparison.js";
 const originals = new WeakMap();
@@ -76,6 +77,17 @@ export function scopeFileSystem(filesystem, charge, signal) {
                     const peer = args[1];
                     args[1] = originals.get(peer) ?? peer;
                 }
+                if (property === "rename" && args[2]?.noReplace)
+                    return (async () => {
+                        const options = args[2];
+                        const capabilities = await original.capabilitiesFor?.(args[1], options) ?? original.capabilities;
+                        assertOpen(options);
+                        if (capabilities.atomicRenameNoReplace !== true)
+                            throw new FsError("ENOTSUP", {
+                                syscall: "rename", path: args[0], dest: args[1],
+                            });
+                        return Reflect.apply(method, original, args);
+                    })();
                 return Reflect.apply(method, original, args);
             };
             const scoped = property === "openReadFile"

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

@@ -1,6 +1,6 @@
 import type { PlatformComparisonCallback } from "#safe-fs-platform";
 import type { ByteSource } from "../../contracts/io.js";
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 export type WebDavFetch = (url: string, init: RequestInit) => Promise<Response>;
 export interface WebDavAtomicEmptyDirectoryRequest {
     readonly operation: "atomic-empty-rmdir/v1";
@@ -49,6 +49,7 @@ export declare class WebDavFileSystem implements FileSystem {
         remove: true;
         recursiveRemove: true;
         rename: true;
+        atomicRenameNoReplace: false;
         copy: true;
         exclusiveCopy: true;
         readlink: false;
@@ -114,7 +115,7 @@ export declare class WebDavFileSystem implements FileSystem {
     private guardTransferIdentity;
     private transfer;
     private withDestinationLock;
-    rename(source: string, destination: string, options?: FsOptions): Promise<void>;
+    rename(source: string, destination: string, options?: RenameOptions): Promise<void>;
     copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
     realpath(path: string, options?: FsOptions): Promise<string>;
     access(path: string, mode?: number, options?: FsOptions): Promise<void>;

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

@@ -143,7 +143,7 @@ export class WebDavFileSystem {
     capabilities = Object.freeze({
         read: true, stat: true, readdir: true, realpath: true, access: true,
         write: true, append: true, exclusiveCreate: true, explicitDirectories: true, implicitDirectories: false,
-        mkdir: true, recursiveMkdir: true, remove: true, recursiveRemove: true, rename: true, copy: true,
+        mkdir: true, recursiveMkdir: true, remove: true, recursiveRemove: true, rename: true, atomicRenameNoReplace: false, copy: true,
         exclusiveCopy: true, readlink: false, truncate: false, randomAccessWrite: false,
         removeDirectory: false, streamingAppend: false,
         symlinks: false, hardlinks: false, permissions: false, timestamps: true,
@@ -1192,6 +1192,10 @@ export class WebDavFileSystem {
         }
     }
     async rename(source, destination, options = {}) {
+        if (options.noReplace) {
+            options.signal?.throwIfAborted();
+            fail("ENOTSUP", "rename", source, "atomic no-replace rename is unsupported");
+        }
         await this.transfer("MOVE", source, destination, options);
     }
     async copyFile(source, destination, options = {}) {

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

@@ -1,5 +1,6 @@
 export * from "./contracts/index.js";
 export * from "./fs/memory/index.js";
+export * from "./fs/devices/index.js";
 export * from "./fs/real/index.js";
 export * from "./fs/s3/index.js";
 export type { S3StreamGetInput, S3StreamGetOutput, S3StreamPutInput } from "./fs/s3/transport.js";

package/dist/safe-fs/index.js

@@ -1,5 +1,6 @@
 export * from "./contracts/index.js";
 export * from "./fs/memory/index.js";
+export * from "./fs/devices/index.js";
 export * from "./fs/real/index.js";
 export * from "./fs/s3/index.js";
 export * from "./fs/s3/http/index.js";

package/package.json

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