@poe-platform/safe-fs 0.1.230 → 0.1.232

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

@@ -54,6 +54,7 @@ export interface FileSystemCapabilities {
     readonly streamingRead?: boolean;
     readonly retainedRead?: boolean;
     readonly streamingWrite?: boolean;
+    readonly descriptorWriteStream?: boolean;
     readonly [capability: string]: boolean | undefined;
 }
 export interface FsOptions {

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

@@ -37,6 +37,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,
         atomicRename: false, streamingWrite: false,
     });
 }
@@ -44,7 +45,7 @@ export function quotaCapabilities(capabilities) {
     const streamingWrite = requireCapabilities(capabilities.write, capabilities.append, !capabilities.readOnly);
     const streamingAppend = requireCapabilities(capabilities.append, !capabilities.readOnly);
     const { streamingWrite: ignoredWrite, streamingAppend: ignoredAppend, ...rest } = capabilities;
-    return Object.freeze({ ...rest,
+    return Object.freeze({ ...rest, descriptorWriteStream: false,
         ...(streamingWrite === undefined ? {} : { streamingWrite }),
         ...(streamingAppend === undefined ? {} : { streamingAppend }),
     });

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

@@ -33,6 +33,7 @@ export declare class MemoryFileSystem implements FileSystem {
         streamingRead: true;
         retainedRead: true;
         streamingWrite: true;
+        readonly descriptorWriteStream: boolean;
     }>;
     private readonly identityScope;
     private nextInode;
@@ -56,7 +57,7 @@ export declare class MemoryFileSystem implements FileSystem {
     private bytes;
     private allocate;
     private openWrite;
-    private append;
+    private writeAt;
     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/memory/index.js

@@ -49,22 +49,25 @@ const compareOwnedMemory = async (own, peer, options) => {
     return qualified ? "distinct" : "unknown";
 };
 export class MemoryFileSystem {
-    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, removeDirectory: true, recursiveRemove: true,
-        rename: true, copy: true, exclusiveCopy: true, readlink: true, truncate: true,
-        streamingAppend: true, randomAccessWrite: true,
-        readOnly: false,
-        symlinks: true,
-        hardlinks: true,
-        permissions: true,
-        timestamps: true,
-        atomicRename: true,
-        streamingRead: true,
-        retainedRead: true,
-        streamingWrite: true,
-    });
+    capabilities = ((filesystem) => {
+        return 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, removeDirectory: true, recursiveRemove: true,
+            rename: true, copy: true, exclusiveCopy: true, readlink: true, truncate: true,
+            streamingAppend: true, randomAccessWrite: true,
+            readOnly: false,
+            symlinks: true,
+            hardlinks: true,
+            permissions: true,
+            timestamps: true,
+            atomicRename: true,
+            streamingRead: true,
+            retainedRead: true,
+            streamingWrite: true,
+            get descriptorWriteStream() { return stockDescriptorWrite(filesystem); },
+        });
+    })(this);
     identityScope = Symbol();
     nextInode = 1;
     root = this.directory(0o755);
@@ -72,6 +75,7 @@ export class MemoryFileSystem {
         const root = this.root;
         ownedStores.set(this, {
             root,
+            capabilities: this.capabilities,
             intact: () => this.root === root,
         });
         if (this.compareEntry === memoryImplementation.compareEntry?.value) {
@@ -252,8 +256,15 @@ export class MemoryFileSystem {
         this.changed(location.parent);
         return node;
     }
-    append(node, data, syscall, path) {
-        const length = node.data.byteLength + data.byteLength;
+    writeAt(node, data, position, syscall, path) {
+        if (data.byteLength === 0) {
+            this.changed(node);
+            return;
+        }
+        const end = position + data.byteLength;
+        if (!Number.isSafeInteger(end))
+            this.fail("EFBIG", syscall, path);
+        const length = Math.max(node.data.byteLength, end);
         let storage;
         if (length <= node.data.buffer.byteLength) {
             storage = new Uint8Array(node.data.buffer);
@@ -262,7 +273,9 @@ export class MemoryFileSystem {
             storage = this.allocate(Math.max(length, node.data.byteLength * 2, 64), syscall, path);
             storage.set(node.data);
         }
-        storage.set(data, node.data.byteLength);
+        if (position > node.data.byteLength)
+            storage.fill(0, node.data.byteLength, position);
+        storage.set(data, position);
         node.data = storage.subarray(0, length);
         this.changed(node);
     }
@@ -282,7 +295,7 @@ export class MemoryFileSystem {
         const copied = this.bytes(data);
         const node = this.openWrite(path, options, "writeFile");
         if (options.flag === "a" || options.flag === "ax")
-            this.append(node, copied, "writeFile", path);
+            this.writeAt(node, copied, node.data.byteLength, "writeFile", path);
         else {
             node.data = copied;
             this.changed(node);
@@ -291,7 +304,8 @@ export class MemoryFileSystem {
     async appendFile(path, data, options = {}) {
         options.signal?.throwIfAborted();
         const copied = this.bytes(data);
-        this.append(this.openWrite(path, { ...options, flag: "a" }, "appendFile"), copied, "appendFile", path);
+        const node = this.openWrite(path, { ...options, flag: "a" }, "appendFile");
+        this.writeAt(node, copied, node.data.byteLength, "appendFile", path);
     }
     async stat(path, options = {}) {
         options.signal?.throwIfAborted();
@@ -589,18 +603,40 @@ export class MemoryFileSystem {
     async writeStream(path, source, options = {}) {
         options.signal?.throwIfAborted();
         const node = this.openWrite(path, options, "writeStream");
-        if (options.flag !== "a" && options.flag !== "ax") {
+        const append = options.flag === "a" || options.flag === "ax";
+        let position = 0;
+        if (!append) {
             node.data = new Uint8Array();
             this.changed(node);
         }
         for await (const chunk of source) {
             options.signal?.throwIfAborted();
-            this.append(node, this.bytes(chunk), "writeStream", path);
+            if (!(chunk instanceof Uint8Array))
+                throw new TypeError("Memory files require Uint8Array data");
+            this.writeAt(node, chunk, append ? node.data.byteLength : position, "writeStream", path);
+            if (!append)
+                position += chunk.byteLength;
         }
         options.signal?.throwIfAborted();
     }
 }
 const memoryImplementation = Object.getOwnPropertyDescriptors(MemoryFileSystem.prototype);
+function stockDescriptorWrite(filesystem) {
+    if (Object.getPrototypeOf(filesystem) !== MemoryFileSystem.prototype)
+        return false;
+    const owner = ownedStores.get(filesystem);
+    if (!owner || Object.getOwnPropertyDescriptor(filesystem, "root")?.value !== owner.root
+        || Object.getOwnPropertyDescriptor(filesystem, "capabilities")?.value !== owner.capabilities)
+        return false;
+    for (const name of ["writeStream", "writeFile", "appendFile", "access", "stat", "lstat", "realpath",
+        "openWrite", "resolve", "permission", "validatePath", "mode", "bytes", "allocate", "changed", "metadata", "integer", "writeAt", "fail"]) {
+        const descriptor = Object.getOwnPropertyDescriptor(filesystem, name)
+            ?? Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, name);
+        if (!descriptor || !("value" in descriptor) || descriptor.value !== memoryImplementation[name]?.value)
+            return false;
+    }
+    return true;
+}
 export function createMemoryFileSystem() {
     return new MemoryFileSystem();
 }

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

@@ -85,12 +85,15 @@ export class MountFileSystem {
         const common = (capability) => {
             const optional = {
                 symlinks: ["symlink", "readlink"], hardlinks: ["link"], permissions: ["chmod"], timestamps: ["utimes"], readlink: ["readlink"],
+                descriptorWriteStream: ["writeStream"],
             };
             const values = mounts.map(({ backend }) => {
                 if (backend.capabilities.readOnly === true
                     && !["read", "stat", "readdir", "realpath", "access", "readlink", "explicitDirectories", "implicitDirectories"].includes(capability))
                     return false;
                 const declared = backend.capabilities[capability];
+                if (capability === "descriptorWriteStream" && backend.capabilities.streamingWrite === false)
+                    return false;
                 return declared === true && optional[capability]?.some(method => typeof backend[method] !== "function") ? false : declared;
             });
             if (["rename", "copy", "exclusiveCopy"].includes(capability) && mounts.length > 1)
@@ -101,7 +104,7 @@ export class MountFileSystem {
             "read", "stat", "readdir", "realpath", "access",
             "write", "append", "exclusiveCreate", "explicitDirectories", "implicitDirectories", "mkdir", "recursiveMkdir",
             "remove", "removeDirectory", "recursiveRemove", "rename", "copy", "exclusiveCopy", "readlink", "truncate",
-            "streamingAppend", "randomAccessWrite", "symlinks", "hardlinks", "permissions", "timestamps",
+            "streamingAppend", "randomAccessWrite", "descriptorWriteStream", "symlinks", "hardlinks", "permissions", "timestamps",
         ].map(capability => [capability, common(capability)]).filter(([, value]) => value !== undefined));
         this.capabilities = Object.freeze({
             get snapshotRmdir() { return mounts.some(({ backend }) => backend.capabilities.snapshotRmdir === true); },
@@ -120,8 +123,11 @@ export class MountFileSystem {
     async capabilitiesFor(path, options = {}) {
         return this.operation("capabilitiesFor", path, options, async () => {
             const location = await this.resolve(path, options, { allowMissing: true });
-            const declared = await location.mount.backend.capabilitiesFor?.(location.local, options)
+            const observed = await location.mount.backend.capabilitiesFor?.(location.local, options)
                 ?? location.mount.backend.capabilities;
+            const declared = observed.descriptorWriteStream === true
+                && (typeof location.mount.backend.writeStream !== "function" || observed.readOnly === true || observed.streamingWrite === false)
+                ? { ...observed, descriptorWriteStream: false } : observed;
             const capabilities = location.synthetic ? { ...declared, retainedRead: false }
                 : retainedReadCapabilities(location.mount.backend, declared);
             if (location.synthetic)

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

@@ -118,6 +118,7 @@ export class OverlayFileSystem {
             ...(upper.readOnly === undefined ? {} : { readOnly: upper.readOnly }),
             ...(effectiveAppend === undefined ? {} : { append: effectiveAppend }),
             atomicRename: false,
+            descriptorWriteStream: false,
             hardlinks: false,
             symlinks: writable && this.#upper.capabilities.symlinks === true
                 && typeof this.#upper.symlink === "function" && typeof this.#upper.readlink === "function"

package/package.json

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