@zenfs/core 2.7.4 → 2.7.6

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/internal/rpc.d.ts

@@ -100,15 +100,24 @@ export interface Message {
     method: Method;
     stack: string;
 }
-export interface Request<TMethod extends Method = Method> extends Message {
+export interface RequestInit<TMethod extends Method = Method> {
     method: TMethod;
     args: Parameters<Methods[TMethod]>;
 }
-export interface Response<TMethod extends Method = Method> extends Message {
-    error?: WithOptional<ExceptionJSON, 'code' | 'errno'>;
-    method: TMethod;
-    value: ReturnType<Methods[TMethod]>;
-}
+export type Request<TMethod extends Method = Method> = {
+    [K in Method]: Message & RequestInit<K>;
+}[TMethod];
+export type Response<TMethod extends Method = Method> = {
+    [K in Method]: Message & {
+        error?: WithOptional<ExceptionJSON, 'code' | 'errno'>;
+        method: K;
+        /**
+         * This is undefined if an error occurs, and we check it at runtime.
+         * We don't do the type stuff because Typescript gets confused
+         */
+        value: ReturnType<Methods[K]>;
+    };
+}[TMethod];
 /**
  * Encode a RPC message as a string using JSON.
  * This is only done when structured cloning is not available.
@@ -130,7 +139,7 @@ export interface Executor extends PromiseWithResolvers<any> {
     fs: PortFS;
     timeout: ReturnType<typeof setTimeout>;
 }
-export declare function request<const TRequest extends Request, TValue>(request: Omit<TRequest, 'id' | 'stack' | '_zenfs'>, { port, timeout: ms, fs }: Partial<Options> & {
+export declare function request<const Init extends RequestInit, TValue>(request: Init, { port, timeout: ms, fs }: Partial<Options> & {
     fs: PortFS;
 }): Promise<TValue>;
 export declare function handleResponse<const TMethod extends Method>(response: Response<TMethod>): void;

package/dist/internal/rpc.js

@@ -160,11 +160,6 @@ export function request(request, { port, timeout: ms = 1000, fs }) {
     port.send({ ...request, _zenfs: true, id, stack });
     return promise;
 }
-// Why Typescript, WHY does the type need to be asserted even when the method is explicitly checked?
-function __requestMethod(req) { }
-function __responseMethod(res, ...t) {
-    return t.includes(res.method);
-}
 export function handleResponse(response) {
     if (!isMessage(response))
         return;
@@ -182,7 +177,7 @@ export function handleResponse(response) {
         return;
     }
     disposeExecutors(response.id);
-    resolve(__responseMethod(response, 'stat', 'createFile', 'mkdir') ? new Inode(response.value) : response.value);
+    resolve(['stat', 'createFile', 'mkdir'].includes(response.method) ? new Inode(response.value) : response.value);
     return;
 }
 export function attach(port, handler) {
@@ -214,11 +209,9 @@ export async function handleRequest(port, fs, request) {
     if (!isMessage(request))
         return;
     let value, error;
-    const transferList = [];
     try {
         switch (request.method) {
             case 'read': {
-                __requestMethod(request);
                 const [path, buffer, start, end] = request.args;
                 await fs.read(path, buffer, start, end);
                 value = buffer;
@@ -227,7 +220,6 @@ export async function handleRequest(port, fs, request) {
             case 'stat':
             case 'createFile':
             case 'mkdir': {
-                __requestMethod(request);
                 // @ts-expect-error 2556
                 const md = await fs[request.method](...request.args);
                 const inode = md instanceof Inode ? md : new Inode(md);
@@ -235,7 +227,6 @@ export async function handleRequest(port, fs, request) {
                 break;
             }
             case 'touch': {
-                __requestMethod(request);
                 const [path, metadata] = request.args;
                 await fs.touch(path, new Inode(metadata));
                 value = undefined;
@@ -249,5 +240,5 @@ export async function handleRequest(port, fs, request) {
     catch (e) {
         error = e instanceof Exception ? e.toJSON() : pick(e, 'message', 'stack');
     }
-    port.send({ _zenfs: true, ...pick(request, 'id', 'method', 'stack'), error, value }, transferList);
+    port.send({ _zenfs: true, ...pick(request, 'id', 'method', 'stack'), error, value });
 }

package/dist/mixins/mutexed.d.ts

@@ -1,28 +1,17 @@
+import { RwLockable } from 'kerium/locks';
 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
- * @internal
- */
-export declare class MutexLock {
-    protected readonly previous?: MutexLock | undefined;
-    protected current: PromiseWithResolvers<void>;
-    protected _isLocked: boolean;
-    get isLocked(): boolean;
-    constructor(previous?: MutexLock | undefined);
-    done(): Promise<void>;
-    unlock(): void;
-    [Symbol.dispose](): void;
-}
 /**
  * @hidden
  * @category Internals
+ * @deprecated This is no longer needed and will be removed
+ * @todo [breaking] Remove
  */
-export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
+export declare class _MutexedFS<T extends FileSystem> extends RwLockable implements FileSystem {
     /**
      * @internal
      */
@@ -38,31 +27,6 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     ready(): Promise<void>;
     readySync(): void;
     usage(): UsageInfo;
-    /**
-     * The current locks
-     */
-    private currentLock?;
-    /**
-     * Adds a lock for a path
-     */
-    protected addLock(): MutexLock;
-    /**
-     * Locks `path` asynchronously.
-     * If the path is currently locked, waits for it to be unlocked.
-     * @internal
-     */
-    lock(timeout?: number): Promise<MutexLock>;
-    /**
-     * Locks `path` asynchronously.
-     * If the path is currently locked, an error will be thrown
-     * @internal
-     */
-    lockSync(): MutexLock;
-    /**
-     * Whether `path` is locked
-     * @internal
-     */
-    get isLocked(): boolean;
     rename(oldPath: string, newPath: string): Promise<void>;
     renameSync(oldPath: string, newPath: string): void;
     stat(path: string): Promise<InodeLike>;
@@ -110,9 +74,10 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
  * Instead of extending `FileSystem`,
  * `MutexedFS` implements it in order to make sure all of the methods are passed through
  *
- * @todo Change `using _` to `using void` pending https://github.com/tc39/proposal-discard-binding
  * @category Internals
  * @internal
+ * @deprecated This is no longer needed and will be removed
+ * @todo [breaking] Remove
  */
 export declare function Mutexed<const T extends Concrete<typeof FileSystem>>(FS: T): typeof _MutexedFS<InstanceType<T>> & {
     new (...args: ConstructorParameters<T>): _MutexedFS<InstanceType<T>>;