@poe-platform/safe-fs 0.1.658 → 0.1.659

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

@@ -62,6 +62,7 @@ export interface FileSystemCapabilities {
     readonly atomicFileStaging?: boolean;
     readonly atomicFileMutation?: boolean;
     readonly atomicEntryRemoval?: boolean;
+    readonly atomicTreeRemoval?: boolean;
     readonly atomicDirectoryMetadata?: boolean;
     readonly atomicRenameNoReplace?: boolean;
     readonly snapshotRmdir?: boolean;
@@ -200,6 +201,7 @@ export interface PrepareDirectoryOptions extends FsOptions {
 export interface FileSystem {
     writeFileConditional?(path: string, data: Uint8Array, options: ConditionalWriteFileOptions): Promise<FileStat>;
     removeEntryConditional?(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;
+    removeTreeConditional?(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;
     removeFileConditional?(path: string, options: ConditionalRemoveFileOptions): Promise<void>;
     readonly capabilities: FileSystemCapabilities;
     open?(path: string, options: OpenFileOptions): Promise<FileDescriptor>;

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

@@ -7,4 +7,4 @@ export declare function openRetainedResizeFile(filesystem: FileSystem, path: str
 export declare function readOnlyCapabilities(capabilities: FileSystemCapabilities): FileSystemCapabilities;
 export declare function quotaCapabilities(capabilities: FileSystemCapabilities): FileSystemCapabilities;
 export declare function ownedMutationCapabilities(filesystem: FileSystem, capabilities?: FileSystemCapabilities): FileSystemCapabilities;
-export declare function requireOwnedMutation(filesystem: FileSystem, path: string, capability: "atomicEntryRemoval" | "atomicFileMutation" | "atomicFileStaging" | "atomicDirectoryMetadata", options: FsOptions, create?: boolean): Promise<void>;
+export declare function requireOwnedMutation(filesystem: FileSystem, path: string, capability: "atomicEntryRemoval" | "atomicTreeRemoval" | "atomicFileMutation" | "atomicFileStaging" | "atomicDirectoryMetadata", options: FsOptions, create?: boolean): Promise<void>;

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

@@ -108,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, atomicResize: false, retainedResize: false, atomicFileMutation: false, atomicEntryRemoval: false, atomicFileStaging: false, atomicDirectoryMetadata: false,
+        descriptorWriteStream: false, atomicResize: false, retainedResize: false, atomicFileMutation: false, atomicEntryRemoval: false, atomicTreeRemoval: false, atomicFileStaging: false, atomicDirectoryMetadata: false,
         atomicRename: false, atomicRenameNoReplace: false, streamingWrite: false,
     });
 }
@@ -125,6 +125,8 @@ export function ownedMutationCapabilities(filesystem, capabilities = filesystem.
     const unavailable = {};
     if (capabilities.atomicEntryRemoval === true && (capabilities.readOnly === true || typeof filesystem.removeEntryConditional !== "function"))
         unavailable.atomicEntryRemoval = false;
+    if (capabilities.atomicTreeRemoval === true && (capabilities.readOnly === true || typeof filesystem.removeTreeConditional !== "function"))
+        unavailable.atomicTreeRemoval = false;
     if (capabilities.atomicFileMutation === true && (capabilities.readOnly === true || typeof filesystem.writeFileConditional !== "function" || typeof filesystem.removeFileConditional !== "function"))
         unavailable.atomicFileMutation = false;
     if (capabilities.atomicFileStaging === true && (capabilities.readOnly === true

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

@@ -28,6 +28,7 @@ export declare class DeviceFileSystem implements FileSystem {
     writeFileConditional(path: string, data: Uint8Array, options: ConditionalWriteFileOptions): Promise<FileStat>;
     removeEntryConditional(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;
     removeFileConditional(path: string, options: ConditionalRemoveFileOptions): Promise<void>;
+    removeTreeConditional(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;
     createStagedFile(path: string, name: string, content: StagedFileContent, options: CreateStagedFileOptions): Promise<FileStaging>;
     publishStagedFile(staging: FileStaging, destination: string, options: PublishStagedFileOptions): Promise<void>;
     removeStagedFile(staging: FileStaging, options?: FsOptions): Promise<void>;

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

@@ -14,14 +14,14 @@ 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,
-    open: false, atomicFileMutation: false, atomicEntryRemoval: false, atomicFileStaging: false, atomicDirectoryMetadata: false,
+    open: false, atomicFileMutation: false, atomicEntryRemoval: false, atomicTreeRemoval: false, atomicFileStaging: false, atomicDirectoryMetadata: false,
     atomicRename: false, atomicRenameNoReplace: false, descriptorWriteStream: true, retainedResize: true, atomicResize: false,
 });
 function globalCapabilities(filesystem) {
     const capabilities = { readOnly: false };
     const optional = {
         open: ["open"],
-        atomicEntryRemoval: ["removeEntryConditional"], atomicFileMutation: ["writeFileConditional", "removeFileConditional"], atomicFileStaging: ["createStagedFile", "publishStagedFile", "removeStagedFile"], atomicDirectoryMetadata: ["prepareDirectory"],
+        atomicEntryRemoval: ["removeEntryConditional"], atomicTreeRemoval: ["removeTreeConditional"], atomicFileMutation: ["writeFileConditional", "removeFileConditional"], atomicFileStaging: ["createStagedFile", "publishStagedFile", "removeStagedFile"], atomicDirectoryMetadata: ["prepareDirectory"],
         streamingRead: ["readStream"], streamingWrite: ["writeStream"], retainedRead: ["openReadFile"],
         streamingAppend: ["writeStream"], descriptorWriteStream: ["writeStream"], retainedResize: ["openResizeFile"], atomicResize: ["resizeFile"],
         symlinks: ["symlink", "readlink"], hardlinks: ["link"], permissions: ["chmod"],
@@ -416,6 +416,13 @@ export class DeviceFileSystem {
             throw new FsError("ENOTSUP", { path });
         await this.#filesystem.removeFileConditional(path, options);
     }
+    async removeTreeConditional(path, options) {
+        await this.#mutable(path, options, false);
+        await requireOwnedMutation(this.#filesystem, path, "atomicTreeRemoval", options);
+        if (!this.#filesystem.removeTreeConditional)
+            throw new FsError("ENOTSUP", { path });
+        await this.#filesystem.removeTreeConditional(path, options);
+    }
     async createStagedFile(path, name, content, options) {
         await this.#mutable(path, options, false);
         await requireOwnedMutation(this.#filesystem, path, "atomicFileStaging", options, true);

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

@@ -37,6 +37,7 @@ export declare class MemoryFileSystem implements FileSystem {
         atomicFileStaging: true;
         atomicFileMutation: true;
         atomicEntryRemoval: true;
+        atomicTreeRemoval: true;
         atomicDirectoryMetadata: true;
         streamingRead: true;
         retainedRead: true;
@@ -87,6 +88,7 @@ export declare class MemoryFileSystem implements FileSystem {
     writeFileConditional(path: string, data: Uint8Array, options: ConditionalWriteFileOptions): Promise<FileStat>;
     removeEntryConditional(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;
     removeFileConditional(path: string, options: ConditionalRemoveFileOptions): Promise<void>;
+    removeTreeConditional(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;
     writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
     appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
     stat(path: string, options?: FsOptions): Promise<FileStat>;
@@ -95,6 +97,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>;
+    private removeLocation;
     unlink(path: string, options?: FsOptions): Promise<void>;
     rename(source: string, destination: string, options?: RenameOptions): Promise<void>;
     copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;

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

@@ -68,7 +68,7 @@ export class MemoryFileSystem {
             permissions: true,
             timestamps: true,
             atomicRename: true,
-            atomicFileStaging: true, atomicFileMutation: true, atomicEntryRemoval: true,
+            atomicFileStaging: true, atomicFileMutation: true, atomicEntryRemoval: true, atomicTreeRemoval: true,
             atomicDirectoryMetadata: true,
             streamingRead: true,
             retainedRead: true,
@@ -696,6 +696,15 @@ export class MemoryFileSystem {
         this.releaseNode(node);
         this.changed(location.parent);
     }
+    async removeTreeConditional(path, options) {
+        options.signal?.throwIfAborted();
+        const location = this.entry(path, "removeTreeConditional", true);
+        this.expectEntry(location.parent, options.parent, path, false);
+        this.expectEntry(location.node, options.expected, path, false);
+        if (location.node?.type !== "directory")
+            this.fail("ENOTDIR", "removeTreeConditional", path);
+        this.removeLocation(location, path, "removeTreeConditional", true);
+    }
     async writeFile(path, data, options = {}) {
         options.signal?.throwIfAborted();
         this.writeData(path, data, options, "writeFile");
@@ -773,19 +782,22 @@ export class MemoryFileSystem {
                 return;
             throw error;
         }
+        this.removeLocation(location, path, "rm", options.recursive === true);
+    }
+    removeLocation(location, path, syscall, recursive) {
         const node = location.node;
         if (this.terminalDot(path))
-            this.fail("EINVAL", "rm", path);
+            this.fail("EINVAL", syscall, path);
         if (node === this.root)
-            this.fail("EBUSY", "rm", path);
-        this.permission(location.parent, 3, "rm", path);
-        if (node.type === "directory" && !options.recursive)
-            this.fail("EISDIR", "rm", path);
+            this.fail("EBUSY", syscall, path);
+        this.permission(location.parent, 3, syscall, path);
+        if (node.type === "directory" && !recursive)
+            this.fail("EISDIR", syscall, path);
         const removed = [node];
         for (let index = 0; index < removed.length; index++) {
             const entry = removed[index];
             if (entry.type === "directory" && entry.entries.size > 0) {
-                this.permission(entry, 7, "rm", path);
+                this.permission(entry, 7, syscall, path);
                 for (const child of entry.entries.values())
                     removed.push(child);
             }

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

@@ -38,6 +38,7 @@ export declare class MountFileSystem implements FileSystem {
     writeFileConditional(path: string, data: Uint8Array, options: ConditionalWriteFileOptions): Promise<FileStat>;
     removeEntryConditional(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;
     removeFileConditional(path: string, options: ConditionalRemoveFileOptions): Promise<void>;
+    removeTreeConditional(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;
     createStagedFile(path: string, name: string, content: StagedFileContent, options: CreateStagedFileOptions): Promise<FileStaging>;
     publishStagedFile(staging: FileStaging, destination: string, options: PublishStagedFileOptions): Promise<void>;
     removeStagedFile(staging: FileStaging, options?: FsOptions): Promise<void>;

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

@@ -96,7 +96,7 @@ export class MountFileSystem {
         const common = (capability) => {
             const optional = {
                 open: ["open"],
-                atomicEntryRemoval: ["removeEntryConditional"], atomicFileMutation: ["writeFileConditional", "removeFileConditional"], atomicFileStaging: ["createStagedFile", "publishStagedFile", "removeStagedFile"], atomicDirectoryMetadata: ["prepareDirectory"],
+                atomicEntryRemoval: ["removeEntryConditional"], atomicTreeRemoval: ["removeTreeConditional"], atomicFileMutation: ["writeFileConditional", "removeFileConditional"], atomicFileStaging: ["createStagedFile", "publishStagedFile", "removeStagedFile"], atomicDirectoryMetadata: ["prepareDirectory"],
                 symlinks: ["symlink", "readlink"], hardlinks: ["link"], permissions: ["chmod"], timestamps: ["utimes"], readlink: ["readlink"],
                 descriptorWriteStream: ["writeStream"], retainedResize: ["openResizeFile"], atomicResize: ["resizeFile"],
             };
@@ -114,7 +114,7 @@ export class MountFileSystem {
             return values.every(value => value === true) ? true : values.every(value => value === false) ? false : undefined;
         };
         const semantics = Object.fromEntries([
-            "atomicEntryRemoval", "atomicFileMutation", "atomicFileStaging", "atomicDirectoryMetadata", "read", "stat", "readdir", "realpath", "access", "open",
+            "atomicEntryRemoval", "atomicTreeRemoval", "atomicFileMutation", "atomicFileStaging", "atomicDirectoryMetadata", "read", "stat", "readdir", "realpath", "access", "open",
             "write", "append", "exclusiveCreate", "explicitDirectories", "implicitDirectories", "mkdir", "recursiveMkdir",
             "remove", "removeDirectory", "recursiveRemove", "rename", "atomicRenameNoReplace", "copy", "exclusiveCopy", "readlink", "truncate",
             "streamingAppend", "randomAccessWrite", "descriptorWriteStream", "retainedResize", "atomicResize", "symlinks", "hardlinks", "permissions", "timestamps",
@@ -620,6 +620,19 @@ export class MountFileSystem {
             await backend.removeFileConditional(location.local, options);
         });
     }
+    removeTreeConditional(path, options) {
+        return this.operation("removeTreeConditional", path, options, async () => {
+            const location = await this.resolve(path, options, { followFinal: false, entry: true, allowMissing: true });
+            if (this.protected(location.path))
+                fail("EBUSY");
+            this.mutable(location);
+            const backend = location.mount.backend;
+            await requireOwnedMutation(backend, location.local, "atomicTreeRemoval", options);
+            if (!backend.removeTreeConditional)
+                fail("ENOTSUP");
+            await backend.removeTreeConditional(location.local, options);
+        });
+    }
     createStagedFile(path, name, content, options) {
         return this.operation("createStagedFile", path, options, async () => {
             const location = await this.resolve(path, options, { followFinal: false, entry: true, allowMissing: true, missingDirectory: true });

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

@@ -4,7 +4,7 @@ import { registerEntryView } from "./mount/comparison.js";
 import { openRetainedResizeFile, retainedResizeCapabilities, ownedMutationCapabilities, requireOwnedMutation } from "./capabilities.js";
 const originals = new WeakMap();
 const operations = new Set([
-    "removeEntryConditional", "writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory",
+    "removeEntryConditional", "removeTreeConditional", "writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory",
     "access", "appendFile", "canonicalizeMissingTarget", "capabilitiesFor", "chmod", "compareEntry",
     "copyFile", "link", "lstat", "mkdir", "openReadFile", "openResizeFile", "readFile", "readStream", "readdir",
     "readlink", "realpath", "rename", "resizeFile", "rm", "rmdir", "unlink", "stat", "symlink", "truncate", "utimes",
@@ -198,12 +198,12 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
                     const options = args.at(-1);
                     admit(options && typeof options === "object" && "signal" in options ? options : undefined);
                 }
-                if (["removeEntryConditional", "writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory"].includes(String(property)))
+                if (["removeEntryConditional", "removeTreeConditional", "writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory"].includes(String(property)))
                     return (async () => {
                         const path = typeof args[0] === "string" ? args[0] : args[0].directory.path;
                         const options = args[property === "createStagedFile" ? 3 : property === "publishStagedFile" || property === "writeFileConditional" ? 2 : 1];
                         const create = property === "createStagedFile" || (property === "writeFileConditional" || property === "prepareDirectory") && options !== undefined && "expected" in options && options.expected === null;
-                        await requireOwnedMutation(original, path, property === "removeEntryConditional" ? "atomicEntryRemoval" : property === "prepareDirectory" ? "atomicDirectoryMetadata" : property === "writeFileConditional" || property === "removeFileConditional" ? "atomicFileMutation" : "atomicFileStaging", options ?? {}, create);
+                        await requireOwnedMutation(original, path, property === "removeEntryConditional" ? "atomicEntryRemoval" : property === "removeTreeConditional" ? "atomicTreeRemoval" : property === "prepareDirectory" ? "atomicDirectoryMetadata" : property === "writeFileConditional" || property === "removeFileConditional" ? "atomicFileMutation" : "atomicFileStaging", options ?? {}, create);
                         assertOpen(options);
                         return Reflect.apply(method, original, args);
                     })();

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

@@ -18,7 +18,7 @@ export type PythonFsRequest = {
     readonly op: "sync";
     readonly args: readonly [number, boolean];
 } | {
-    readonly op: "stat" | "lstat" | "readdir" | "realpath" | "readlink" | "rm" | "rmdir";
+    readonly op: "stat" | "lstat" | "readdir" | "realpath" | "readlink" | "rm" | "rmdir" | "rmtree" | "rmtreeSupported";
     readonly args: readonly [string];
 } | {
     readonly op: "rename" | "symlink" | "link";

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

@@ -1,7 +1,7 @@
 import { parsePythonFsRequest } from "./request.js";
 import { composeAbortSignals } from "../contracts/abort.js";
 import { FsError } from "../contracts/errors.js";
-import { validatePath } from "../contracts/virtual-path.js";
+import { dirname, validatePath } from "../contracts/virtual-path.js";
 /** Async half of a worker RPC filesystem. Never run this on an Atomics.wait-blocked interpreter thread. */
 export class PythonFileSystem {
     #fs;
@@ -176,6 +176,25 @@ export class PythonFileSystem {
                     throw new FsError("ENOTSUP", { syscall: "rmdir", path });
                 return fs.rmdir(path, options);
             }
+            case "rmtreeSupported":
+            case "rmtree": {
+                const path = this.#path(request.args[0]);
+                const capabilities = fs.capabilitiesFor ? await fs.capabilitiesFor(path, options) : fs.capabilities;
+                signal.throwIfAborted();
+                if (request.op === "rmtreeSupported")
+                    return capabilities.readOnly === true || capabilities.atomicTreeRemoval === true && typeof fs.removeTreeConditional === "function";
+                if (capabilities.readOnly === true)
+                    throw new FsError("EROFS", { syscall: "rmtree", path });
+                if (capabilities.atomicTreeRemoval !== true || !fs.removeTreeConditional)
+                    throw new FsError("ENOTSUP", { syscall: "rmtree", path });
+                const expected = await fs.lstat(path, options);
+                signal.throwIfAborted();
+                if (expected.type !== "directory")
+                    throw new FsError("ENOTDIR", { syscall: "rmtree", path });
+                const parent = await fs.stat(dirname(path), options);
+                signal.throwIfAborted();
+                return fs.removeTreeConditional(path, { ...options, parent, expected });
+            }
             case "rename": return fs.rename(this.#path(request.args[0]), this.#path(request.args[1]), options);
             case "readlink":
                 if (fs.readlink)

package/dist/safe-fs/python/request.js

@@ -2,7 +2,7 @@ import { FsError } from "../contracts/errors.js";
 const argumentKinds = {
     open: ["string", "object"], read: ["number", "number", "position"], write: ["number", "bytes", "position"],
     descriptorCapabilities: ["number"], fstat: ["number"], close: ["number"], position: ["number"], ftruncate: ["number", "number"], sync: ["number", "boolean"],
-    stat: ["string"], lstat: ["string"], readdir: ["string"], realpath: ["string"], readlink: ["string"], rm: ["string"], rmdir: ["string"],
+    stat: ["string"], lstat: ["string"], readdir: ["string"], realpath: ["string"], readlink: ["string"], rm: ["string"], rmdir: ["string"], rmtree: ["string"], rmtreeSupported: ["string"],
     rename: ["string", "string"], symlink: ["string", "string"], link: ["string", "string"], mkdir: ["string", "optionalObject"],
     chmod: ["string", "number"], truncate: ["string", "number"], access: ["string", "number"], utimes: ["string", "number", "number"],
 };

package/package.json

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