@zenfs/core 2.7.3 → 2.7.5

package/dist/internal/filesystem.d.ts

@@ -117,6 +117,7 @@ export interface StreamOptions {
     start?: number;
     end?: number;
     autoClose?: boolean;
+    chunkSize?: number;
 }
 /**
  * Provides a consistent and easy to use internal API.

package/dist/internal/filesystem.js

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { withErrno } from 'kerium';
 import { ioctl_default_ops_async, ioctl_default_ops_sync } from './ioctl.js';
-const _chunkSize = 0x1000;
+/** Default bytes per chunk for streamed reads, matching Node's default stream `highWaterMark` */
+const defaultChunkSize = 0x10000;
 /**
  * Provides a consistent and easy to use internal API.
  * Default implementations for `exists` and `existsSync` are included.
@@ -97,17 +98,22 @@ export class FileSystem {
      * @privateRemarks The default implementation of `streamRead` uses "chunked" `read`s
      */
     streamRead(path, options) {
+        const { chunkSize = defaultChunkSize } = options;
+        let offset = options.start ?? 0;
+        let end = options.end;
         return new ReadableStream({
-            start: async (controller) => {
-                const { size } = await this.stat(path);
-                const { start = 0, end = size } = options;
-                for (let offset = start; offset < end; offset += _chunkSize) {
-                    const bytesRead = offset + _chunkSize > end ? end - offset : _chunkSize;
-                    const buffer = new Uint8Array(bytesRead);
-                    await this.read(path, buffer, offset, offset + bytesRead).catch(controller.error.bind(controller));
-                    controller.enqueue(buffer);
+            pull: async (controller) => {
+                end ??= (await this.stat(path)).size;
+                if (offset >= end) {
+                    controller.close();
+                    return;
                 }
-                controller.close();
+                const buffer = new Uint8Array(Math.min(chunkSize, end - offset));
+                await this.read(path, buffer, offset, offset + buffer.byteLength);
+                offset += buffer.byteLength;
+                controller.enqueue(buffer);
+                if (offset >= end)
+                    controller.close();
             },
             type: 'bytes',
         });
@@ -140,7 +146,7 @@ export class FileSystem {
         const cmd = ioctl_default_ops_async[command];
         if (!cmd)
             throw withErrno('ENOTTY');
-        return await cmd(this, context, ...args);
+        return await cmd(context, ...args);
     }
     /** @internal */
     ioctlSync(context, command, ...args) {
@@ -148,6 +154,6 @@ export class FileSystem {
         const cmd = ioctl_default_ops_sync[command];
         if (!cmd)
             throw withErrno('ENOTTY');
-        return cmd(this, context, ...args);
+        return cmd(context, ...args);
     }
 }

package/dist/internal/inode.d.ts

@@ -145,9 +145,19 @@ export declare enum InodeFlags {
     /** File is in use by the kernel (eg. fs/cachefiles) */
     KernelFile = 131072
 }
-/** User visible flags */
+/**
+ * User visible flags
+ * These are actually masks for userspace `FileFlag`s, not `InodeFlags`.
+ * @deprecated Use the export from `/internal/ioctl`
+ * @todo [breaking] remove
+ */
 export declare const userVisibleFlags = 253951;
-/** User modifiable flags */
+/**
+ * User modifiable flags
+ * These are actually masks for userspace `FileFlag`s, not `InodeFlags`.
+ * @deprecated Use the export from `/internal/ioctl`
+ * @todo [breaking] remove these re-exports
+ */
 export declare const userModifiableFlags = 229631;
 declare const Inode_base: import("memium").StructConstructor<BufferView<any>>;
 /**

package/dist/internal/inode.js

@@ -326,9 +326,19 @@ export var InodeFlags;
     /** File is in use by the kernel (eg. fs/cachefiles) */
     InodeFlags[InodeFlags["KernelFile"] = 131072] = "KernelFile";
 })(InodeFlags || (InodeFlags = {}));
-/** User visible flags */
+/**
+ * User visible flags
+ * These are actually masks for userspace `FileFlag`s, not `InodeFlags`.
+ * @deprecated Use the export from `/internal/ioctl`
+ * @todo [breaking] remove
+ */
 export const userVisibleFlags = 0x0003dfff;
-/** User modifiable flags */
+/**
+ * User modifiable flags
+ * These are actually masks for userspace `FileFlag`s, not `InodeFlags`.
+ * @deprecated Use the export from `/internal/ioctl`
+ * @todo [breaking] remove these re-exports
+ */
 export const userModifiableFlags = 0x000380ff;
 /**
  * Generic inode definition that can easily be serialized.

package/dist/internal/ioctl.d.ts

@@ -1,38 +1,96 @@
-import { BufferView } from 'utilium/buffer';
 import type { FileSystem } from './filesystem.js';
 import type { InodeLike } from './inode.js';
-declare const fsxattr_base: import("memium").StructConstructor<BufferView<any>>;
-declare class fsxattr extends fsxattr_base {
-    static name: string;
-    /** xflags field value */
-    accessor xflags: number;
-    /** extsize field value */
-    accessor extsize: number;
-    /** nextents field value */
-    accessor nextents: number;
-    /** project identifier */
-    accessor projid: number;
-    /** CoW extsize field value */
-    accessor cowextsize: number;
-    protected accessor pad: number[];
-    constructor(inode?: Readonly<InodeLike>);
+/**
+ * Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS)
+ * @see `FS_*_FL` in `include/uapi/linux/fs.h` (around L250)
+ * @experimental
+ */
+export declare enum FileFlag {
+    /** Secure deletion */
+    SecureRm = 1,
+    /** Undelete */
+    Undelete = 2,
+    /** Compress file */
+    Compress = 4,
+    /** Synchronous updates */
+    Sync = 8,
+    /** Immutable file */
+    Immutable = 16,
+    /** Writes to file may only append */
+    Append = 32,
+    /** do not dump file */
+    NoDump = 64,
+    /** do not update atime */
+    NoAtime = 128,
+    Dirty = 256,
+    /** One or more compressed clusters */
+    CompressBlk = 512,
+    /** Don't compress */
+    NoCompress = 1024,
+    /** Encrypted file */
+    Encrypt = 2048,
+    /** btree format dir */
+    Btree = 4096,
+    /** hash-indexed directory */
+    Index = 4096,
+    /** AFS directory */
+    IMagic = 8192,
+    /** Reserved for ext3 */
+    JournalData = 16384,
+    /** file tail should not be merged */
+    NoTail = 32768,
+    /** dirsync behaviour (directories only) */
+    DirSync = 65536,
+    /** Top of directory hierarchies*/
+    TopDir = 131072,
+    /** Reserved for ext4 */
+    HugeFile = 262144,
+    /** Extents */
+    Extent = 524288,
+    /** Verity protected inode */
+    Verity = 1048576,
+    /** Inode used for large EA */
+    EaInode = 2097152,
+    /** Reserved for ext4 */
+    EofBlocks = 4194304,
+    /** Do not cow file */
+    NoCow = 8388608,
+    /** Inode is DAX */
+    Dax = 33554432,
+    /** Reserved for ext4 */
+    InlineData = 268435456,
+    /** Create with parents projid */
+    ProjInherit = 536870912,
+    /** Folder is case insensitive */
+    CaseFold = 1073741824,
+    /** reserved for ext2 lib */
+    Reserved = 2147483648
 }
+/** User visible flags */
+export declare const userVisibleFlags = 253951;
+/** User modifiable flags */
+export declare const userModifiableFlags = 229631;
 /**
  * `FS_IOC_*` commands for {@link ioctl | `ioctl`}
  * @remarks
  * These are computed from a script since constant values are needed for enum member types
+ * @todo [breaking] remove deprecated flags and handlers
  */
 export declare enum IOC {
     GetFlags = 2148034049,
     SetFlags = 1074292226,
     GetVersion = 2148038145,
     SetVersion = 1074296322,
+    /** @deprecated */
     Fiemap = 3223348747,
+    /** @deprecated  */
     GetXattr = 2149341215,
+    /** @deprecated */
     SetXattr = 1075599392,
     GetLabel = 2164298801,
     SetLabel = 1090556978,
     GetUUID = 2148603136,
+    /** @deprecated */
     GetSysfsPath = 2155943169
 }
 /**
@@ -82,12 +140,12 @@ export declare const ioctl_default_ops: {
     2148038145($: IoctlContext): number;
     2147776001($: IoctlContext): number;
     3223348747(): never;
-    2149341215($: IoctlContext, _name: string): fsxattr;
-    1075599392($: IoctlContext, _name: string, _value: fsxattr): never;
+    2149341215(): never;
+    1075599392(): never;
     2164298801($: IoctlContext): string | undefined;
     1090556978($: IoctlContext, label: string): void;
     2148603136($: IoctlContext): string;
-    2155943169($: IoctlContext): string;
+    2155943169(): never;
 };
 /**
  * @internal
@@ -103,12 +161,12 @@ export declare const ioctl_default_ops_async: {
     2148038145($: IoctlContext): number;
     2147776001($: IoctlContext): number;
     3223348747(): never;
-    2149341215($: IoctlContext, _name: string): fsxattr;
-    1075599392($: IoctlContext, _name: string, _value: fsxattr): never;
+    2149341215(): never;
+    1075599392(): never;
     2164298801($: IoctlContext): string | undefined;
     1090556978($: IoctlContext, label: string): void;
     2148603136($: IoctlContext): string;
-    2155943169($: IoctlContext): string;
+    2155943169(): never;
 };
 type _IoctlOpsAsync = typeof ioctl_default_ops_async;
 /**
@@ -131,12 +189,12 @@ export declare const ioctl_default_ops_sync: {
     2148038145($: IoctlContext): number;
     2147776001($: IoctlContext): number;
     3223348747(): never;
-    2149341215($: IoctlContext, _name: string): fsxattr;
-    1075599392($: IoctlContext, _name: string, _value: fsxattr): never;
+    2149341215(): never;
+    1075599392(): never;
     2164298801($: IoctlContext): string | undefined;
     1090556978($: IoctlContext, label: string): void;
     2148603136($: IoctlContext): string;
-    2155943169($: IoctlContext): string;
+    2155943169(): never;
 };
 type _IoctlOpsSync = typeof ioctl_default_ops_sync;
 /**

package/dist/internal/ioctl.js

@@ -1,178 +1,11 @@
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-import { Errno, Exception, withErrno } from 'kerium';
-import { sizeof } from 'memium';
-import { $from, struct, types as t } from 'memium/decorators';
-import { _throw } from 'utilium';
-import { BufferView } from 'utilium/buffer';
+import { withErrno } from 'kerium';
 import { InodeFlags } from './inode.js';
-/*
- * Flags for the fsxattr.xflags field
- */
-var XFlag;
-(function (XFlag) {
-    /** data in realtime volume */
-    XFlag[XFlag["RealTime"] = 1] = "RealTime";
-    /** preallocated file extents */
-    XFlag[XFlag["PreAlloc"] = 2] = "PreAlloc";
-    /** file cannot be modified */
-    XFlag[XFlag["Immutable"] = 8] = "Immutable";
-    /** all writes append */
-    XFlag[XFlag["Append"] = 16] = "Append";
-    /** all writes synchronous */
-    XFlag[XFlag["Sync"] = 32] = "Sync";
-    /** do not update access time */
-    XFlag[XFlag["NoAtime"] = 64] = "NoAtime";
-    /** do not include in backups */
-    XFlag[XFlag["NoDump"] = 128] = "NoDump";
-    /** create with rt bit set */
-    XFlag[XFlag["RtInherit"] = 256] = "RtInherit";
-    /** create with parents projid */
-    XFlag[XFlag["ProjInherit"] = 512] = "ProjInherit";
-    /** disallow symlink creation */
-    XFlag[XFlag["NoSymlinks"] = 1024] = "NoSymlinks";
-    /** extent size allocator hint */
-    XFlag[XFlag["ExtSize"] = 2048] = "ExtSize";
-    /** inherit inode extent size */
-    XFlag[XFlag["ExtSzInherit"] = 4096] = "ExtSzInherit";
-    /** do not defragment */
-    XFlag[XFlag["NoDefrag"] = 8192] = "NoDefrag";
-    /** use filestream allocator */
-    XFlag[XFlag["FileStream"] = 16384] = "FileStream";
-    /** use DAX for IO */
-    XFlag[XFlag["Dax"] = 32768] = "Dax";
-    /** CoW extent size allocator hint */
-    XFlag[XFlag["CowExtSize"] = 65536] = "CowExtSize";
-    /** no DIFLAG for this */
-    XFlag[XFlag["HasAttr"] = 2147483648] = "HasAttr";
-})(XFlag || (XFlag = {}));
-let fsxattr = (() => {
-    var _a, _b, _c, _d, _e;
-    let _classDecorators = [struct()];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    let _classSuper = $from(BufferView);
-    let _xflags_decorators;
-    let _xflags_initializers = [];
-    let _xflags_extraInitializers = [];
-    let _extsize_decorators;
-    let _extsize_initializers = [];
-    let _extsize_extraInitializers = [];
-    let _nextents_decorators;
-    let _nextents_initializers = [];
-    let _nextents_extraInitializers = [];
-    let _projid_decorators;
-    let _projid_initializers = [];
-    let _projid_extraInitializers = [];
-    let _cowextsize_decorators;
-    let _cowextsize_initializers = [];
-    let _cowextsize_extraInitializers = [];
-    let _pad_decorators;
-    let _pad_initializers = [];
-    let _pad_extraInitializers = [];
-    var fsxattr = class extends _classSuper {
-        static { _classThis = this; }
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _xflags_decorators = [(_a = t).uint32.bind(_a)];
-            _extsize_decorators = [(_b = t).uint32.bind(_b)];
-            _nextents_decorators = [(_c = t).uint32.bind(_c)];
-            _projid_decorators = [(_d = t).uint32.bind(_d)];
-            _cowextsize_decorators = [(_e = t).uint32.bind(_e)];
-            _pad_decorators = [t.char(8)];
-            __esDecorate(this, null, _xflags_decorators, { kind: "accessor", name: "xflags", static: false, private: false, access: { has: obj => "xflags" in obj, get: obj => obj.xflags, set: (obj, value) => { obj.xflags = value; } }, metadata: _metadata }, _xflags_initializers, _xflags_extraInitializers);
-            __esDecorate(this, null, _extsize_decorators, { kind: "accessor", name: "extsize", static: false, private: false, access: { has: obj => "extsize" in obj, get: obj => obj.extsize, set: (obj, value) => { obj.extsize = value; } }, metadata: _metadata }, _extsize_initializers, _extsize_extraInitializers);
-            __esDecorate(this, null, _nextents_decorators, { kind: "accessor", name: "nextents", static: false, private: false, access: { has: obj => "nextents" in obj, get: obj => obj.nextents, set: (obj, value) => { obj.nextents = value; } }, metadata: _metadata }, _nextents_initializers, _nextents_extraInitializers);
-            __esDecorate(this, null, _projid_decorators, { kind: "accessor", name: "projid", static: false, private: false, access: { has: obj => "projid" in obj, get: obj => obj.projid, set: (obj, value) => { obj.projid = value; } }, metadata: _metadata }, _projid_initializers, _projid_extraInitializers);
-            __esDecorate(this, null, _cowextsize_decorators, { kind: "accessor", name: "cowextsize", static: false, private: false, access: { has: obj => "cowextsize" in obj, get: obj => obj.cowextsize, set: (obj, value) => { obj.cowextsize = value; } }, metadata: _metadata }, _cowextsize_initializers, _cowextsize_extraInitializers);
-            __esDecorate(this, null, _pad_decorators, { kind: "accessor", name: "pad", static: false, private: false, access: { has: obj => "pad" in obj, get: obj => obj.pad, set: (obj, value) => { obj.pad = value; } }, metadata: _metadata }, _pad_initializers, _pad_extraInitializers);
-            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-            fsxattr = _classThis = _classDescriptor.value;
-            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        }
-        static name = 'fsxattr';
-        #xflags_accessor_storage = __runInitializers(this, _xflags_initializers, void 0);
-        /** xflags field value */
-        get xflags() { return this.#xflags_accessor_storage; }
-        set xflags(value) { this.#xflags_accessor_storage = value; }
-        #extsize_accessor_storage = (__runInitializers(this, _xflags_extraInitializers), __runInitializers(this, _extsize_initializers, void 0));
-        /** extsize field value */
-        get extsize() { return this.#extsize_accessor_storage; }
-        set extsize(value) { this.#extsize_accessor_storage = value; }
-        #nextents_accessor_storage = (__runInitializers(this, _extsize_extraInitializers), __runInitializers(this, _nextents_initializers, void 0));
-        /** nextents field value */
-        get nextents() { return this.#nextents_accessor_storage; }
-        set nextents(value) { this.#nextents_accessor_storage = value; }
-        #projid_accessor_storage = (__runInitializers(this, _nextents_extraInitializers), __runInitializers(this, _projid_initializers, void 0));
-        /** project identifier */
-        get projid() { return this.#projid_accessor_storage; }
-        set projid(value) { this.#projid_accessor_storage = value; }
-        #cowextsize_accessor_storage = (__runInitializers(this, _projid_extraInitializers), __runInitializers(this, _cowextsize_initializers, void 0));
-        /** CoW extsize field value */
-        get cowextsize() { return this.#cowextsize_accessor_storage; }
-        set cowextsize(value) { this.#cowextsize_accessor_storage = value; }
-        #pad_accessor_storage = (__runInitializers(this, _cowextsize_extraInitializers), __runInitializers(this, _pad_initializers, []));
-        get pad() { return this.#pad_accessor_storage; }
-        set pad(value) { this.#pad_accessor_storage = value; }
-        constructor(inode = _throw(new Exception(Errno.EINVAL, 'fsxattr must be initialized with an inode'))) {
-            super(new ArrayBuffer(sizeof(fsxattr)));
-            __runInitializers(this, _pad_extraInitializers);
-            this.extsize = inode.size;
-            this.nextents = 1;
-            this.projid = inode.uid;
-            this.cowextsize = inode.size;
-            for (const name of Object.keys(InodeFlags)) {
-                if (!((inode.flags || 0) & InodeFlags[name]))
-                    continue;
-                if (name in XFlag)
-                    this.xflags |= XFlag[name];
-            }
-        }
-        static {
-            __runInitializers(_classThis, _classExtraInitializers);
-        }
-    };
-    return fsxattr = _classThis;
-})();
 /**
  * Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS)
  * @see `FS_*_FL` in `include/uapi/linux/fs.h` (around L250)
  * @experimental
  */
-var FileFlag;
+export var FileFlag;
 (function (FileFlag) {
     /** Secure deletion */
     FileFlag[FileFlag["SecureRm"] = 1] = "SecureRm";
@@ -237,10 +70,43 @@ var FileFlag;
     /** reserved for ext2 lib */
     FileFlag[FileFlag["Reserved"] = 2147483648] = "Reserved";
 })(FileFlag || (FileFlag = {}));
+/** User visible flags */
+export const userVisibleFlags = 0x0003dfff;
+/** User modifiable flags */
+export const userModifiableFlags = 0x000380ff;
+const flagPairs = [
+    [FileFlag.Sync, InodeFlags.Sync],
+    [FileFlag.Immutable, InodeFlags.Immutable],
+    [FileFlag.Append, InodeFlags.Append],
+    [FileFlag.NoAtime, InodeFlags.NoAtime],
+    [FileFlag.Encrypt, InodeFlags.Encrypted],
+    [FileFlag.DirSync, InodeFlags.Dirsync],
+    [FileFlag.Verity, InodeFlags.Verity],
+    [FileFlag.Dax, InodeFlags.DAX],
+    [FileFlag.CaseFold, InodeFlags.CaseFold],
+];
+const supportedFlags = flagPairs.reduce((all, [flag]) => all | flag, 0), settableFlags = flagPairs.reduce((all, [, flag]) => all | flag, 0);
+function toFileFlags(flags) {
+    let value = 0;
+    for (const [file, inode] of flagPairs)
+        if (flags & inode)
+            value |= file;
+    return value;
+}
+function setFlags($, flags) {
+    if (flags & ~supportedFlags)
+        throw withErrno('ENOTSUP', 'Unsupported file flags');
+    let value = 0;
+    for (const [file, inode] of flagPairs)
+        if (flags & file)
+            value |= inode;
+    $.inode.flags = (($.inode.flags || 0) & ~settableFlags) | value;
+}
 /**
  * `FS_IOC_*` commands for {@link ioctl | `ioctl`}
  * @remarks
  * These are computed from a script since constant values are needed for enum member types
+ * @todo [breaking] remove deprecated flags and handlers
  */
 export var IOC;
 (function (IOC) {
@@ -248,12 +114,16 @@ export var IOC;
     IOC[IOC["SetFlags"] = 1074292226] = "SetFlags";
     IOC[IOC["GetVersion"] = 2148038145] = "GetVersion";
     IOC[IOC["SetVersion"] = 1074296322] = "SetVersion";
+    /** @deprecated */
     IOC[IOC["Fiemap"] = 3223348747] = "Fiemap";
+    /** @deprecated  */
     IOC[IOC["GetXattr"] = 2149341215] = "GetXattr";
+    /** @deprecated */
     IOC[IOC["SetXattr"] = 1075599392] = "SetXattr";
     IOC[IOC["GetLabel"] = 2164298801] = "GetLabel";
     IOC[IOC["SetLabel"] = 1090556978] = "SetLabel";
     IOC[IOC["GetUUID"] = 2148603136] = "GetUUID";
+    /** @deprecated */
     IOC[IOC["GetSysfsPath"] = 2155943169] = "GetSysfsPath";
 })(IOC || (IOC = {}));
 /**
@@ -276,12 +146,12 @@ export const ioctl_default_ops = {
     [IOC.GetFlags]($) {
         if (typeof $.inode.flags !== 'number')
             throw withErrno('ENOTTY');
-        return $.inode.flags;
+        return toFileFlags($.inode.flags);
     },
     [IOC32.GetFlags]($) {
         if (typeof $.inode.flags !== 'number')
             throw withErrno('ENOTTY');
-        return $.inode.flags;
+        return toFileFlags($.inode.flags);
     },
     [IOC.GetVersion]($) {
         if (typeof $.inode.version !== 'number')
@@ -296,10 +166,10 @@ export const ioctl_default_ops = {
     [IOC.Fiemap]() {
         throw withErrno('ENOTSUP');
     },
-    [IOC.GetXattr]($, _name) {
-        return new fsxattr($.inode);
+    [IOC.GetXattr]() {
+        throw withErrno('ENOTSUP');
     },
-    [IOC.SetXattr]($, _name, _value) {
+    [IOC.SetXattr]() {
         throw withErrno('ENOTSUP');
     },
     [IOC.GetLabel]($) {
@@ -311,13 +181,8 @@ export const ioctl_default_ops = {
     [IOC.GetUUID]($) {
         return $.fs.uuid;
     },
-    [IOC.GetSysfsPath]($) {
-        /**
-         * Returns the path component under /sys/fs/ that refers to this filesystem;
-         * also /sys/kernel/debug/ for filesystems with debugfs exports
-         * @todo Implement sysfs and have each FS implement the /sys/fs/<name> tree
-         */
-        return `/sys/fs/${$.fs.name}/${$.fs.uuid}`;
+    [IOC.GetSysfsPath]() {
+        throw withErrno('ENOTSUP');
     },
 };
 /**
@@ -327,11 +192,11 @@ export const ioctl_default_ops = {
 export const ioctl_default_ops_async = {
     ...ioctl_default_ops,
     async [IOC.SetFlags]($, flags) {
-        $.inode.flags = flags;
+        setFlags($, flags);
         await $.fs.touch($.path, $.inode);
     },
     async [IOC32.SetFlags]($, flags) {
-        $.inode.flags = flags;
+        setFlags($, flags);
         await $.fs.touch($.path, $.inode);
     },
     async [IOC.SetVersion]($, version) {
@@ -350,11 +215,11 @@ export const ioctl_default_ops_async = {
 export const ioctl_default_ops_sync = {
     ...ioctl_default_ops,
     [IOC.SetFlags]($, flags) {
-        $.inode.flags = flags;
+        setFlags($, flags);
         $.fs.touchSync($.path, $.inode);
     },
     [IOC32.SetFlags]($, flags) {
-        $.inode.flags = flags;
+        setFlags($, flags);
         $.fs.touchSync($.path, $.inode);
     },
     [IOC.SetVersion]($, version) {

package/dist/node/streams.d.ts

@@ -1,10 +1,10 @@
-/// <reference path="../../types/readable-stream.d.ts" preserve="true" />
 import type { Abortable } from 'node:events';
 import type * as fs from 'node:fs';
 import type { CreateReadStreamOptions, CreateWriteStreamOptions } from 'node:fs/promises';
 import type { Callback } from '../utils.js';
 import type { FileHandle } from './promises.js';
-import { Readable, Writable } from 'readable-stream';
+import { Readable } from '@zenfs/streams/readable';
+import { Writable } from '@zenfs/streams/writable';
 interface FSImplementation {
     open?: (...args: unknown[]) => unknown;
     close?: (...args: unknown[]) => unknown;

package/dist/node/streams.js

@@ -1,6 +1,8 @@
+import { eos } from '@zenfs/streams/end-of-stream';
+import { Readable } from '@zenfs/streams/readable';
+import { Writable } from '@zenfs/streams/writable';
 import { Errno, Exception, UV } from 'kerium';
 import { warn } from 'kerium/log';
-import { finished, Readable, Writable } from 'readable-stream';
 /**
  * A ReadStream implementation that wraps an underlying global ReadableStream.
  */
@@ -16,7 +18,11 @@ export class ReadStream extends Readable {
             .then(handle => {
             this._path = handle['vfs'].path;
             // `end` is inclusive for streams, but the internal range is not
-            const internal = handle.readableWebStream({ start: opts.start, end: opts.end === undefined ? undefined : opts.end + 1 });
+            const internal = handle.readableWebStream({
+                start: opts.start,
+                end: opts.end === undefined ? undefined : opts.end + 1,
+                chunkSize: opts.highWaterMark,
+            });
             this.reader = internal.getReader();
             this.pending = false;
         })
@@ -46,7 +52,7 @@ export class ReadStream extends Readable {
      * Closing before the stream has finished reports `ERR_STREAM_PREMATURE_CLOSE`.
      */
     close(callback = () => null) {
-        finished(this, error => callback(error ?? null));
+        eos(this, error => callback(error ?? null));
         this.destroy();
     }
     get path() {

package/dist/vfs/file.js

@@ -93,8 +93,8 @@ import { _chown, InodeFlags, isBlockDevice, isCharacterDevice } from '../interna
 import '../polyfills.js';
 import { validateFD } from '../utils.js';
 import { cacheOf } from './vcache.js';
-/** The chunk size used when streaming reads and writes */
-const streamChunkSize = 0x1000;
+/** Default bytes per chunk for streamed reads, matching Node's default stream `highWaterMark` */
+const streamChunkSize = 0x10000;
 /**
  * @internal
  */
@@ -608,19 +608,25 @@ let Handle = (() => {
             if (this.closed)
                 throw UV('EBADF', 'streamRead', this.path);
             const { vnode } = this;
+            const { chunkSize = streamChunkSize } = options;
+            let offset = options.start ?? 0;
+            let end = options.end;
             return new ReadableStream({
-                async start(controller) {
+                async pull(controller) {
                     const env_15 = { stack: [], error: void 0, hasError: false };
                     try {
                         const _ = __addDisposableResource(env_15, await vnode.lock('ro'), false);
-                        const { start = 0, end = vnode.inode.size } = options;
-                        for (let offset = start; offset < end; offset += streamChunkSize) {
-                            const bytesRead = offset + streamChunkSize > end ? end - offset : streamChunkSize;
-                            const buffer = new Uint8Array(bytesRead);
-                            await vnode.read(buffer, offset, offset + bytesRead).catch(controller.error.bind(controller));
-                            controller.enqueue(buffer);
+                        end ??= vnode.inode.size;
+                        if (offset >= end) {
+                            controller.close();
+                            return;
                         }
-                        controller.close();
+                        const buffer = new Uint8Array(Math.min(chunkSize, end - offset));
+                        await vnode.read(buffer, offset, offset + buffer.byteLength);
+                        offset += buffer.byteLength;
+                        controller.enqueue(buffer);
+                        if (offset >= end)
+                            controller.close();
                     }
                     catch (e_15) {
                         env_15.error = e_15;

package/dist/vfs/vnode.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { RwLockable } from 'kerium/locks';
-import { Resource } from 'utilium/cache';
+import { addRange, Resource } from 'utilium/cache';
 import { InodeFlags, isBlockDevice, isCharacterDevice } from '../internal/inode.js';
 /**
  * A VFS-level node, roughly equivalent to Linux's in-memory `struct inode`.
@@ -57,17 +57,7 @@ export class VNode extends RwLockable {
     }
     /** Add a range to `dirtyRanges`, merging overlapping and adjacent ranges */
     markDirty(start, end) {
-        this.dirtyRanges.push({ start, end });
-        this.dirtyRanges.sort((a, b) => a.start - b.start);
-        const merged = [];
-        for (const range of this.dirtyRanges) {
-            const last = merged.at(-1);
-            if (last && range.start <= last.end)
-                last.end = Math.max(last.end, range.end);
-            else
-                merged.push(range);
-        }
-        this.dirtyRanges = merged;
+        addRange(this.dirtyRanges, start, end);
     }
     /**
      * Copy `[start, end)` from the cache into `buffer`.
@@ -75,12 +65,10 @@ export class VNode extends RwLockable {
      */
     copyFromCache(buffer, start, end) {
         let pos = start;
-        for (const region of this.data.regions) {
+        for (const region of this.data.regionsIn(start, end)) {
             const regionEnd = region.offset + region.data.byteLength;
             if (regionEnd <= pos)
                 continue;
-            if (region.offset >= end)
-                break;
             if (region.offset > pos) {
                 buffer.fill(0, pos - start, region.offset - start);
                 pos = region.offset;

package/dist/vfs/xattr.d.ts

@@ -44,6 +44,8 @@ export interface SetOptions extends Options {
      */
     replace?: boolean;
 }
+/** Attributes outside the `user` namespace that are supported. */
+export declare const allowedRestrictedNames: Set<`user.${string}` | `trusted.${string}` | `system.${string}` | `security.${string}`>;
 /**
  * Gets the value of an extended attribute.
  *

package/dist/vfs/xattr.js

@@ -6,14 +6,15 @@ import { normalizePath } from '../utils.js';
 import { checkAccess } from './config.js';
 import { R_OK, W_OK } from '../constants.js';
 import { resolveMount } from './shared.js';
-const _allowedRestrictedNames = [];
+/** Attributes outside the `user` namespace that are supported. */
+export const allowedRestrictedNames = new Set();
 /**
  * Check permission for the attribute name.
- * For now, only attributes in the 'user' namespace are supported.
- * @throws ENOTSUP for attributes in namespaces other than 'user'
+ * Only the 'user' namespace and whatever is in {@link allowedRestrictedNames} are supported.
+ * @throws ENOTSUP for any other attribute
  */
 function checkName($, name, path, syscall) {
-    if (!name.startsWith('user.') && !_allowedRestrictedNames.includes(name))
+    if (!name.startsWith('user.') && !allowedRestrictedNames.has(name))
         throw UV('ENOTSUP', syscall, path);
 }
 export async function get(path, name, opt = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.7.3",
+	"version": "2.7.5",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -69,18 +69,19 @@
 		"lint": "eslint src tests",
 		"test": "npx -s zenfs-test --clean; npx -s zenfs-test -abcpn; tests/fetch/run.sh; npx -s zenfs-test --report-only",
 		"test:native": "npx -s zenfs-test tests/native-setup.ts --verbose",
+		"test:perf": "zbench",
 		"build": "tsc --build",
 		"dev": "tsc --build --watch",
 		"prepublishOnly": "npm run build"
 	},
 	"dependencies": {
 		"@types/node": "^26.0.0",
+		"@zenfs/streams": "^1.0.0",
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
 		"kerium": "^1.5.0",
 		"memium": "^1.0.0",
-		"readable-stream": "^4.5.2",
-		"utilium": "^3.0.0"
+		"utilium": "^3.7.0"
 	},
 	"devDependencies": {
 		"@eslint/js": "^10.0.1",
@@ -91,7 +92,8 @@
 		"prettier": "^3.2.5",
 		"typedoc": "^0.28.18",
 		"typescript": "^6.0.0",
-		"typescript-eslint": "^8.58.0"
+		"typescript-eslint": "^8.58.0",
+		"zbench-js": "^0.2.0"
 	},
 	"prettier": {
 		"singleQuote": true,

package/tests/fs/streams.test.ts

@@ -141,4 +141,64 @@ suite('Streams', config('streams'), () => {
 		// Closing invalidates the descriptor, so it fails range validation
 		assert.throws(() => fileHandle.createWriteStream(), { code: 'ERR_OUT_OF_RANGE' });
 	});
+
+	// A file large enough to span several chunks, so the read path has to stitch
+	// them back together and the vnode cache has to grow to hold them.
+	const large = Buffer.alloc(200 * 1024);
+	for (let i = 0; i < large.length; i++) large[i] = (i * 31 + 7) & 0xff;
+
+	test('createReadStream reads a multi-chunk file byte for byte', async () => {
+		await fs.promises.writeFile('large.bin', large);
+
+		const chunks: Uint8Array[] = [];
+		for await (const chunk of fs.createReadStream('large.bin')) chunks.push(chunk as Uint8Array);
+
+		assert.deepEqual(Buffer.concat(chunks), large);
+	});
+
+	test('createReadStream honors highWaterMark as the chunk size', async () => {
+		await fs.promises.writeFile('large.bin', large);
+
+		const highWaterMark = 64 * 1024;
+		const sizes: number[] = [];
+		for await (const chunk of fs.createReadStream('large.bin', { highWaterMark })) sizes.push((chunk as Uint8Array).byteLength);
+
+		// Every chunk but the last is a full highWaterMark, and they sum to the file
+		assert.deepEqual(sizes.slice(0, -1), Array(sizes.length - 1).fill(highWaterMark));
+		assert.equal(
+			sizes.reduce((a, b) => a + b, 0),
+			large.length
+		);
+	});
+
+	test('createReadStream with start and end spanning chunks', async () => {
+		await fs.promises.writeFile('large.bin', large);
+
+		// `end` is inclusive, and this range deliberately starts and stops mid-chunk
+		const start = 1000;
+		const end = 150_000;
+		const chunks: Uint8Array[] = [];
+		for await (const chunk of fs.createReadStream('large.bin', { start, end, highWaterMark: 8192 })) chunks.push(chunk as Uint8Array);
+
+		assert.deepEqual(Buffer.concat(chunks), large.subarray(start, end + 1));
+	});
+
+	test('a read stream does not read past the end of the file', async () => {
+		await fs.promises.writeFile('small.bin', large.subarray(0, 10));
+
+		const chunks: Uint8Array[] = [];
+		for await (const chunk of fs.createReadStream('small.bin', { highWaterMark: 64 * 1024 })) chunks.push(chunk as Uint8Array);
+
+		assert.equal(chunks.length, 1);
+		assert.deepEqual(chunks[0], large.subarray(0, 10));
+	});
+
+	test('a read stream over an empty file ends without a chunk', async () => {
+		await fs.promises.writeFile('empty.bin', '');
+
+		const chunks: unknown[] = [];
+		for await (const chunk of fs.createReadStream('empty.bin')) chunks.push(chunk);
+
+		assert.deepEqual(chunks, []);
+	});
 });

package/tests/perf/append.ts

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Sequential appends into one region. Every write extends the same region, so a region that
+// allocates exactly what it needs copies the whole file on each append.
+import type { FileHandle } from '@zenfs/core/promises';
+import { fs, mount, piece } from './common.ts';
+
+interface Config {
+	writes: number;
+}
+
+interface State {
+	data: Buffer;
+	handle?: FileHandle;
+}
+
+export async function setup(): Promise<State> {
+	await mount('perf-append');
+	return { data: Buffer.alloc(piece, 0x11) };
+}
+
+export async function before(config: Config, state: State): Promise<void> {
+	state.handle = await fs.promises.open('/a', 'w');
+}
+
+export async function test(config: Config, state: State) {
+	for (let i = 0; i < config.writes; i++) await state.handle!.write(state.data, 0, state.data.length, i * piece);
+
+	return { writes: config.writes, bytes: config.writes * piece };
+}
+
+export async function after(config: Config, state: State): Promise<void> {
+	await state.handle!.close();
+	await fs.promises.rm('/a');
+}

package/tests/perf/common.ts

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+import { configureSingle, fs, InMemory } from '@zenfs/core';
+
+export { fs };
+
+export const KB = 1024;
+export const MB = 1024 * 1024;
+
+/**
+ * A piece and the stride between pieces, chosen so consecutive writes never merge into one region:
+ * the 12 KB hole between them is wider than `regionGapThreshold`.
+ */
+export const piece = 4 * KB;
+export const stride = 16 * KB;
+
+/** A fresh in-memory filesystem, so no configuration inherits another's cached vnodes. */
+export async function mount(name: string): Promise<void> {
+	await configureSingle({ backend: InMemory, name });
+}
+
+/** Split a buffer the way a stream writer feeds it. */
+export function chunks(buffer: Buffer, size: number): Buffer[] {
+	const out: Buffer[] = [];
+	for (let i = 0; i < buffer.length; i += size) out.push(buffer.subarray(i, Math.min(i + size, buffer.length)));
+	return out;
+}
+
+/** Give the event loop a moment, so work queued by the previous phase never lands in the timed one. */
+export function settle(): Promise<void> {
+	return new Promise(resolve => setTimeout(resolve, 50));
+}

package/tests/perf/config.json

@@ -0,0 +1,84 @@
+{
+	"flags": {
+		"prep": ["writeFile", "stream"]
+	},
+	"tests": [
+		{
+			"path": "stream-read.ts",
+			"name": "Read with createReadStream",
+			"flags": ["prep"],
+			"measure": {
+				"bytes": { "throughput": "s", "aggregate_throughput": "s", "unit": "MB" },
+				"files": { "cost": true, "unit": "file" }
+			},
+			"configurations": [
+				{ "name": "4K x2000", "value": { "size": 4096, "count": 2000, "hwm": 65536 } },
+				{ "name": "256K x200", "value": { "size": 262144, "count": 200, "hwm": 65536 } },
+				{ "name": "8M x8", "cpu": 1, "mem": 1, "value": { "size": 8388608, "count": 8, "hwm": 65536 } },
+				{
+					"name": "8M x8, hwm 1M",
+					"cpu": 1,
+					"mem": 1,
+					"value": { "size": 8388608, "count": 8, "hwm": 1048576 }
+				}
+			]
+		},
+		{
+			"path": "stream-write.ts",
+			"name": "Write with createWriteStream",
+			"measure": {
+				"bytes": { "throughput": "s", "aggregate_throughput": "s", "unit": "MB" },
+				"files": { "cost": true, "unit": "file" }
+			},
+			"configurations": [
+				{ "name": "4K x2000", "value": { "size": 4096, "count": 2000, "hwm": 65536 } },
+				{ "name": "256K x200", "value": { "size": 262144, "count": 200, "hwm": 65536 } },
+				{ "name": "8M x8", "cpu": 1, "mem": 1, "value": { "size": 8388608, "count": 8, "hwm": 65536 } },
+				{
+					"name": "8M x8, hwm 1M",
+					"cpu": 1,
+					"mem": 1,
+					"value": { "size": 8388608, "count": 8, "hwm": 1048576 }
+				}
+			]
+		},
+		{
+			"path": "fragmented-read.ts",
+			"name": "Read across many cached regions",
+			"measure": {
+				"reads": { "cost": true, "aggregate_cost": true, "unit": "read" }
+			},
+			"configurations": [
+				{ "name": "128 regions", "value": { "regions": 128, "reads": 4000 } },
+				{ "name": "512 regions", "value": { "regions": 512, "reads": 4000 } },
+				{ "name": "2048 regions", "cpu": 1, "value": { "regions": 2048, "reads": 4000 } },
+				{ "name": "8192 regions", "cpu": 2, "mem": 1, "value": { "regions": 8192, "reads": 4000 } }
+			]
+		},
+		{
+			"path": "fragmented-write.ts",
+			"name": "Scattered writes into one file",
+			"measure": {
+				"writes": { "cost": true, "aggregate_cost": true, "unit": "write" }
+			},
+			"configurations": [
+				{ "name": "512 writes", "value": { "writes": 512 } },
+				{ "name": "2048 writes", "cpu": 1, "value": { "writes": 2048 } },
+				{ "name": "8192 writes", "cpu": 2, "mem": 1, "value": { "writes": 8192 } }
+			]
+		},
+		{
+			"path": "append.ts",
+			"name": "Append 4 KB at a time",
+			"measure": {
+				"bytes": { "throughput": "s", "unit": "MB" },
+				"writes": { "cost": true, "aggregate_cost": true, "unit": "write" }
+			},
+			"configurations": [
+				{ "name": "500 appends", "value": { "writes": 500 } },
+				{ "name": "2000 appends", "value": { "writes": 2000 } },
+				{ "name": "8000 appends", "cpu": 1, "value": { "writes": 8000 } }
+			]
+		}
+	]
+}

package/tests/perf/fragmented-read.ts

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Reads spread across a file with many disjoint cached regions.
+
+import type { FileHandle } from '@zenfs/core/promises';
+import { fs, mount, piece, stride } from './common.ts';
+
+interface Config {
+	/** Cached regions to build, one per scattered write */
+	regions: number;
+	reads: number;
+}
+
+interface State {
+	handle: FileHandle;
+	target: Buffer;
+}
+
+export async function setup(config: Config): Promise<State> {
+	await mount('perf-fragmented-read');
+
+	await fs.promises.writeFile('/f', Buffer.alloc(config.regions * stride));
+	const handle = await fs.promises.open('/f', 'r+');
+
+	const data = Buffer.alloc(piece, 0xcd);
+	for (let i = 0; i < config.regions; i++) await handle.write(data, 0, data.length, i * stride);
+
+	return { handle, target: Buffer.allocUnsafe(piece) };
+}
+
+export async function test(config: Config, state: State) {
+	// Backwards, so a scan that starts at region zero pays its worst case on every read
+	for (let i = 0; i < config.reads; i++)
+		await state.handle.read(state.target, 0, state.target.length, (config.regions - 1 - (i % config.regions)) * stride);
+
+	return { reads: config.reads, bytes: config.reads * piece };
+}
+
+export async function teardown(config: Config, state: State): Promise<void> {
+	await state.handle.close();
+	await fs.promises.rm('/f');
+}

package/tests/perf/fragmented-write.ts

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Writes that each land in their own region, so the region list grows by one per write.
+// Anything that walks the whole list — or re-sorts the dirty ranges — per write shows up as
+// quadratic here.
+import type { FileHandle } from '@zenfs/core/promises';
+import { fs, mount, piece, stride } from './common.ts';
+
+interface Config {
+	writes: number;
+}
+
+interface State {
+	data: Buffer;
+	handle?: FileHandle;
+}
+
+export async function setup(): Promise<State> {
+	await mount('perf-fragmented-write');
+	return { data: Buffer.alloc(piece, 0xcd) };
+}
+
+/** A fresh file each iteration: the point is the cost of building the region list, not of reusing it. */
+export async function before(config: Config, state: State): Promise<void> {
+	await fs.promises.writeFile('/f', Buffer.alloc(config.writes * stride));
+	state.handle = await fs.promises.open('/f', 'r+');
+}
+
+export async function test(config: Config, state: State) {
+	for (let i = 0; i < config.writes; i++) await state.handle!.write(state.data, 0, state.data.length, i * stride);
+
+	return { writes: config.writes, bytes: config.writes * piece };
+}
+
+export async function after(config: Config, state: State): Promise<void> {
+	await state.handle!.close();
+	await fs.promises.rm('/f');
+}

package/tests/perf/stream-read.ts

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Reading through `createReadStream`: the VFS cache lookup, `copyFromCache`, and the stream's own
+// chunking, with the files written outside the timed window.
+import { pipeline } from 'node:stream/promises';
+import { chunks, fs, mount, settle } from './common.ts';
+
+interface Config {
+	size: number;
+	count: number;
+	/** Stream highWaterMark, which is also the read chunk size */
+	hwm: number;
+	prep: 'writeFile' | 'stream';
+}
+
+interface State {
+	buffer: Buffer;
+	parts: Buffer[];
+}
+
+export async function setup(config: Config): Promise<State> {
+	await mount('perf-stream-read');
+	const buffer = Buffer.alloc(config.size, 0xab);
+	return { buffer, parts: chunks(buffer, config.hwm) };
+}
+
+export async function before(config: Config, state: State): Promise<void> {
+	for (let i = 0; i < config.count; i++) {
+		if (config.prep == 'stream') await pipeline(state.parts, fs.createWriteStream(`/w${i}`, { highWaterMark: config.hwm }));
+		else await fs.promises.writeFile(`/w${i}`, state.buffer);
+	}
+	await settle();
+}
+
+export async function test(config: Config) {
+	let bytes = 0;
+
+	for (let i = 0; i < config.count; i++) {
+		for await (const chunk of fs.createReadStream(`/w${i}`, { highWaterMark: config.hwm })) bytes += (chunk as Buffer).length;
+	}
+
+	if (bytes != config.size * config.count) throw new Error(`short read: ${bytes} of ${config.size * config.count}`);
+
+	return { bytes, files: config.count };
+}
+
+export async function after(config: Config): Promise<void> {
+	for (let i = 0; i < config.count; i++) await fs.promises.rm(`/w${i}`);
+}

package/tests/perf/stream-write.ts

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// Writing through `createWriteStream`: how the cache grows as a file is appended to one chunk at a
+// time. A region that reallocates exactly on every append makes this quadratic in the file's size.
+import { pipeline } from 'node:stream/promises';
+import { chunks, fs, mount, settle } from './common.ts';
+
+interface Config {
+	size: number;
+	count: number;
+	hwm: number;
+}
+
+interface State {
+	parts: Buffer[];
+}
+
+export async function setup(config: Config): Promise<State> {
+	await mount('perf-stream-write');
+	return { parts: chunks(Buffer.alloc(config.size, 0xab), config.hwm) };
+}
+
+export async function test(config: Config, state: State) {
+	for (let i = 0; i < config.count; i++) await pipeline(state.parts, fs.createWriteStream(`/w${i}`, { highWaterMark: config.hwm }));
+
+	return { bytes: config.size * config.count, files: config.count };
+}
+
+export async function after(config: Config): Promise<void> {
+	for (let i = 0; i < config.count; i++) await fs.promises.rm(`/w${i}`);
+	await settle();
+}

package/tests/setup.ts

@@ -8,7 +8,7 @@ export const data = join(import.meta.dirname, 'data');
 
 export const tmp = join(import.meta.dirname, 'tmp');
 
-if (!existsSync(tmp)) mkdirSync(tmp);
+if (!existsSync(tmp)) mkdirSync(tmp, { recursive: true });
 
 export async function copyAsync(_path: string, fs: NodeFS = _fs): Promise<void> {
 	const path = relative(data, _path) || '/';

package/types/README.md

@@ -1 +0,0 @@
-This directory contains declaration files. Due to numerous TypeScript shenanigans, placing them into `src` is a really bad idea. Instead, we put them here.

package/types/readable-stream.d.ts

@@ -1,18 +0,0 @@
-/*
-@types/readable-stream has *many* problems:
-https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/71923
-https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/71307
-https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/71083
-https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/66049
-... and many more
-
-This allows us to bypass those problems.
-
-Warning: Do not install @types/readable-stream alongside this package!
-*/
-
-/// <reference types="node" preserve="true" />
-declare module 'readable-stream' {
-	import { finished, Readable, Writable } from 'node:stream';
-	export { finished, Readable, Writable };
-}