@zenfs/core 2.4.1 → 2.4.3

package/dist/{vfs → node}/promises.js

@@ -51,92 +51,41 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { Buffer } from 'buffer';
-import { Exception, rethrow, setUVMessage, UV } from 'kerium';
-import { defaultContext } from '../internal/contexts.js';
-import { hasAccess, InodeFlags, isBlockDevice, isCharacterDevice, isDirectory, isSymbolicLink } from '../internal/inode.js';
-import { basename, dirname, join, matchesGlob, parse, resolve } from '../path.js';
+import { Exception, rethrow, UV } from 'kerium';
+import { encodeUTF8 } from 'utilium';
+import * as constants from '../constants.js';
+import { hasAccess, InodeFlags, isDirectory } from '../internal/inode.js';
+import { join, matchesGlob, parse } from '../path.js';
 import '../polyfills.js';
-import { createInterface } from '../readline.js';
-import { __assertType, _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
-import { checkAccess } from './config.js';
-import * as constants from './constants.js';
+import { _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import * as _async from '../vfs/async.js';
+import { checkAccess } from '../vfs/config.js';
+import { deleteFD, fromFD, toFD } from '../vfs/file.js';
+import * as flags from '../vfs/flags.js';
+import { _statfs, resolveMount } from '../vfs/shared.js';
+import { emitChange, FSWatcher } from '../vfs/watchers.js';
 import { Dir, Dirent } from './dir.js';
-import { deleteFD, fromFD, SyncHandle, toFD } from './file.js';
-import * as flags from './flags.js';
-import { _statfs, resolveMount } from './shared.js';
-import { _chown, BigIntStats, Stats } from './stats.js';
+import { createInterface } from './readline.js';
+import { BigIntStats, Stats } from './stats.js';
 import { ReadStream, WriteStream } from './streams.js';
-import { emitChange, FSWatcher } from './watchers.js';
-export * as constants from './constants.js';
+export * as constants from '../constants.js';
 export class FileHandle {
     context;
     fd;
-    _buffer;
-    /**
-     * Get the current file position.
-     *
-     * We emulate the following bug mentioned in the Node documentation:
-     *
-     * On Linux, positional writes don't work when the file is opened in append mode.
-     * The kernel ignores the position argument and always appends the data to the end of the file.
-     * @returns The current file position.
-     */
-    get position() {
-        return this._sync.position;
-    }
-    set position(value) {
-        this._sync.position = value;
-    }
-    /**
-     * Whether the file has changes which have not been written to the FS
-     */
-    dirty = false;
-    /**
-     * Whether the file is open or closed
-     */
-    closed = false;
-    /** The path relative to the context's root */
-    get path() {
-        return this._sync.path;
-    }
-    /** The internal FS associated with the handle */
-    get fs() {
-        return this._sync.fs;
-    }
-    /** The path relative to the `FileSystem`'s root */
-    get internalPath() {
-        return this._sync.internalPath;
-    }
-    /** The flag the handle was opened with */
-    get flag() {
-        return this._sync.flag;
-    }
-    /** Stats for the handle */
-    get inode() {
-        return this._sync.inode;
-    }
-    _sync;
+    vfs;
     constructor(context, fd) {
         this.context = context;
         this.fd = fd;
-        this._sync = fromFD(context, fd);
-    }
-    get _isSync() {
-        return !!(this.flag & constants.O_SYNC || this.inode.flags & InodeFlags.Sync);
+        this.vfs = fromFD(context, fd);
     }
     _emitChange() {
-        emitChange(this.context, 'change', this.path);
+        emitChange(this.context, 'change', this.vfs.path);
     }
     /**
      * Asynchronous fchown(2) - Change ownership of a file.
      */
     async chown(uid, gid) {
-        if (this.closed)
-            throw UV('EBADF', 'chown', this.path);
-        this.dirty = true;
-        _chown(this.inode, uid, gid);
-        if (this._isSync)
-            await this.sync();
+        await this.vfs.chown(uid, gid);
         this._emitChange();
     }
     /**
@@ -146,13 +95,8 @@ export class FileHandle {
     async chmod(mode) {
         const numMode = normalizeMode(mode, -1);
         if (numMode < 0)
-            throw UV('EINVAL', 'chmod', this.path);
-        if (this.closed)
-            throw UV('EBADF', 'chmod', this.path);
-        this.dirty = true;
-        this.inode.mode = (this.inode.mode & (numMode > constants.S_IFMT ? ~constants.S_IFMT : constants.S_IFMT)) | numMode;
-        if (this._isSync || numMode > constants.S_IFMT)
-            await this.sync();
+            throw UV('EINVAL', 'chmod', this.vfs.path);
+        await this.vfs.chmod(numMode);
         this._emitChange();
     }
     /**
@@ -165,36 +109,14 @@ export class FileHandle {
      * Asynchronous fsync(2) - synchronize a file's in-core state with the underlying storage device.
      */
     async sync() {
-        if (this.closed)
-            throw UV('EBADF', 'sync', this.path);
-        if (!this.dirty)
-            return;
-        if (!this.fs.attributes.has('no_write'))
-            await this.fs.touch(this.internalPath, this.inode);
-        this.dirty = false;
+        await this.vfs.sync();
     }
     /**
      * Asynchronous ftruncate(2) - Truncate a file to a specified length.
      * @param length If not specified, defaults to `0`.
      */
     async truncate(length = 0) {
-        if (this.closed)
-            throw UV('EBADF', 'truncate', this.path);
-        if (length < 0)
-            throw UV('EINVAL', 'truncate', this.path);
-        if (!(this.flag & constants.O_WRONLY || this.flag & constants.O_RDWR))
-            throw UV('EBADF', 'truncate', this.path);
-        if (this.fs.attributes.has('readonly'))
-            throw UV('EROFS', 'truncate', this.path);
-        if (this.inode.flags & InodeFlags.Immutable)
-            throw UV('EPERM', 'truncate', this.path);
-        this.dirty = true;
-        if (!(this.flag & constants.O_WRONLY || this.flag & constants.O_RDWR))
-            throw UV('EBADF', 'truncate', this.path);
-        this.inode.mtimeMs = Date.now();
-        this.inode.size = length;
-        if (this._isSync)
-            await this.sync();
+        await this.vfs.truncate(length);
         this._emitChange();
     }
     /**
@@ -203,13 +125,9 @@ export class FileHandle {
      * @param mtime The last modified time. If a string is provided, it will be coerced to number.
      */
     async utimes(atime, mtime) {
-        if (this.closed)
-            throw UV('EBADF', 'utimes', this.path);
-        this.dirty = true;
-        this.inode.atimeMs = normalizeTime(atime);
-        this.inode.mtimeMs = normalizeTime(mtime);
-        if (this._isSync)
-            await this.sync();
+        atime = normalizeTime(atime);
+        mtime = normalizeTime(mtime);
+        await this.vfs.utimes(atime, mtime);
         this._emitChange();
     }
     /**
@@ -225,39 +143,11 @@ export class FileHandle {
         const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
         const flag = flags.parse(options.flag);
         if (!(flag & constants.O_APPEND))
-            throw UV('EBADF', 'write', this.path);
+            throw UV('EBADF', 'write', this.vfs.path);
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
-        await this._write(encodedData, 0, encodedData.length);
+        await this.vfs.write(encodedData, 0, encodedData.length);
         this._emitChange();
     }
-    /**
-     * Read data from the file.
-     * @param buffer The buffer that the data will be written to.
-     * @param offset The offset within the buffer where writing will start.
-     * @param length An integer specifying the number of bytes to read.
-     * @param position An integer specifying where to begin reading from in the file.
-     * If position is unset, data will be read from the current file position.
-     */
-    async _read(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
-        if (this.closed)
-            throw UV('EBADF', 'read', this.path);
-        if (this.flag & constants.O_WRONLY)
-            throw UV('EBADF', 'read', this.path);
-        if (!(this.inode.flags & InodeFlags.NoAtime) && !this.fs.attributes.has('no_atime')) {
-            this.dirty = true;
-            this.inode.atimeMs = Date.now();
-        }
-        let end = position + length;
-        if (!isCharacterDevice(this.inode) && !isBlockDevice(this.inode) && end > this.inode.size) {
-            end = position + Math.max(this.inode.size - position, 0);
-        }
-        this._sync.position = end;
-        const uint8 = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        await this.fs.read(this.internalPath, uint8.subarray(offset, offset + length), position, end);
-        if (this._isSync)
-            await this.sync();
-        return { bytesRead: end - position, buffer };
-    }
     async read(buffer, offset, length, position) {
         if (typeof offset == 'object' && offset != null) {
             position = offset.position;
@@ -270,19 +160,24 @@ export class FileHandle {
             offset = buffer.offset;
             buffer = buffer.buffer;
         }
-        const pos = Number.isSafeInteger(position) ? position : this.position;
-        buffer ||= new Uint8Array(this.inode.size);
+        if (position && position > Number.MAX_SAFE_INTEGER)
+            throw UV('EINVAL');
+        if (typeof position == 'bigint')
+            position = Number(position);
+        position = Number.isSafeInteger(position) ? position : this.vfs.position;
+        buffer ||= new Uint8Array(this.vfs.inode.size);
         offset ??= 0;
-        return this._read(buffer, offset, length ?? buffer.byteLength - offset, pos ? Number(pos) : undefined);
+        const bytesRead = await this.vfs.read(buffer, offset, length ?? buffer.byteLength - offset, position);
+        return { bytesRead, buffer };
     }
     async readFile(_options) {
         const options = normalizeOptions(_options, null, 'r', 0o444);
         const flag = flags.parse(options.flag);
         if (flag & constants.O_WRONLY)
-            throw UV('EBADF', 'read', this.path);
+            throw UV('EBADF', 'read', this.vfs.path);
         const { size } = await this.stat();
         const data = new Uint8Array(size);
-        await this._read(data, 0, size, 0);
+        await this.vfs.read(data, 0, size, 0);
         const buffer = Buffer.from(data);
         return options.encoding ? buffer.toString(options.encoding) : buffer;
     }
@@ -291,9 +186,9 @@ export class FileHandle {
      * The handle will not be closed automatically.
      */
     readableWebStream(options = {}) {
-        if (this.closed)
-            throw UV('EBADF', 'readableWebStream', this.path);
-        return this.fs.streamRead(this.internalPath, options);
+        if (this.vfs.isClosed)
+            throw UV('EBADF', 'readableWebStream', this.vfs.path);
+        return this.vfs.fs.streamRead(this.vfs.internalPath, options);
     }
     /**
      * Not part of the Node.js API!
@@ -303,11 +198,11 @@ export class FileHandle {
      * @internal
      */
     writableWebStream(options = {}) {
-        if (this.closed)
-            throw UV('EBADF', 'writableWebStream', this.path);
-        if (this.inode.flags & InodeFlags.Immutable)
-            throw UV('EPERM', 'writableWebStream', this.path);
-        return this.fs.streamWrite(this.internalPath, options);
+        if (this.vfs.isClosed)
+            throw UV('EBADF', 'writableWebStream', this.vfs.path);
+        if (this.vfs.inode.flags & InodeFlags.Immutable)
+            throw UV('EPERM', 'writableWebStream', this.vfs.path);
+        return this.vfs.fs.streamWrite(this.vfs.internalPath, options);
     }
     /**
      * Creates a readline Interface object that allows reading the file line by line
@@ -315,49 +210,19 @@ export class FileHandle {
      * @returns A readline interface for reading the file line by line
      */
     readLines(options) {
-        if (this.closed || this.flag & constants.O_WRONLY)
-            throw UV('EBADF', 'read', this.path);
+        if (this.vfs.isClosed || this.vfs.flag & constants.O_WRONLY)
+            throw UV('EBADF', 'read', this.vfs.path);
         return createInterface({ input: this.createReadStream(options), crlfDelay: Infinity });
     }
     [Symbol.asyncDispose]() {
         return this.close();
     }
     async stat(opts) {
-        if (this.closed)
-            throw UV('EBADF', 'stat', this.path);
-        if (checkAccess && !hasAccess(this.context, this.inode, constants.R_OK))
-            throw UV('EACCES', 'stat', this.path);
-        return opts?.bigint ? new BigIntStats(this.inode) : new Stats(this.inode);
-    }
-    /**
-     * Write buffer to the file.
-     * @param buffer Uint8Array containing the data to write to the file.
-     * @param offset Offset in the buffer to start reading data from.
-     * @param length The amount of bytes to write to the file.
-     * @param position Offset from the beginning of the file where this data should be written.
-     * If position is null, the data will be written at  the current position.
-     */
-    async _write(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
-        if (this.closed)
-            throw UV('EBADF', 'write', this.path);
-        if (this.inode.flags & InodeFlags.Immutable)
-            throw UV('EPERM', 'write', this.path);
-        if (!(this.flag & constants.O_WRONLY || this.flag & constants.O_RDWR))
-            throw UV('EBADF', 'write', this.path);
-        if (this.fs.attributes.has('readonly'))
-            throw UV('EROFS', 'write', this.path);
-        this.dirty = true;
-        const end = position + length;
-        const slice = buffer.subarray(offset, offset + length);
-        if (!isCharacterDevice(this.inode) && !isBlockDevice(this.inode) && end > this.inode.size)
-            this.inode.size = end;
-        this.inode.mtimeMs = Date.now();
-        this.inode.ctimeMs = Date.now();
-        this._sync.position = position + slice.byteLength;
-        await this.fs.write(this.internalPath, slice, position);
-        if (this._isSync)
-            await this.sync();
-        return slice.byteLength;
+        if (this.vfs.isClosed)
+            throw UV('EBADF', 'stat', this.vfs.path);
+        if (checkAccess && !hasAccess(this.context, this.vfs.inode, constants.R_OK))
+            throw UV('EACCES', 'stat', this.vfs.path);
+        return opts?.bigint ? new BigIntStats(this.vfs.inode) : new Stats(this.vfs.inode);
     }
     /**
      * Asynchronously writes `string` to the file.
@@ -384,8 +249,8 @@ export class FileHandle {
             length = typeof lenOrEnc == 'number' ? lenOrEnc : buffer.byteLength;
             position = typeof position === 'number' ? position : null;
         }
-        position ??= this.position;
-        const bytesWritten = await this._write(buffer, offset, length, position);
+        position ??= this.vfs.position;
+        const bytesWritten = await this.vfs.write(buffer, offset, length, position);
         this._emitChange();
         return { buffer: data, bytesWritten };
     }
@@ -403,31 +268,18 @@ export class FileHandle {
         const options = normalizeOptions(_options, 'utf8', 'w', 0o644);
         const flag = flags.parse(options.flag);
         if (!(flag & constants.O_WRONLY || flag & constants.O_RDWR))
-            throw UV('EBADF', 'writeFile', this.path);
+            throw UV('EBADF', 'writeFile', this.vfs.path);
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
-        await this._write(encodedData, 0, encodedData.length, 0);
+        await this.vfs.write(encodedData, 0, encodedData.length, 0);
         this._emitChange();
     }
     /**
      * Asynchronous close(2) - close a `FileHandle`.
      */
     async close() {
-        if (this.closed)
-            throw UV('EBADF', 'close', this.path);
-        await this.sync();
-        this.dispose();
+        await this.vfs.close();
         deleteFD(this.context, this.fd);
     }
-    /**
-     * Cleans up. This will *not* sync the file data to the FS
-     */
-    dispose(force) {
-        if (this.closed)
-            throw UV('EBADF', 'close', this.path);
-        if (this.dirty && !force)
-            throw UV('EBUSY', 'close', this.path);
-        this.closed = true;
-    }
     /**
      * Asynchronous `writev`. Writes from multiple buffers.
      * @param buffers An array of Uint8Array buffers.
@@ -436,7 +288,7 @@ export class FileHandle {
      */
     async writev(buffers, position) {
         if (typeof position == 'number')
-            this.position = position;
+            this.vfs.position = position;
         let bytesWritten = 0;
         for (const buffer of buffers) {
             bytesWritten += (await this.write(buffer)).bytesWritten;
@@ -451,7 +303,7 @@ export class FileHandle {
      */
     async readv(buffers, position) {
         if (typeof position == 'number')
-            this.position = position;
+            this.vfs.position = position;
         let bytesRead = 0;
         for (const buffer of buffers) {
             bytesRead += (await this.read(buffer)).bytesRead;
@@ -463,8 +315,8 @@ export class FileHandle {
      * @param options Options for the readable stream
      */
     createReadStream(options = {}) {
-        if (this.closed || this.flag & constants.O_WRONLY)
-            throw UV('EBADF', 'createReadStream', this.path);
+        if (this.vfs.isClosed || this.vfs.flag & constants.O_WRONLY)
+            throw UV('EBADF', 'createReadStream', this.vfs.path);
         return new ReadStream(options, this);
     }
     /**
@@ -472,52 +324,26 @@ export class FileHandle {
      * @param options Options for the writeable stream.
      */
     createWriteStream(options = {}) {
-        if (this.closed)
-            throw UV('EBADF', 'createWriteStream', this.path);
-        if (this.inode.flags & InodeFlags.Immutable)
-            throw UV('EPERM', 'createWriteStream', this.path);
-        if (this.fs.attributes.has('readonly'))
-            throw UV('EROFS', 'createWriteStream', this.path);
+        if (this.vfs.isClosed)
+            throw UV('EBADF', 'createWriteStream', this.vfs.path);
+        if (this.vfs.inode.flags & InodeFlags.Immutable)
+            throw UV('EPERM', 'createWriteStream', this.vfs.path);
+        if (this.vfs.fs.attributes.has('readonly'))
+            throw UV('EROFS', 'createWriteStream', this.vfs.path);
         return new WriteStream(options, this);
     }
 }
 export async function rename(oldPath, newPath) {
-    oldPath = normalizePath(oldPath);
-    __assertType(oldPath);
-    newPath = normalizePath(newPath);
-    __assertType(newPath);
-    const $ex = { syscall: 'rename', path: oldPath, dest: newPath };
-    const src = resolveMount(oldPath, this);
-    const dst = resolveMount(newPath, this);
-    if (src.fs !== dst.fs)
-        throw UV('EXDEV', $ex);
-    if (dst.path.startsWith(src.path + '/'))
-        throw UV('EBUSY', $ex);
-    const parent = (await stat.call(this, dirname(oldPath)).catch(rethrow($ex)));
-    const stats = (await stat.call(this, oldPath).catch(rethrow($ex)));
-    const newParent = (await stat.call(this, dirname(newPath)).catch(rethrow($ex)));
-    const newStats = (await stat.call(this, newPath).catch((e) => {
-        if (e.code == 'ENOENT')
-            return null;
-        throw setUVMessage(Object.assign(e, $ex));
-    }));
-    if (checkAccess && (!parent.hasAccess(constants.R_OK, this) || !newParent.hasAccess(constants.W_OK, this)))
-        throw UV('EACCES', $ex);
-    if (newStats && !isDirectory(stats) && isDirectory(newStats))
-        throw UV('EISDIR', $ex);
-    if (newStats && isDirectory(stats) && !isDirectory(newStats))
-        throw UV('ENOTDIR', $ex);
-    await src.fs.rename(src.path, dst.path).catch(rethrow($ex));
-    emitChange(this, 'rename', oldPath);
-    emitChange(this, 'change', newPath);
+    await _async.rename.call(this, oldPath, newPath);
 }
 rename;
 /**
  * Test whether or not `path` exists by checking with the file system.
  */
 export async function exists(path) {
+    path = normalizePath(path);
     try {
-        const { fs, path: resolved } = resolveMount(await realpath.call(this, path), this);
+        const { fs, path: resolved } = await _async.resolve(this, path);
         return await fs.exists(resolved);
     }
     catch (e) {
@@ -529,7 +355,7 @@ export async function exists(path) {
 }
 export async function stat(path, options) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(await realpath.call(this, path), this);
+    const { fs, path: resolved } = await _async.resolve(this, path);
     const $ex = { syscall: 'stat', path };
     const stats = await fs.stat(resolved).catch(rethrow($ex));
     if (checkAccess && !hasAccess(this, stats, constants.R_OK))
@@ -540,9 +366,9 @@ stat;
 export async function lstat(path, options) {
     path = normalizePath(path);
     const $ex = { syscall: 'lstat', path };
-    path = join(await realpath.call(this, dirname(path)), basename(path));
-    const { fs, path: resolved } = resolveMount(path, this);
-    const stats = await fs.stat(resolved).catch(rethrow($ex));
+    const { base, dir } = parse(path);
+    const { fs, path: parent } = await _async.resolve(this, dir);
+    const stats = await fs.stat(base ? join(parent, base) : parent).catch(rethrow($ex));
     if (checkAccess && !hasAccess(this, stats, constants.R_OK))
         throw UV('EACCES', $ex);
     return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
@@ -576,45 +402,6 @@ export async function unlink(path) {
     emitChange(this, 'rename', path.toString());
 }
 unlink;
-/**
- * Opens a file. This helper handles the complexity of file flags.
- * @internal
- */
-async function _open($, path, opt) {
-    path = normalizePath(path);
-    const mode = normalizeMode(opt.mode, 0o644), flag = flags.parse(opt.flag);
-    const $ex = { syscall: 'open', path };
-    const { fs, path: resolved, stats } = await _resolve($, path.toString(), opt.preserveSymlinks);
-    if (!stats) {
-        if (!(flag & constants.O_CREAT))
-            throw UV('ENOENT', $ex);
-        // Create the file
-        const parentStats = await fs.stat(dirname(resolved));
-        if (checkAccess && !hasAccess($, parentStats, constants.W_OK))
-            throw UV('EACCES', 'open', dirname(path));
-        if (!isDirectory(parentStats))
-            throw UV('ENOTDIR', 'open', dirname(path));
-        if (!opt.allowDirectory && mode & constants.S_IFDIR)
-            throw UV('EISDIR', 'open', path);
-        const { euid: uid, egid: gid } = $?.credentials ?? defaultContext.credentials;
-        const inode = await fs.createFile(resolved, {
-            mode,
-            uid: parentStats.mode & constants.S_ISUID ? parentStats.uid : uid,
-            gid: parentStats.mode & constants.S_ISGID ? parentStats.gid : gid,
-        });
-        return new FileHandle($, toFD(new SyncHandle($, path, fs, resolved, flag, inode)));
-    }
-    if (checkAccess && !hasAccess($, stats, flags.toMode(flag)))
-        throw UV('EACCES', $ex);
-    if (flag & constants.O_EXCL)
-        throw UV('EEXIST', $ex);
-    const handle = new FileHandle($, toFD(new SyncHandle($, path, fs, resolved, flag, stats)));
-    if (!opt.allowDirectory && mode & constants.S_IFDIR)
-        throw UV('EISDIR', 'open', path);
-    if (flag & constants.O_TRUNC)
-        await handle.truncate(0);
-    return handle;
-}
 /**
  * Asynchronous file open.
  * @see https://nodejs.org/api/fs.html#fspromisesopenpath-flags-mode
@@ -622,7 +409,8 @@ async function _open($, path, opt) {
  * @param mode Mode to use to open the file. Can be ignored if the filesystem doesn't support permissions.
  */
 export async function open(path, flag = 'r', mode = 0o644) {
-    return await _open(this, path, { flag, mode });
+    const handle = await _async.open(this, path, { flag, mode });
+    return new FileHandle(this, toFD(handle));
 }
 open;
 export async function readFile(path, _options) {
@@ -683,7 +471,7 @@ export async function appendFile(path, data, _options) {
     try {
         const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
         const flag = flags.parse(options.flag);
-        const $ex = { syscall: 'write', path: path instanceof FileHandle ? path.path : path.toString() };
+        const $ex = { syscall: 'write', path: path instanceof FileHandle ? path['vfs'].path : path.toString() };
         if (!(flag & constants.O_APPEND))
             throw UV('EBADF', $ex);
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
@@ -702,8 +490,8 @@ export async function appendFile(path, data, _options) {
 }
 appendFile;
 export async function rmdir(path) {
-    path = await realpath.call(this, path);
-    const { fs, path: resolved } = resolveMount(path, this);
+    path = normalizePath(path);
+    const { fs, path: resolved } = await _async.resolve(this, path);
     const $ex = { syscall: 'rmdir', path };
     const stats = await fs.stat(resolved).catch(rethrow($ex));
     if (!stats)
@@ -717,103 +505,32 @@ export async function rmdir(path) {
 }
 rmdir;
 export async function mkdir(path, options) {
-    const { euid: uid, egid: gid } = this?.credentials ?? defaultContext.credentials;
     options = typeof options === 'object' ? options : { mode: options };
     const mode = normalizeMode(options?.mode, 0o777);
-    path = await realpath.call(this, path);
-    const { fs, path: resolved } = resolveMount(path, this);
-    const __create = async (path, resolved, parent) => {
-        if (checkAccess && !hasAccess(this, parent, constants.W_OK))
-            throw UV('EACCES', 'mkdir', dirname(path));
-        const inode = await fs
-            .mkdir(resolved, {
-            mode,
-            uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
-            gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
-        })
-            .catch(rethrow({ syscall: 'mkdir', path }));
-        emitChange(this, 'rename', path);
-        return inode;
-    };
-    if (!options?.recursive) {
-        await __create(path, resolved, await fs.stat(dirname(resolved)).catch(rethrow({ path: dirname(path) })));
-        return;
-    }
-    const dirs = [];
-    let origDir = path;
-    for (let dir = resolved; !(await fs.exists(dir).catch(rethrow({ syscall: 'exists', path: origDir }))); dir = dirname(dir), origDir = dirname(origDir)) {
-        dirs.unshift([origDir, dir]);
-    }
-    if (!dirs.length)
-        return;
-    const stats = [await fs.stat(dirname(dirs[0][1])).catch(rethrow({ syscall: 'stat', path: dirname(dirs[0][0]) }))];
-    for (const [i, [path, resolved]] of dirs.entries()) {
-        stats.push(await __create(path, resolved, stats[i]));
-    }
-    return dirs[0][0];
+    return await _async.mkdir.call(this, path, { ...options, mode });
 }
 mkdir;
-export async function readdir(_path, options) {
+export async function readdir(path, options) {
+    path = normalizePath(path);
     const opt = typeof options === 'object' && options != null ? options : { encoding: options, withFileTypes: false, recursive: false };
-    const path = await realpath.call(this, _path);
-    const { fs, path: resolved } = resolveMount(path, this);
-    const $ex = { syscall: 'readdir', path };
-    const stats = await fs.stat(resolved).catch(rethrow({ syscall: 'stat', path }));
-    if (!stats)
-        throw UV('ENOENT', $ex);
-    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
-        throw UV('EACCES', $ex);
-    if (!isDirectory(stats))
-        throw UV('ENOTDIR', $ex);
-    const entries = await fs.readdir(resolved).catch(rethrow($ex));
+    const rawEntries = await _async.readdir.call(this, path, opt);
     const values = [];
-    const addEntry = async (entry) => {
-        let entryStats;
-        if (opt.recursive || opt.withFileTypes) {
-            entryStats = await fs.stat(join(resolved, entry)).catch((e) => {
-                if (e.code == 'ENOENT')
-                    return;
-                throw setUVMessage(Object.assign(e, { syscall: 'stat', path: join(path, entry) }));
-            });
-            if (!entryStats)
-                return;
-        }
+    for (const entry of rawEntries) {
         if (opt.withFileTypes) {
-            values.push(Dirent.from(join(_path.toString(), entry), entryStats, opt.encoding));
+            values.push(Dirent.from(entry, opt.encoding));
         }
         else if (opt.encoding == 'buffer') {
-            values.push(Buffer.from(entry));
+            values.push(Buffer.from(entry.path));
         }
         else {
-            values.push(entry);
+            values.push(entry.path);
         }
-        if (!opt.recursive || !isDirectory(entryStats))
-            return;
-        const children = await fs.readdir(join(resolved, entry)).catch(rethrow({ syscall: 'readdir', path: join(path, entry) }));
-        for (const child of children)
-            await addEntry(join(entry, child));
-    };
-    await Promise.all(entries.map(addEntry));
+    }
     return values;
 }
 readdir;
 export async function link(path, dest) {
-    path = normalizePath(path);
-    dest = normalizePath(dest);
-    const { fs, path: resolved } = resolveMount(path, this);
-    const dst = resolveMount(dest, this);
-    const $ex = { syscall: 'link', path };
-    if (fs != dst.fs)
-        throw UV('EXDEV', $ex);
-    const stats = await fs.stat(dirname(resolved)).catch(rethrow({ syscall: 'stat', path: dirname(path) }));
-    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
-        throw UV('EACCES', 'link', dirname(path));
-    // We need to use the VFS here since the link path may be a mount point
-    if (checkAccess && !(await stat.call(this, dirname(dest))).hasAccess(constants.W_OK, this))
-        throw UV('EACCES', 'link', dirname(dest));
-    if (checkAccess && !hasAccess(this, await fs.stat(resolved).catch(rethrow($ex)), constants.R_OK))
-        throw UV('EACCES', $ex);
-    return await fs.link(resolved, dst.path).catch(rethrow($ex));
+    return await _async.link.call(this, path, dest);
 }
 link;
 /**
@@ -830,8 +547,9 @@ export async function symlink(dest, path, type = 'file') {
         path = normalizePath(path);
         if (await exists.call(this, path))
             throw UV('EEXIST', 'symlink', path);
-        const handle = __addDisposableResource(env_5, await _open(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
-        await handle.writeFile(normalizePath(dest, true));
+        const handle = __addDisposableResource(env_5, await _async.open(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
+        const encoded = encodeUTF8(normalizePath(dest, true));
+        await handle.write(encoded, 0, encoded.length, 0);
         await handle.chmod(constants.S_IFLNK);
     }
     catch (e_5) {
@@ -846,17 +564,18 @@ export async function symlink(dest, path, type = 'file') {
 }
 symlink;
 export async function readlink(path, options) {
+    path = normalizePath(path);
+    const buf = Buffer.from(await _async.readlink.call(this, path), 'utf-8');
+    const encoding = typeof options == 'object' ? options?.encoding : options;
+    // always defaults to utf-8 to avoid wrangler (cloudflare) worker "unknown encoding" exception
+    return encoding == 'buffer' ? buf : buf.toString((encoding ?? 'utf-8'));
+}
+readlink;
+export async function chown(path, uid, gid) {
     const env_6 = { stack: [], error: void 0, hasError: false };
     try {
-        path = normalizePath(path);
-        __assertType(path);
-        const handle = __addDisposableResource(env_6, await _open(this, path, { flag: 'r', mode: 0o644, preserveSymlinks: true }), true);
-        if (!isSymbolicLink(handle.inode))
-            throw UV('EINVAL', 'readlink', path);
-        const value = await handle.readFile();
-        const encoding = typeof options == 'object' ? options?.encoding : options;
-        // always defaults to utf-8 to avoid wrangler (cloudflare) worker "unknown encoding" exception
-        return encoding == 'buffer' ? value : value.toString((encoding ?? 'utf-8'));
+        const handle = __addDisposableResource(env_6, await open.call(this, path, 'r+'), true);
+        await handle.chown(uid, gid);
     }
     catch (e_6) {
         env_6.error = e_6;
@@ -868,11 +587,16 @@ export async function readlink(path, options) {
             await result_6;
     }
 }
-readlink;
-export async function chown(path, uid, gid) {
+chown;
+export async function lchown(path, uid, gid) {
     const env_7 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_7, await open.call(this, path, 'r+'), true);
+        const handle = __addDisposableResource(env_7, await _async.open(this, path, {
+            flag: 'r+',
+            mode: 0o644,
+            preserveSymlinks: true,
+            allowDirectory: true,
+        }), true);
         await handle.chown(uid, gid);
     }
     catch (e_7) {
@@ -885,17 +609,12 @@ export async function chown(path, uid, gid) {
             await result_7;
     }
 }
-chown;
-export async function lchown(path, uid, gid) {
+lchown;
+export async function chmod(path, mode) {
     const env_8 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_8, await _open(this, path, {
-            flag: 'r+',
-            mode: 0o644,
-            preserveSymlinks: true,
-            allowDirectory: true,
-        }), true);
-        await handle.chown(uid, gid);
+        const handle = __addDisposableResource(env_8, await open.call(this, path, 'r+'), true);
+        await handle.chmod(mode);
     }
     catch (e_8) {
         env_8.error = e_8;
@@ -907,11 +626,17 @@ export async function lchown(path, uid, gid) {
             await result_8;
     }
 }
-lchown;
-export async function chmod(path, mode) {
+chmod;
+export async function lchmod(path, mode) {
     const env_9 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_9, await open.call(this, path, 'r+'), true);
+        mode = normalizeMode(mode);
+        const handle = __addDisposableResource(env_9, await _async.open(this, path, {
+            flag: 'r+',
+            mode: 0o644,
+            preserveSymlinks: true,
+            allowDirectory: true,
+        }), true);
         await handle.chmod(mode);
     }
     catch (e_9) {
@@ -924,17 +649,18 @@ export async function chmod(path, mode) {
             await result_9;
     }
 }
-chmod;
-export async function lchmod(path, mode) {
+lchmod;
+/**
+ * Change file timestamps of the file referenced by the supplied path.
+ */
+export async function utimes(path, atime, mtime) {
     const env_10 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_10, await _open(this, path, {
+        const handle = __addDisposableResource(env_10, await _async.open(this, path, {
             flag: 'r+',
-            mode: 0o644,
-            preserveSymlinks: true,
             allowDirectory: true,
         }), true);
-        await handle.chmod(mode);
+        await handle.utimes(normalizeTime(atime), normalizeTime(mtime));
     }
     catch (e_10) {
         env_10.error = e_10;
@@ -946,99 +672,36 @@ export async function lchmod(path, mode) {
             await result_10;
     }
 }
-lchmod;
-/**
- * Change file timestamps of the file referenced by the supplied path.
- */
-export async function utimes(path, atime, mtime) {
-    const env_11 = { stack: [], error: void 0, hasError: false };
-    try {
-        const handle = __addDisposableResource(env_11, await open.call(this, path, 'r+'), true);
-        await handle.utimes(atime, mtime);
-    }
-    catch (e_11) {
-        env_11.error = e_11;
-        env_11.hasError = true;
-    }
-    finally {
-        const result_11 = __disposeResources(env_11);
-        if (result_11)
-            await result_11;
-    }
-}
 utimes;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  */
 export async function lutimes(path, atime, mtime) {
-    const env_12 = { stack: [], error: void 0, hasError: false };
+    const env_11 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_12, await _open(this, path, {
+        const handle = __addDisposableResource(env_11, await _async.open(this, path, {
             flag: 'r+',
             mode: 0o644,
             preserveSymlinks: true,
             allowDirectory: true,
         }), true);
-        await handle.utimes(new Date(atime), new Date(mtime));
+        await handle.utimes(normalizeTime(atime), normalizeTime(mtime));
     }
-    catch (e_12) {
-        env_12.error = e_12;
-        env_12.hasError = true;
+    catch (e_11) {
+        env_11.error = e_11;
+        env_11.hasError = true;
     }
     finally {
-        const result_12 = __disposeResources(env_12);
-        if (result_12)
-            await result_12;
+        const result_11 = __disposeResources(env_11);
+        if (result_11)
+            await result_11;
     }
 }
 lutimes;
-/**
- * Resolves the mount and real path for a path.
- * Additionally, any stats fetched will be returned for de-duplication
- * @internal @hidden
- */
-async function _resolve($, path, preserveSymlinks) {
-    if (preserveSymlinks) {
-        const resolved = resolveMount(path, $);
-        const stats = await resolved.fs.stat(resolved.path).catch(() => undefined);
-        return { ...resolved, fullPath: path, stats };
-    }
-    /* Try to resolve it directly. If this works,
-    that means we don't need to perform any resolution for parent directories. */
-    try {
-        const resolved = resolveMount(path, $);
-        // Stat it to make sure it exists
-        const stats = await resolved.fs.stat(resolved.path);
-        if (!isSymbolicLink(stats)) {
-            return { ...resolved, fullPath: path, stats };
-        }
-        const target = resolve.call($, dirname(path), (await readlink.call($, path)).toString());
-        return await _resolve($, target);
-    }
-    catch {
-        // Go the long way
-    }
-    const { base, dir } = parse(path);
-    const realDir = dir == '/' ? '/' : await realpath.call($, dir);
-    const maybePath = join(realDir, base);
-    const resolved = resolveMount(maybePath, $);
-    const stats = await resolved.fs.stat(resolved.path).catch((e) => {
-        if (e.code == 'ENOENT')
-            return;
-        throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath }));
-    });
-    if (!stats)
-        return { ...resolved, fullPath: path };
-    if (!isSymbolicLink(stats)) {
-        return { ...resolved, fullPath: maybePath, stats };
-    }
-    const target = resolve.call($, realDir, (await readlink.call($, maybePath)).toString());
-    return await _resolve($, target);
-}
 export async function realpath(path, options) {
     const encoding = typeof options == 'string' ? options : (options?.encoding ?? 'utf8');
     path = normalizePath(path);
-    const { fullPath } = await _resolve(this, path);
+    const { fullPath } = await _async.resolve(this, path);
     if (encoding == 'utf8' || encoding == 'utf-8')
         return fullPath;
     const buf = Buffer.from(fullPath, 'utf-8');