@zenfs/core 2.6.5 → 2.7.0

package/dist/internal/ioctl.js

@@ -0,0 +1,368 @@
+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 { 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;
+(function (FileFlag) {
+    /** Secure deletion */
+    FileFlag[FileFlag["SecureRm"] = 1] = "SecureRm";
+    /** Undelete */
+    FileFlag[FileFlag["Undelete"] = 2] = "Undelete";
+    /** Compress file */
+    FileFlag[FileFlag["Compress"] = 4] = "Compress";
+    /** Synchronous updates */
+    FileFlag[FileFlag["Sync"] = 8] = "Sync";
+    /** Immutable file */
+    FileFlag[FileFlag["Immutable"] = 16] = "Immutable";
+    /** Writes to file may only append */
+    FileFlag[FileFlag["Append"] = 32] = "Append";
+    /** do not dump file */
+    FileFlag[FileFlag["NoDump"] = 64] = "NoDump";
+    /** do not update atime */
+    FileFlag[FileFlag["NoAtime"] = 128] = "NoAtime";
+    // Reserved for compression usage...
+    FileFlag[FileFlag["Dirty"] = 256] = "Dirty";
+    /** One or more compressed clusters */
+    FileFlag[FileFlag["CompressBlk"] = 512] = "CompressBlk";
+    /** Don't compress */
+    FileFlag[FileFlag["NoCompress"] = 1024] = "NoCompress";
+    // End compression flags --- maybe not all used
+    /** Encrypted file */
+    FileFlag[FileFlag["Encrypt"] = 2048] = "Encrypt";
+    /** btree format dir */
+    FileFlag[FileFlag["Btree"] = 4096] = "Btree";
+    /** hash-indexed directory */
+    // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values
+    FileFlag[FileFlag["Index"] = 4096] = "Index";
+    /** AFS directory */
+    FileFlag[FileFlag["IMagic"] = 8192] = "IMagic";
+    /** Reserved for ext3 */
+    FileFlag[FileFlag["JournalData"] = 16384] = "JournalData";
+    /** file tail should not be merged */
+    FileFlag[FileFlag["NoTail"] = 32768] = "NoTail";
+    /** dirsync behaviour (directories only) */
+    FileFlag[FileFlag["DirSync"] = 65536] = "DirSync";
+    /** Top of directory hierarchies*/
+    FileFlag[FileFlag["TopDir"] = 131072] = "TopDir";
+    /** Reserved for ext4 */
+    FileFlag[FileFlag["HugeFile"] = 262144] = "HugeFile";
+    /** Extents */
+    FileFlag[FileFlag["Extent"] = 524288] = "Extent";
+    /** Verity protected inode */
+    FileFlag[FileFlag["Verity"] = 1048576] = "Verity";
+    /** Inode used for large EA */
+    FileFlag[FileFlag["EaInode"] = 2097152] = "EaInode";
+    /** Reserved for ext4 */
+    FileFlag[FileFlag["EofBlocks"] = 4194304] = "EofBlocks";
+    /** Do not cow file */
+    FileFlag[FileFlag["NoCow"] = 8388608] = "NoCow";
+    /** Inode is DAX */
+    FileFlag[FileFlag["Dax"] = 33554432] = "Dax";
+    /** Reserved for ext4 */
+    FileFlag[FileFlag["InlineData"] = 268435456] = "InlineData";
+    /** Create with parents projid */
+    FileFlag[FileFlag["ProjInherit"] = 536870912] = "ProjInherit";
+    /** Folder is case insensitive */
+    FileFlag[FileFlag["CaseFold"] = 1073741824] = "CaseFold";
+    /** reserved for ext2 lib */
+    FileFlag[FileFlag["Reserved"] = 2147483648] = "Reserved";
+})(FileFlag || (FileFlag = {}));
+/**
+ * `FS_IOC_*` commands for {@link ioctl | `ioctl`}
+ * @remarks
+ * These are computed from a script since constant values are needed for enum member types
+ */
+export var IOC;
+(function (IOC) {
+    IOC[IOC["GetFlags"] = 2148034049] = "GetFlags";
+    IOC[IOC["SetFlags"] = 1074292226] = "SetFlags";
+    IOC[IOC["GetVersion"] = 2148038145] = "GetVersion";
+    IOC[IOC["SetVersion"] = 1074296322] = "SetVersion";
+    IOC[IOC["Fiemap"] = 3223348747] = "Fiemap";
+    IOC[IOC["GetXattr"] = 2149341215] = "GetXattr";
+    IOC[IOC["SetXattr"] = 1075599392] = "SetXattr";
+    IOC[IOC["GetLabel"] = 2164298801] = "GetLabel";
+    IOC[IOC["SetLabel"] = 1090556978] = "SetLabel";
+    IOC[IOC["GetUUID"] = 2148603136] = "GetUUID";
+    IOC[IOC["GetSysfsPath"] = 2155943169] = "GetSysfsPath";
+})(IOC || (IOC = {}));
+/**
+ * `FS_IOC32_*` commands for {@link ioctl | `ioctl`}
+ * @remarks
+ * These are computed from a script since constant values are needed for enum member types
+ */
+export var IOC32;
+(function (IOC32) {
+    IOC32[IOC32["GetFlags"] = 2147771905] = "GetFlags";
+    IOC32[IOC32["SetFlags"] = 1074030082] = "SetFlags";
+    IOC32[IOC32["GetVersion"] = 2147776001] = "GetVersion";
+    IOC32[IOC32["SetVersion"] = 1074034178] = "SetVersion";
+})(IOC32 || (IOC32 = {}));
+/**
+ * @internal
+ * @category ioctl
+ */
+export const ioctl_default_ops = {
+    [IOC.GetFlags]($) {
+        if (typeof $.inode.flags !== 'number')
+            throw withErrno('ENOTTY');
+        return $.inode.flags;
+    },
+    [IOC32.GetFlags]($) {
+        if (typeof $.inode.flags !== 'number')
+            throw withErrno('ENOTTY');
+        return $.inode.flags;
+    },
+    [IOC.GetVersion]($) {
+        if (typeof $.inode.version !== 'number')
+            throw withErrno('ENOTTY');
+        return $.inode.version;
+    },
+    [IOC32.GetVersion]($) {
+        if (typeof $.inode.version !== 'number')
+            throw withErrno('ENOTTY');
+        return $.inode.version;
+    },
+    [IOC.Fiemap]() {
+        throw withErrno('ENOTSUP');
+    },
+    [IOC.GetXattr]($, _name) {
+        return new fsxattr($.inode);
+    },
+    [IOC.SetXattr]($, _name, _value) {
+        throw withErrno('ENOTSUP');
+    },
+    [IOC.GetLabel]($) {
+        return $.fs.label;
+    },
+    [IOC.SetLabel]($, label) {
+        $.fs.label = label;
+    },
+    [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}`;
+    },
+};
+/**
+ * @internal
+ * @category ioctl
+ */
+export const ioctl_default_ops_async = {
+    ...ioctl_default_ops,
+    async [IOC.SetFlags]($, flags) {
+        $.inode.flags = flags;
+        await $.fs.touch($.path, $.inode);
+    },
+    async [IOC32.SetFlags]($, flags) {
+        $.inode.flags = flags;
+        await $.fs.touch($.path, $.inode);
+    },
+    async [IOC.SetVersion]($, version) {
+        $.inode.version = version;
+        await $.fs.touch($.path, $.inode);
+    },
+    async [IOC32.SetVersion]($, version) {
+        $.inode.version = version;
+        await $.fs.touch($.path, $.inode);
+    },
+};
+/**
+ * @internal
+ * @category ioctl
+ */
+export const ioctl_default_ops_sync = {
+    ...ioctl_default_ops,
+    [IOC.SetFlags]($, flags) {
+        $.inode.flags = flags;
+        $.fs.touchSync($.path, $.inode);
+    },
+    [IOC32.SetFlags]($, flags) {
+        $.inode.flags = flags;
+        $.fs.touchSync($.path, $.inode);
+    },
+    [IOC.SetVersion]($, version) {
+        $.inode.version = version;
+        $.fs.touchSync($.path, $.inode);
+    },
+    [IOC32.SetVersion]($, version) {
+        $.inode.version = version;
+        $.fs.touchSync($.path, $.inode);
+    },
+};

package/dist/mixins/async.js

@@ -1,9 +1,10 @@
-import { _asyncFSKeys } from './shared.js';
+// SPDX-License-Identifier: LGPL-3.0-or-later
 import { withErrno } from 'kerium';
 import { crit, debug, err } from 'kerium/log';
 import { StoreFS } from '../backends/store/fs.js';
 import { isDirectory } from '../internal/inode.js';
 import { join } from '../path.js';
+import { _asyncFSKeys } from './shared.js';
 /**
  * Async() implements synchronous methods on an asynchronous file system
  *
@@ -143,6 +144,10 @@ export function Async(FS) {
             this._sync.writeSync(path, buffer, offset);
             this._async(() => this.write(path, buffer, offset));
         }
+        ioctlSync(context, command, ...args) {
+            this.checkSync();
+            return this._sync.ioctlSync(context, command, ...args);
+        }
         streamWrite(path, options) {
             this.checkSync();
             const sync = this._sync.streamWrite(path, options).getWriter();

package/dist/mixins/mutexed.d.ts

@@ -2,6 +2,7 @@ import type { UUID } from 'node:crypto';
 import type { Concrete } from 'utilium';
 import type { CreationOptions, FileSystem, StreamOptions, UsageInfo } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
+import type { IoctlContext } from '../internal/ioctl.js';
 import '../polyfills.js';
 /**
  * @category Internals
@@ -90,6 +91,8 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     writeSync(path: string, buffer: Uint8Array, offset: number): void;
     streamRead(path: string, options: StreamOptions): ReadableStream;
     streamWrite(path: string, options: StreamOptions): WritableStream;
+    ioctl(context: IoctlContext, command: number, ...args: any[]): Promise<any>;
+    ioctlSync(context: IoctlContext, command: number, ...args: any[]): any;
 }
 /**
  * This serializes access to an underlying async filesystem.

package/dist/mixins/mutexed.js

@@ -50,6 +50,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+// SPDX-License-Identifier: LGPL-3.0-or-later
 import { withErrno } from 'kerium';
 import { err } from 'kerium/log';
 import '../polyfills.js';
@@ -170,7 +171,6 @@ export class _MutexedFS {
     get isLocked() {
         return !!this.currentLock?.isLocked;
     }
-    /* eslint-disable @typescript-eslint/no-unused-vars */
     async rename(oldPath, newPath) {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
@@ -563,6 +563,34 @@ export class _MutexedFS {
             __disposeResources(env_28);
         }
     }
+    async ioctl(context, command, ...args) {
+        const env_29 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_29, await this.lock(), false);
+            return await this._fs.ioctl({ ...context, fs: this._fs }, command, ...args);
+        }
+        catch (e_29) {
+            env_29.error = e_29;
+            env_29.hasError = true;
+        }
+        finally {
+            __disposeResources(env_29);
+        }
+    }
+    ioctlSync(context, command, ...args) {
+        const env_30 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_30, this.lockSync(), false);
+            return this._fs.ioctlSync({ ...context, fs: this._fs }, command, ...args);
+        }
+        catch (e_30) {
+            env_30.error = e_30;
+            env_30.hasError = true;
+        }
+        finally {
+            __disposeResources(env_30);
+        }
+    }
 }
 /**
  * This serializes access to an underlying async filesystem.

package/dist/mixins/shared.d.ts

@@ -18,7 +18,7 @@ export type _SyncFSKeys = Exclude<Extract<keyof FileSystem, `${string}Sync`>, '_
 export type _AsyncFSKeys = {
     [K in _SyncFSKeys]: K extends `${infer T}Sync` ? T : never;
 }[_SyncFSKeys];
-export declare const _asyncFSKeys: ["rename", "stat", "touch", "createFile", "unlink", "rmdir", "mkdir", "readdir", "exists", "link", "sync", "read", "write"];
+export declare const _asyncFSKeys: ["rename", "stat", "touch", "createFile", "unlink", "rmdir", "mkdir", "readdir", "exists", "link", "sync", "read", "write", "ioctl"];
 /**
  * Asynchronous `FileSystem` methods. This is a convenience type for all of the async operations.
  * @category Internals

package/dist/mixins/shared.js

@@ -13,4 +13,5 @@ export const _asyncFSKeys = [
     'sync',
     'read',
     'write',
+    'ioctl',
 ];

package/dist/mixins/sync.js

@@ -44,6 +44,9 @@ export function Sync(FS) {
         async write(path, buffer, offset) {
             return this.writeSync(path, buffer, offset);
         }
+        async ioctl(context, command, ...args) {
+            return this.ioctlSync(context, command, ...args);
+        }
     }
     return SyncFS;
 }

package/dist/node/sync.js

@@ -117,7 +117,7 @@ lstatSync;
 export function truncateSync(path, len = 0) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const file = __addDisposableResource(env_1, _sync.open.call(this, path, { flag: 'r+' }), false);
+        const file = __addDisposableResource(env_1, _sync.open(this, path, { flag: 'r+' }), false);
         len ||= 0;
         if (len < 0)
             throw UV('EINVAL', 'truncate', path.toString());
@@ -165,7 +165,7 @@ unlinkSync;
  * @param flag {@link https://nodejs.org/api/fs.html#file-system-flags}
  */
 export function openSync(path, flag, mode = constants.F_OK) {
-    return toFD(_sync.open.call(this, path, { flag, mode }));
+    return toFD(_sync.open(this, path, { flag, mode }));
 }
 openSync;
 /**
@@ -173,7 +173,7 @@ openSync;
  * @internal
  */
 export function lopenSync(path, flag, mode) {
-    return toFD(_sync.open.call(this, path, { flag, mode, preserveSymlinks: true }));
+    return toFD(_sync.open(this, path, { flag, mode, preserveSymlinks: true }));
 }
 export function readFileSync(path, _options = {}) {
     const env_3 = { stack: [], error: void 0, hasError: false };
@@ -184,7 +184,7 @@ export function readFileSync(path, _options = {}) {
             throw UV('EBADF', 'read', path.toString());
         const file = __addDisposableResource(env_3, typeof path == 'number'
             ? fromFD(this, path)
-            : _sync.open.call(this, path.toString(), { flag: options.flag, mode: 0o644, preserveSymlinks: false }), false);
+            : _sync.open(this, path.toString(), { flag: options.flag, mode: 0o644, preserveSymlinks: false }), false);
         const { size } = file.stat();
         const data = Buffer.alloc(size);
         file.readSync(data, 0, size, 0);
@@ -216,7 +216,7 @@ export function writeFileSync(path, data, _options = {}) {
         }
         const file = __addDisposableResource(env_4, typeof path == 'number'
             ? fromFD(this, path)
-            : _sync.open.call(this, path.toString(), {
+            : _sync.open(this, path.toString(), {
                 flag,
                 mode: options.mode,
             }), false);
@@ -250,7 +250,7 @@ export function appendFileSync(filename, data, _options = {}) {
     const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
     const file = typeof filename == 'number'
         ? fromFD(this, filename)
-        : _sync.open.call(this, normalizePath(filename), {
+        : _sync.open(this, normalizePath(filename), {
             flag,
             mode: options.mode,
         });
@@ -416,7 +416,7 @@ export function symlinkSync(target, path, type = 'file') {
         if (!['file', 'dir', 'junction'].includes(type))
             throw new TypeError('Invalid symlink type: ' + type);
         path = normalizePath(path);
-        const file = __addDisposableResource(env_6, _sync.open.call(this, path, { flag: 'wx', mode: 0o644 }), false);
+        const file = __addDisposableResource(env_6, _sync.open(this, path, { flag: 'wx', mode: 0o644 }), false);
         file.writeSync(encodeUTF8(normalizePath(target, true)));
         file.chmodSync(constants.S_IFLNK);
     }
@@ -442,7 +442,7 @@ readlinkSync;
 export function chownSync(path, uid, gid) {
     const env_7 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_7, _sync.open.call(this, path, { flag: 'r+', mode: constants.F_OK }), false);
+        const handle = __addDisposableResource(env_7, _sync.open(this, path, { flag: 'r+', mode: constants.F_OK }), false);
         handle.chownSync(uid, gid);
     }
     catch (e_7) {

package/dist/vfs/async.js

@@ -131,7 +131,7 @@ export async function open($, path, opt) {
                 throw UV('EACCES', 'open', dirname(path));
             if (!isDirectory(parentStats))
                 throw UV('ENOTDIR', 'open', dirname(path));
-            if (!opt.allowDirectory && mode & constants.S_IFDIR)
+            if (!opt.allowDirectory && isDirectory({ mode }))
                 throw UV('EISDIR', 'open', path);
             // Serialize entry creation with other operations on the parent directory
             const _ = __addDisposableResource(env_1, await lockPath(fs, parentPath, 'rw', parentStats), false);
@@ -161,7 +161,7 @@ export async function open($, path, opt) {
         throw UV('EACCES', $ex);
     if (flag & constants.O_EXCL)
         throw UV('EEXIST', $ex);
-    if (!opt.allowDirectory && mode & constants.S_IFDIR)
+    if (!opt.allowDirectory && isDirectory({ mode }))
         throw UV('EISDIR', 'open', path);
     const handle = new Handle($, path, resolved, flag, cacheOf(fs).ref(resolved, stats));
     if (flag & constants.O_TRUNC)

package/dist/vfs/file.js

@@ -675,7 +675,8 @@ export { Handle };
  */
 export function toFD(file) {
     const map = contextOf(file.context).descriptors;
-    const fd = Math.max(map.size ? Math.max(...map.keys()) + 1 : 0, 4);
+    // @todo use `Iterator` helper #296
+    const fd = Array.from(map.keys()).reduce((next, k) => Math.max(next, k + 1), 4);
     map.set(fd, file);
     return fd;
 }