@zenfs/core 1.11.4 → 2.0.0

package/dist/utils.js

@@ -1,56 +1,6 @@
+import { decodeUTF8, encodeUTF8 } from 'utilium';
 import { Errno, ErrnoError } from './internal/error.js';
-import { log_deprecated } from './internal/log.js';
-import { resolve } from './vfs/path.js';
-/**
- * Encodes a string into a buffer
- * @internal
- */
-export function encodeRaw(input) {
-    if (typeof input != 'string') {
-        throw new ErrnoError(Errno.EINVAL, 'Can not encode a non-string');
-    }
-    return new Uint8Array(Array.from(input).map(char => char.charCodeAt(0)));
-}
-/**
- * Decodes a string from a buffer
- * @internal
- */
-export function decodeRaw(input) {
-    if (!(input instanceof Uint8Array)) {
-        throw new ErrnoError(Errno.EINVAL, 'Can not decode a non-Uint8Array');
-    }
-    return Array.from(input)
-        .map(char => String.fromCharCode(char))
-        .join('');
-}
-const encoder = new TextEncoder();
-/**
- * Encodes a string into a buffer
- * @internal
- */
-export function encodeUTF8(input) {
-    if (typeof input != 'string') {
-        throw new ErrnoError(Errno.EINVAL, 'Can not encode a non-string');
-    }
-    return encoder.encode(input);
-}
-/* node:coverage disable */
-export { /** @deprecated @hidden */ encodeUTF8 as encode };
-/* node:coverage enable */
-const decoder = new TextDecoder();
-/**
- * Decodes a string from a buffer
- * @internal
- */
-export function decodeUTF8(input) {
-    if (!(input instanceof Uint8Array)) {
-        throw new ErrnoError(Errno.EINVAL, 'Can not decode a non-Uint8Array');
-    }
-    return decoder.decode(input);
-}
-/* node:coverage disable */
-export { /** @deprecated @hidden */ decodeUTF8 as decode };
-/* node:coverage enable */
+import { resolve } from './path.js';
 /**
  * Decodes a directory listing
  * @hidden
@@ -117,6 +67,7 @@ export function normalizePath(p, noResolve = false) {
         throw new ErrnoError(Errno.EINVAL, 'Path can not be empty');
     }
     p = p.replaceAll(/[/\\]+/g, '/');
+    // Note: PWD is not resolved here, it is resolved later.
     return noResolve ? p : resolve(p);
 }
 /**
@@ -141,26 +92,10 @@ export function normalizeOptions(options, encoding = 'utf8', flag, mode = 0) {
         mode: normalizeMode('mode' in options ? options === null || options === void 0 ? void 0 : options.mode : null, mode),
     };
 }
-/* node:coverage disable */
-import { randomHex } from 'utilium';
-/**
- * Generate a random ino
- * @internal @deprecated @hidden
- */
-export function randomBigInt() {
-    log_deprecated('randomBigInt');
-    return BigInt('0x' + randomHex(8));
+export function stringifyUUID(uuid) {
+    const hex = uuid.toString(16).padStart(32, '0');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
-/**
- * Prevents infinite loops
- * @internal
- * @deprecated Use `canary` from Utilium
- */
-export function canary(path, syscall) {
-    log_deprecated('canary');
-    const timeout = setTimeout(() => {
-        throw ErrnoError.With('EDEADLK', path, syscall);
-    }, 5000);
-    return () => clearTimeout(timeout);
+export function parseUUID(uuid) {
+    return BigInt(`0x${uuid.replace(/-/g, '')}`);
 }
-/* node:coverage enable */

package/dist/vfs/acl.d.ts

@@ -0,0 +1,42 @@
+import { type V_Context } from '../internal/contexts.js';
+import { type InodeLike } from '../internal/inode.js';
+export declare const enum Type {
+    Access = 32768,
+    Default = 16384
+}
+export declare const enum Tag {
+    UserObj = 1,
+    User = 2,
+    GroupObj = 4,
+    Group = 8,
+    Mask = 16,
+    Other = 32,
+    /**
+     * @internal @hidden
+     */
+    _None = 0
+}
+export declare class Entry {
+    tag: Tag;
+    perm: number;
+    id: number;
+    constructor(data?: Partial<Entry> | Uint8Array);
+}
+export declare class ACL {
+    version: number;
+    entries: Entry[];
+    constructor(data?: Uint8Array | Entry[]);
+}
+export declare function fromMode(mode: number): ACL;
+export declare function toMode(acl: ACL): number;
+export declare function get($: V_Context, path: string): Promise<ACL>;
+export declare function getSync($: V_Context, path: string): ACL;
+export declare function set($: V_Context, path: string, acl: ACL): Promise<void>;
+export declare function setSync($: V_Context, path: string, acl: ACL): void;
+export declare let shouldCheck: boolean;
+export declare function setChecks(enabled: boolean): void;
+/**
+ * Checks if a given user/group has access to this item
+ * @param access The requested access, combination of `W_OK`, `R_OK`, and `X_OK`
+ */
+export declare function check($: V_Context, inode: InodeLike, access: number): boolean;

package/dist/vfs/acl.js

@@ -0,0 +1,249 @@
+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;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+/*
+    Access Control Lists.
+    At the moment, they are only intended for internal use.
+    They also are not checked for permissions yet.
+    Please use a namespace import for the best experience.
+*/
+import { assignWithDefaults, deserialize, serialize, sizeof, struct, types as t } from 'utilium';
+import { defaultContext } from '../internal/contexts.js';
+import { Errno, ErrnoError } from '../internal/error.js';
+import { Attributes } from '../internal/inode.js';
+import { err } from '../internal/log.js';
+import { S_IRWXG, S_IRWXO, S_IRWXU, W_OK, X_OK, R_OK } from './constants.js';
+import * as xattr from './xattr.js';
+const version = 2;
+export var Type;
+(function (Type) {
+    Type[Type["Access"] = 32768] = "Access";
+    Type[Type["Default"] = 16384] = "Default";
+})(Type || (Type = {}));
+export var Tag;
+(function (Tag) {
+    Tag[Tag["UserObj"] = 1] = "UserObj";
+    Tag[Tag["User"] = 2] = "User";
+    Tag[Tag["GroupObj"] = 4] = "GroupObj";
+    Tag[Tag["Group"] = 8] = "Group";
+    Tag[Tag["Mask"] = 16] = "Mask";
+    Tag[Tag["Other"] = 32] = "Other";
+    /**
+     * @internal @hidden
+     */
+    Tag[Tag["_None"] = 0] = "_None";
+})(Tag || (Tag = {}));
+let Entry = (() => {
+    var _a, _b, _c;
+    let _classDecorators = [struct()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _tag_decorators;
+    let _tag_initializers = [];
+    let _tag_extraInitializers = [];
+    let _perm_decorators;
+    let _perm_initializers = [];
+    let _perm_extraInitializers = [];
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    var Entry = _classThis = class {
+        constructor(data) {
+            this.tag = __runInitializers(this, _tag_initializers, 0);
+            this.perm = (__runInitializers(this, _tag_extraInitializers), __runInitializers(this, _perm_initializers, 0));
+            this.id = (__runInitializers(this, _perm_extraInitializers), __runInitializers(this, _id_initializers, 0));
+            __runInitializers(this, _id_extraInitializers);
+            if (data instanceof Uint8Array)
+                deserialize(this, data);
+            else if (typeof data == 'object')
+                assignWithDefaults(this, data);
+        }
+    };
+    __setFunctionName(_classThis, "Entry");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _tag_decorators = [(_a = t).uint16.bind(_a)];
+        _perm_decorators = [(_b = t).uint16.bind(_b)];
+        _id_decorators = [(_c = t).uint32.bind(_c)];
+        __esDecorate(null, null, _tag_decorators, { kind: "field", name: "tag", static: false, private: false, access: { has: obj => "tag" in obj, get: obj => obj.tag, set: (obj, value) => { obj.tag = value; } }, metadata: _metadata }, _tag_initializers, _tag_extraInitializers);
+        __esDecorate(null, null, _perm_decorators, { kind: "field", name: "perm", static: false, private: false, access: { has: obj => "perm" in obj, get: obj => obj.perm, set: (obj, value) => { obj.perm = value; } }, metadata: _metadata }, _perm_initializers, _perm_extraInitializers);
+        __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        Entry = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return Entry = _classThis;
+})();
+export { Entry };
+let ACL = (() => {
+    var _a;
+    let _classDecorators = [struct()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _version_decorators;
+    let _version_initializers = [];
+    let _version_extraInitializers = [];
+    var ACL = _classThis = class {
+        constructor(data) {
+            this.version = __runInitializers(this, _version_initializers, version);
+            this.entries = (__runInitializers(this, _version_extraInitializers), []);
+            if (!data)
+                return;
+            if (!(data instanceof Uint8Array)) {
+                this.entries.push(...data);
+                return;
+            }
+            deserialize(this, data);
+            if (this.version != version)
+                throw err(new ErrnoError(Errno.EINVAL, 'Invalid ACL version'));
+            for (let offset = sizeof(ACL); offset < data.length; offset += sizeof(Entry)) {
+                if (offset + sizeof(Entry) > data.length)
+                    throw err(new ErrnoError(Errno.EIO, 'Invalid ACL data'));
+                const slice = data.subarray(offset, offset + sizeof(Entry));
+                this.entries.push(new Entry(slice));
+            }
+        }
+    };
+    __setFunctionName(_classThis, "ACL");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _version_decorators = [(_a = t).uint32.bind(_a)];
+        __esDecorate(null, null, _version_decorators, { kind: "field", name: "version", static: false, private: false, access: { has: obj => "version" in obj, get: obj => obj.version, set: (obj, value) => { obj.version = value; } }, metadata: _metadata }, _version_initializers, _version_extraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        ACL = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return ACL = _classThis;
+})();
+export { ACL };
+export function fromMode(mode) {
+    return new ACL([
+        new Entry({ tag: Tag.UserObj, perm: (mode & S_IRWXU) >> 6 }),
+        new Entry({ tag: Tag.GroupObj, perm: (mode & S_IRWXG) >> 3 }),
+        new Entry({ tag: Tag.Other, perm: mode & S_IRWXO }),
+    ]);
+}
+export function toMode(acl) {
+    let mode = 0;
+    for (const entry of acl.entries) {
+        switch (entry.tag) {
+            case Tag.UserObj:
+                mode |= entry.perm << 6;
+                break;
+            case Tag.GroupObj:
+                mode |= entry.perm << 3;
+                break;
+            case Tag.Other:
+                mode |= entry.perm;
+                break;
+            case Tag.User:
+            case Tag.Group:
+            case Tag.Mask:
+            case Tag._None:
+                continue;
+        }
+    }
+    return mode;
+}
+export async function get($, path) {
+    return new ACL(await xattr.get.call($, path, 'system.posix_acl_access'));
+}
+export function getSync($, path) {
+    return new ACL(xattr.getSync.call($, path, 'system.posix_acl_access'));
+}
+export async function set($, path, acl) {
+    await xattr.set.call($, path, 'system.posix_acl_access', serialize(acl));
+}
+export function setSync($, path, acl) {
+    xattr.setSync.call($, path, 'system.posix_acl_access', serialize(acl));
+}
+export let shouldCheck = true;
+export function setChecks(enabled) {
+    shouldCheck = enabled;
+}
+/**
+ * Checks if a given user/group has access to this item
+ * @param access The requested access, combination of `W_OK`, `R_OK`, and `X_OK`
+ */
+export function check($, inode, access) {
+    var _a, _b;
+    if (!shouldCheck)
+        return true;
+    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    const { euid, egid } = (_b = $ === null || $ === void 0 ? void 0 : $.credentials) !== null && _b !== void 0 ? _b : defaultContext.credentials;
+    const attr = inode.attributes.get('system.posix_acl_access');
+    if (!attr)
+        return true;
+    const acl = new ACL(attr.value);
+    let mask = R_OK | W_OK | X_OK;
+    let result = false;
+    for (const entry of acl.entries) {
+        switch (entry.tag) {
+            case Tag.UserObj:
+                if (inode.uid == euid && (entry.perm & access) === access)
+                    result = true;
+                break;
+            case Tag.User:
+                if (entry.id == euid && (entry.perm & mask & access) === access)
+                    result = true;
+                break;
+            case Tag.GroupObj:
+                if (inode.gid == egid && (entry.perm & mask & access) === access)
+                    result = true;
+                break;
+            case Tag.Group:
+                if (entry.id == egid && (entry.perm & mask & access) === access)
+                    result = true;
+                break;
+            case Tag.Mask:
+                mask = entry.perm;
+                break;
+            case Tag.Other:
+                if ((entry.perm & mask & access) === access)
+                    result = true;
+                break;
+            case Tag._None:
+                continue;
+        }
+    }
+    return result;
+}

package/dist/vfs/async.d.ts

@@ -1,12 +1,12 @@
 import type * as fs from 'node:fs';
 import type { V_Context } from '../context.js';
-import type { Stats } from '../stats.js';
 import type { Callback } from '../utils.js';
 import type { Dir, Dirent } from './dir.js';
+import type { Stats } from './stats.js';
 import type { FileContents } from './types.js';
 import { Buffer } from 'buffer';
 import { ErrnoError } from '../internal/error.js';
-import { BigIntStats } from '../stats.js';
+import { BigIntStats } from './stats.js';
 import { ReadStream, WriteStream, type ReadStreamOptions, type WriteStreamOptions } from './streams.js';
 import { FSWatcher } from './watchers.js';
 /**
@@ -16,7 +16,7 @@ export declare function rename(this: V_Context, oldPath: fs.PathLike, newPath: f
 /**
  * Test whether or not `path` exists by checking with the file system.
  * Then call the callback argument with either true or false.
- * @deprecated Use {@link stat} or {@link access} instead.
+ * According to Node.js: deprecated Use {@link stat} or {@link access} instead.
  */
 export declare function exists(this: V_Context, path: fs.PathLike, cb?: (exists: boolean) => unknown): void;
 export declare function stat(this: V_Context, path: fs.PathLike, callback: Callback<[Stats]>): void;
@@ -48,25 +48,11 @@ export declare function unlink(this: V_Context, path: fs.PathLike, cb?: Callback
  * Exclusive mode ensures that path is newly created.
  * Mode defaults to `0644`
  *
- * `flags` can be:
- *
- * * `'r'` - Open file for reading. An exception occurs if the file does not exist.
- * * `'r+'` - Open file for reading and writing. An exception occurs if the file does not exist.
- * * `'rs'` - Open file for reading in synchronous mode. Instructs the filesystem to not cache writes.
- * * `'rs+'` - Open file for reading and writing, and opens the file in synchronous mode.
- * * `'w'` - Open file for writing. The file is created (if it does not exist) or truncated (if it exists).
- * * `'wx'` - Like 'w' but opens the file in exclusive mode.
- * * `'w+'` - Open file for reading and writing. The file is created (if it does not exist) or truncated (if it exists).
- * * `'wx+'` - Like 'w+' but opens the file in exclusive mode.
- * * `'a'` - Open file for appending. The file is created if it does not exist.
- * * `'ax'` - Like 'a' but opens the file in exclusive mode.
- * * `'a+'` - Open file for reading and appending. The file is created if it does not exist.
- * * `'ax+'` - Like 'a+' but opens the file in exclusive mode.
- *
- * @see http://www.manpagez.com/man/2/open/
+ * @see https://nodejs.org/api/fs.html#fsopenpath-flags-mode-callback
+ * @param flags {@link https://nodejs.org/api/fs.html#file-system-flags}
  */
-export declare function open(this: V_Context, path: fs.PathLike, flag: string, cb?: Callback<[number]>): void;
-export declare function open(this: V_Context, path: fs.PathLike, flag: string, mode: number | string, cb?: Callback<[number]>): void;
+export declare function open(this: V_Context, path: fs.PathLike, flag: fs.OpenMode, cb?: Callback<[number]>): void;
+export declare function open(this: V_Context, path: fs.PathLike, flag: fs.OpenMode, mode: number | string, cb?: Callback<[number]>): void;
 /**
  * Asynchronously reads the entire contents of a file.
  * @option encoding The string encoding for the file contents. Defaults to `null`.

package/dist/vfs/async.js

@@ -1,10 +1,9 @@
 import { Buffer } from 'buffer';
 import { Errno, ErrnoError } from '../internal/error.js';
-import { BigIntStats } from '../stats.js';
 import { normalizeMode, normalizePath } from '../utils.js';
 import { R_OK } from './constants.js';
 import * as promises from './promises.js';
-import { fd2file, fdMap } from './shared.js';
+import { BigIntStats } from './stats.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher, StatWatcher } from './watchers.js';
 const nop = () => { };
@@ -31,7 +30,7 @@ rename;
 /**
  * Test whether or not `path` exists by checking with the file system.
  * Then call the callback argument with either true or false.
- * @deprecated Use {@link stat} or {@link access} instead.
+ * According to Node.js: deprecated Use {@link stat} or {@link access} instead.
  */
 export function exists(path, cb = nop) {
     promises.exists
@@ -108,22 +107,23 @@ export function appendFile(filename, data, cbEncOpts, cb = nop) {
 appendFile;
 export function fstat(fd, options, cb = nop) {
     cb = typeof options == 'function' ? options : cb;
-    fd2file(fd)
+    new promises.FileHandle(this, fd)
         .stat()
         .then(stats => cb(undefined, typeof options == 'object' && (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : stats))
         .catch(cb);
 }
 fstat;
 export function close(fd, cb = nop) {
-    const close = fd2file(fd).close();
-    fdMap.delete(fd);
-    close.then(() => cb()).catch(cb);
+    new promises.FileHandle(this, fd)
+        .close()
+        .then(() => cb())
+        .catch(cb);
 }
 close;
 export function ftruncate(fd, lenOrCB, cb = nop) {
     const length = typeof lenOrCB === 'number' ? lenOrCB : 0;
     cb = typeof lenOrCB === 'function' ? lenOrCB : cb;
-    const file = fd2file(fd);
+    const file = new promises.FileHandle(this, fd);
     if (length < 0) {
         throw new ErrnoError(Errno.EINVAL);
     }
@@ -133,14 +133,14 @@ export function ftruncate(fd, lenOrCB, cb = nop) {
 }
 ftruncate;
 export function fsync(fd, cb = nop) {
-    fd2file(fd)
+    new promises.FileHandle(this, fd)
         .sync()
         .then(() => cb())
         .catch(cb);
 }
 fsync;
 export function fdatasync(fd, cb = nop) {
-    fd2file(fd)
+    new promises.FileHandle(this, fd)
         .datasync()
         .then(() => cb())
         .catch(cb);
@@ -148,7 +148,7 @@ export function fdatasync(fd, cb = nop) {
 fdatasync;
 export function write(fd, data, cbPosOff, cbLenEnc, cbPosEnc, cb = nop) {
     let buffer, offset, length, position, encoding;
-    const handle = new promises.FileHandle(fd, this);
+    const handle = new promises.FileHandle(this, fd);
     if (typeof data === 'string') {
         // Signature 1: (fd, string, [position?, [encoding?]], cb?)
         encoding = 'utf8';
@@ -202,21 +202,21 @@ write;
  * @param cb The number is the number of bytes read
  */
 export function read(fd, buffer, offset, length, position, cb = nop) {
-    new promises.FileHandle(fd, this)
+    new promises.FileHandle(this, fd)
         .read(buffer, offset, length, position)
         .then(({ bytesRead, buffer }) => cb(undefined, bytesRead, buffer))
         .catch(cb);
 }
 read;
 export function fchown(fd, uid, gid, cb = nop) {
-    new promises.FileHandle(fd, this)
+    new promises.FileHandle(this, fd)
         .chown(uid, gid)
         .then(() => cb())
         .catch(cb);
 }
 fchown;
 export function fchmod(fd, mode, cb) {
-    new promises.FileHandle(fd, this)
+    new promises.FileHandle(this, fd)
         .chmod(mode)
         .then(() => cb())
         .catch(cb);
@@ -226,7 +226,7 @@ fchmod;
  * Change the file timestamps of a file referenced by the supplied file descriptor.
  */
 export function futimes(fd, atime, mtime, cb = nop) {
-    new promises.FileHandle(fd, this)
+    new promises.FileHandle(this, fd)
         .utimes(atime, mtime)
         .then(() => cb())
         .catch(cb);
@@ -350,7 +350,7 @@ export function access(path, cbMode, cb = nop) {
 access;
 const statWatchers = new Map();
 export function watchFile(path, options, listener) {
-    const normalizedPath = normalizePath(path.toString());
+    const normalizedPath = normalizePath(path);
     const opts = typeof options != 'function' ? options : {};
     if (typeof options == 'function') {
         listener = options;
@@ -388,7 +388,7 @@ watchFile;
  * @param listener Optional listener to remove.
  */
 export function unwatchFile(path, listener = nop) {
-    const normalizedPath = normalizePath(path.toString());
+    const normalizedPath = normalizePath(path);
     const entry = statWatchers.get(normalizedPath);
     if (entry) {
         if (listener && listener !== nop) {
@@ -465,7 +465,7 @@ export function copyFile(src, dest, flags, callback = nop) {
 copyFile;
 export function readv(fd, buffers, position, cb = nop) {
     cb = typeof position === 'function' ? position : cb;
-    new promises.FileHandle(fd, this)
+    new promises.FileHandle(this, fd)
         .readv(buffers, typeof position === 'function' ? undefined : position)
         .then(({ buffers, bytesRead }) => cb(undefined, bytesRead, buffers))
         .catch(cb);
@@ -473,7 +473,7 @@ export function readv(fd, buffers, position, cb = nop) {
 readv;
 export function writev(fd, buffers, position, cb = nop) {
     cb = typeof position === 'function' ? position : cb;
-    new promises.FileHandle(fd, this)
+    new promises.FileHandle(this, fd)
         .writev(buffers, typeof position === 'function' ? undefined : position)
         .then(({ buffers, bytesWritten }) => cb(undefined, bytesWritten, buffers))
         .catch(cb);

package/dist/vfs/config.d.ts

@@ -1,18 +1,6 @@
-export declare const config: {
-    /**
-     * Whether to perform access checks
-     */
-    checkAccess: boolean;
-    /**
-     * Whether to mark a file as dirty after updating its `atime` when read from
-     */
-    updateOnRead: boolean;
-    /**
-     * Whether to immediately sync when files are changed
-     */
-    syncImmediately: boolean;
-    /**
-     * If a file's buffer is not large enough to store content when writing and the buffer can't be resized, reuse the buffer passed to write()
-     */
-    unsafeBufferReplace: boolean;
-};
+/** Whether to perform access checks */
+export declare let checkAccess: boolean;
+/**
+ * @internal @hidden
+ */
+export declare function _setAccessChecks(value: boolean): void;

package/dist/vfs/config.js

@@ -1,18 +1,8 @@
-export const config = {
-    /**
-     * Whether to perform access checks
-     */
-    checkAccess: true,
-    /**
-     * Whether to mark a file as dirty after updating its `atime` when read from
-     */
-    updateOnRead: true,
-    /**
-     * Whether to immediately sync when files are changed
-     */
-    syncImmediately: true,
-    /**
-     * If a file's buffer is not large enough to store content when writing and the buffer can't be resized, reuse the buffer passed to write()
-     */
-    unsafeBufferReplace: false,
-};
+/** Whether to perform access checks */
+export let checkAccess = true;
+/**
+ * @internal @hidden
+ */
+export function _setAccessChecks(value) {
+    checkAccess = value;
+}

package/dist/vfs/dir.d.ts

@@ -1,12 +1,12 @@
 import type { Dir as _Dir, Dirent as _Dirent } from 'node:fs';
 import type { V_Context } from '../context.js';
-import type { Stats } from '../stats.js';
+import { type InodeLike } from '../internal/inode.js';
 import type { Callback } from '../utils.js';
 export declare class Dirent implements _Dirent {
     path: string;
-    protected stats: Stats;
+    protected stats: InodeLike;
     get name(): string;
-    constructor(path: string, stats: Stats);
+    constructor(path: string, stats: InodeLike);
     get parentPath(): string;
     isFile(): boolean;
     isDirectory(): boolean;