@zenfs/core 1.11.4 → 2.1.0

package/dist/vfs/promises.js

@@ -51,37 +51,74 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { Buffer } from 'buffer';
-import { _throw } from 'utilium';
-import { credentials } from '../internal/credentials.js';
-import { Errno, ErrnoError } from '../internal/error.js';
-import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../internal/file.js';
+import { Exception, rethrow, setUVMessage, UV } from 'kerium';
+import { decodeUTF8, pick } from 'utilium';
+import { defaultContext } from '../internal/contexts.js';
+import { hasAccess, InodeFlags, isBlockDevice, isCharacterDevice, isDirectory, isSymbolicLink } from '../internal/inode.js';
+import { dirname, join, parse, resolve } from '../path.js';
 import '../polyfills.js';
-import { BigIntStats } from '../stats.js';
-import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
-import { config } from './config.js';
+import { createInterface } from '../readline.js';
+import { __assertType, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { checkAccess } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
-import { dirname, join, parse, resolve } from './path.js';
-import { _statfs, fd2file, fdMap, file2fd, fixError, resolveMount } from './shared.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 { ReadStream, WriteStream } from './streams.js';
-import { FSWatcher, emitChange } from './watchers.js';
+import { emitChange, FSWatcher } from './watchers.js';
 export * as constants from './constants.js';
 export class FileHandle {
-    constructor(fdOrFile, context) {
+    /**
+     * 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.flag & constants.O_APPEND ? this.inode.size : this._position;
+    }
+    set position(value) {
+        this._position = value;
+    }
+    constructor(context, fd) {
         this.context = context;
-        const isFile = typeof fdOrFile != 'number';
-        this.fd = isFile ? file2fd(fdOrFile) : fdOrFile;
-        this.file = isFile ? fdOrFile : fd2file(fdOrFile);
+        this.fd = fd;
+        /**
+         * Current position
+         */
+        this._position = 0;
+        /**
+         * Whether the file has changes which have not been written to the FS
+         */
+        this.dirty = false;
+        /**
+         * Whether the file is open or closed
+         */
+        this.closed = false;
+        const sync = fromFD(context, fd);
+        Object.assign(this, pick(sync, 'path', 'fs', 'internalPath', 'flag', 'inode'));
+    }
+    get _isSync() {
+        return !!(this.flag & constants.O_SYNC || this.inode.flags & InodeFlags.Sync);
     }
     _emitChange() {
-        var _a, _b, _c;
-        emitChange(this.context, 'change', this.file.path.slice((_c = (_b = (_a = this.context) === null || _a === void 0 ? void 0 : _a.root) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0));
+        emitChange(this.context, 'change', this.path);
     }
     /**
      * Asynchronous fchown(2) - Change ownership of a file.
      */
     async chown(uid, gid) {
-        await this.file.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();
         this._emitChange();
     }
     /**
@@ -91,31 +128,55 @@ export class FileHandle {
     async chmod(mode) {
         const numMode = normalizeMode(mode, -1);
         if (numMode < 0)
-            throw new ErrnoError(Errno.EINVAL, 'Invalid mode');
-        await this.file.chmod(numMode);
+            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();
         this._emitChange();
     }
     /**
      * Asynchronous fdatasync(2) - synchronize a file's in-core state with storage device.
      */
     datasync() {
-        return this.file.datasync();
+        return this.sync();
     }
     /**
      * Asynchronous fsync(2) - synchronize a file's in-core state with the underlying storage device.
      */
-    sync() {
-        return this.file.sync();
+    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;
     }
     /**
      * Asynchronous ftruncate(2) - Truncate a file to a specified length.
      * @param length If not specified, defaults to `0`.
      */
-    async truncate(length) {
-        length || (length = 0);
+    async truncate(length = 0) {
+        if (this.closed)
+            throw UV('EBADF', 'truncate', this.path);
         if (length < 0)
-            throw new ErrnoError(Errno.EINVAL);
-        await this.file.truncate(length);
+            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();
         this._emitChange();
     }
     /**
@@ -124,7 +185,13 @@ export class FileHandle {
      * @param mtime The last modified time. If a string is provided, it will be coerced to number.
      */
     async utimes(atime, mtime) {
-        await this.file.utimes(normalizeTime(atime), normalizeTime(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();
         this._emitChange();
     }
     /**
@@ -138,17 +205,41 @@ export class FileHandle {
      */
     async appendFile(data, _options = {}) {
         const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
-        const flag = parseFlag(options.flag);
-        if (!isAppendable(flag)) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending');
-        }
-        if (typeof data != 'string' && !options.encoding) {
-            throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
-        }
+        const flag = flags.parse(options.flag);
+        if (!(flag & constants.O_APPEND))
+            throw UV('EBADF', 'write', this.path);
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
-        await this.file.write(encodedData, 0, encodedData.length);
+        await this._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._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;
@@ -161,19 +252,19 @@ export class FileHandle {
             offset = buffer.offset;
             buffer = buffer.buffer;
         }
-        const pos = Number.isSafeInteger(position) ? position : this.file.position;
-        buffer || (buffer = new Uint8Array((await this.file.stat()).size));
+        const pos = Number.isSafeInteger(position) ? position : this.position;
+        buffer || (buffer = new Uint8Array(this.inode.size));
         offset !== null && offset !== void 0 ? offset : (offset = 0);
-        return this.file.read(buffer, offset, length !== null && length !== void 0 ? length : buffer.byteLength - offset, pos);
+        return this._read(buffer, offset, length !== null && length !== void 0 ? length : buffer.byteLength - offset, pos);
     }
     async readFile(_options) {
         const options = normalizeOptions(_options, null, 'r', 0o444);
-        const flag = parseFlag(options.flag);
-        if (!isReadable(flag)) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for reading');
-        }
+        const flag = flags.parse(options.flag);
+        if (flag & constants.O_WRONLY)
+            throw UV('EBADF', 'read', this.path);
         const { size } = await this.stat();
-        const { buffer: data } = await this.file.read(new Uint8Array(size), 0, size, 0);
+        const data = new Uint8Array(size);
+        await this._read(data, 0, size, 0);
         const buffer = Buffer.from(data);
         return options.encoding ? buffer.toString(options.encoding) : buffer;
     }
@@ -182,23 +273,73 @@ export class FileHandle {
      * The handle will not be closed automatically.
      */
     readableWebStream(options = {}) {
-        return this.file.streamRead({});
+        if (this.closed)
+            throw UV('EBADF', 'readableWebStream', this.path);
+        return this.fs.streamRead(this.internalPath, options);
     }
     /**
-     * @todo Implement
+     * Not part of the Node.js API!
+     *
+     * Write file data using a `WritableStream`.
+     * The handle will not be closed automatically.
+     * @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);
+    }
+    /**
+     * Creates a readline Interface object that allows reading the file line by line
+     * @param options Options for creating a read stream
+     * @returns A readline interface for reading the file line by line
      */
     readLines(options) {
-        throw ErrnoError.With('ENOSYS', this.file.path, 'FileHandle.readLines');
+        if (this.closed || this.flag & constants.O_WRONLY)
+            throw UV('EBADF', 'read', this.path);
+        return createInterface({ input: this.createReadStream(options), crlfDelay: Infinity });
     }
     [Symbol.asyncDispose]() {
         return this.close();
     }
     async stat(opts) {
-        const stats = await this.file.stat();
-        if (config.checkAccess && !stats.hasAccess(constants.R_OK, this.context)) {
-            throw ErrnoError.With('EACCES', this.file.path, 'stat');
-        }
-        return (opts === null || opts === void 0 ? void 0 : opts.bigint) ? new BigIntStats(stats) : stats;
+        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 === null || opts === void 0 ? void 0 : 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._position = position + slice.byteLength;
+        await this.fs.write(this.internalPath, slice, position);
+        if (this._isSync)
+            await this.sync();
+        return slice.byteLength;
     }
     /**
      * Asynchronously writes `string` to the file.
@@ -225,8 +366,8 @@ export class FileHandle {
             length = typeof lenOrEnc == 'number' ? lenOrEnc : buffer.byteLength;
             position = typeof position === 'number' ? position : null;
         }
-        position !== null && position !== void 0 ? position : (position = this.file.position);
-        const bytesWritten = await this.file.write(buffer, offset, length, position);
+        position !== null && position !== void 0 ? position : (position = this.position);
+        const bytesWritten = await this._write(buffer, offset, length, position);
         this._emitChange();
         return { buffer: data, bytesWritten };
     }
@@ -242,23 +383,32 @@ export class FileHandle {
      */
     async writeFile(data, _options = {}) {
         const options = normalizeOptions(_options, 'utf8', 'w', 0o644);
-        const flag = parseFlag(options.flag);
-        if (!isWriteable(flag)) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for writing');
-        }
-        if (typeof data != 'string' && !options.encoding) {
-            throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
-        }
+        const flag = flags.parse(options.flag);
+        if (!(flag & constants.O_WRONLY || flag & constants.O_RDWR))
+            throw UV('EBADF', 'writeFile', this.path);
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
-        await this.file.write(encodedData, 0, encodedData.length, 0);
+        await this._write(encodedData, 0, encodedData.length, 0);
         this._emitChange();
     }
     /**
      * Asynchronous close(2) - close a `FileHandle`.
      */
     async close() {
-        await this.file.close();
-        fdMap.delete(this.fd);
+        if (this.closed)
+            throw UV('EBADF', 'close', this.path);
+        await this.sync();
+        this.dispose();
+        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.
@@ -268,7 +418,7 @@ export class FileHandle {
      */
     async writev(buffers, position) {
         if (typeof position == 'number')
-            this.file.position = position;
+            this.position = position;
         let bytesWritten = 0;
         for (const buffer of buffers) {
             bytesWritten += (await this.write(buffer)).bytesWritten;
@@ -283,7 +433,7 @@ export class FileHandle {
      */
     async readv(buffers, position) {
         if (typeof position == 'number')
-            this.file.position = position;
+            this.position = position;
         let bytesRead = 0;
         for (const buffer of buffers) {
             bytesRead += (await this.read(buffer)).bytesRead;
@@ -295,6 +445,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);
         return new ReadStream(options, this);
     }
     /**
@@ -302,31 +454,44 @@ 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);
         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 (config.checkAccess && !(await stat.call(this, dirname(oldPath))).hasAccess(constants.W_OK, this)) {
-        throw ErrnoError.With('EACCES', oldPath, 'rename');
-    }
-    try {
-        if (src.mountPoint == dst.mountPoint) {
-            await src.fs.rename(src.path, dst.path);
-            emitChange(this, 'rename', oldPath.toString());
-            emitChange(this, 'change', newPath.toString());
-            return;
-        }
-        await writeFile.call(this, newPath, await readFile(oldPath));
-        await unlink.call(this, oldPath);
-        emitChange(this, 'rename', oldPath.toString());
-    }
-    catch (e) {
-        throw fixError(e, { [src.path]: oldPath, [dst.path]: newPath });
-    }
+    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);
 }
 rename;
 /**
@@ -338,7 +503,7 @@ export async function exists(path) {
         return await fs.exists(resolved);
     }
     catch (e) {
-        if (e instanceof ErrnoError && e.code == 'ENOENT') {
+        if (e instanceof Exception && e.code == 'ENOENT') {
             return false;
         }
         throw e;
@@ -347,31 +512,23 @@ 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);
-    try {
-        const stats = await fs.stat(resolved);
-        if (config.checkAccess && !stats.hasAccess(constants.R_OK, this)) {
-            throw ErrnoError.With('EACCES', resolved, 'stat');
-        }
-        return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : stats;
-    }
-    catch (e) {
-        throw fixError(e, { [resolved]: path });
-    }
+    const $ex = { syscall: 'stat', path };
+    const stats = await fs.stat(resolved).catch(rethrow($ex));
+    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
+        throw UV('EACCES', $ex);
+    return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new Stats(stats);
 }
 stat;
 export async function lstat(path, options) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
-    try {
-        const stats = await fs.stat(resolved);
-        return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : stats;
-    }
-    catch (e) {
-        throw fixError(e, { [resolved]: path });
-    }
+    const $ex = { syscall: 'lstat', path };
+    const stats = await fs.stat(resolved).catch(rethrow($ex));
+    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
+        throw UV('EACCES', $ex);
+    return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new Stats(stats);
 }
 lstat;
-// FILE-ONLY METHODS
 export async function truncate(path, len = 0) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
@@ -392,28 +549,14 @@ truncate;
 export async function unlink(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
-    try {
-        if (config.checkAccess && !(await fs.stat(resolved)).hasAccess(constants.W_OK, this)) {
-            throw ErrnoError.With('EACCES', resolved, 'unlink');
-        }
-        await fs.unlink(resolved);
-        emitChange(this, 'rename', path.toString());
-    }
-    catch (e) {
-        throw fixError(e, { [resolved]: path });
-    }
+    const $ex = { syscall: 'unlink', path };
+    const stats = await fs.stat(resolved).catch(rethrow($ex));
+    if (checkAccess && !hasAccess(this, stats, constants.W_OK))
+        throw UV('EACCES', $ex);
+    await fs.unlink(resolved).catch(rethrow($ex));
+    emitChange(this, 'rename', path.toString());
 }
 unlink;
-/**
- * Manually apply setuid/setgid.
- */
-async function applySetId(file, uid, gid) {
-    if (file.fs.attributes.has('setid'))
-        return;
-    const parent = await file.fs.stat(dirname(file.path));
-    await file.chown(parent.mode & constants.S_ISUID ? parent.uid : uid, // manually apply setuid/setgid
-    parent.mode & constants.S_ISGID ? parent.gid : gid);
-}
 /**
  * Opens a file. This helper handles the complexity of file flags.
  * @internal
@@ -421,47 +564,43 @@ async function applySetId(file, uid, gid) {
 async function _open($, path, opt) {
     var _a;
     path = normalizePath(path);
-    const mode = normalizeMode(opt.mode, 0o644), flag = parseFlag(opt.flag);
-    const { fullPath, fs, path: resolved, stats } = await _resolve($, path.toString(), opt.preserveSymlinks);
+    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 ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
-            throw ErrnoError.With('ENOENT', fullPath, '_open');
-        }
+        if (!(flag & constants.O_CREAT))
+            throw UV('ENOENT', $ex);
         // Create the file
         const parentStats = await fs.stat(dirname(resolved));
-        if (config.checkAccess && !parentStats.hasAccess(constants.W_OK, $)) {
-            throw ErrnoError.With('EACCES', dirname(fullPath), '_open');
-        }
-        if (!parentStats.isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', dirname(fullPath), '_open');
-        }
-        const { euid: uid, egid: gid } = (_a = $ === null || $ === void 0 ? void 0 : $.credentials) !== null && _a !== void 0 ? _a : credentials;
-        const file = await fs.createFile(resolved, flag, mode, { uid, gid });
-        await applySetId(file, uid, gid);
-        return new FileHandle(file, $);
-    }
-    if (config.checkAccess && !stats.hasAccess(flagToMode(flag), $)) {
-        throw ErrnoError.With('EACCES', fullPath, '_open');
-    }
-    if (isExclusive(flag)) {
-        throw ErrnoError.With('EEXIST', fullPath, '_open');
-    }
-    const handle = new FileHandle(await fs.openFile(resolved, flag), $);
-    /*
-        In a previous implementation, we deleted the file and
-        re-created it. However, this created a race condition if another
-        asynchronous request was trying to read the file, as the file
-        would not exist for a small period of time.
-    */
-    if (isTruncating(flag)) {
+        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 } = (_a = $ === null || $ === void 0 ? void 0 : $.credentials) !== null && _a !== void 0 ? _a : 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 http://www.manpagez.com/man/2/open/
- * @param flag Handles the complexity of the various file modes. See its API for more details.
+ * @see https://nodejs.org/api/fs.html#fspromisesopenpath-flags-mode
+ * @param flag {@link https://nodejs.org/api/fs.html#file-system-flags}
  * @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) {
@@ -471,7 +610,7 @@ open;
 export async function readFile(path, _options) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
-        const options = normalizeOptions(_options, null, 'r', 0o644);
+        const options = normalizeOptions(_options, null, 'r', 0o444);
         const handle = __addDisposableResource(env_2, typeof path == 'object' && 'fd' in path ? path : await open.call(this, path, options.flag, options.mode), true);
         return await handle.readFile(options);
     }
@@ -500,9 +639,8 @@ export async function writeFile(path, data, _options) {
         const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
         const handle = __addDisposableResource(env_3, path instanceof FileHandle ? path : await open.call(this, path.toString(), options.flag, options.mode), true);
         const _data = typeof data == 'string' ? data : data instanceof DataView ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : data;
-        if (typeof _data != 'string' && !(_data instanceof Uint8Array)) {
-            throw new ErrnoError(Errno.EINVAL, 'The "data" argument must be of type string or an instance of Buffer, TypedArray, or DataView. Received ' + typeof data, handle.file.path, 'writeFile');
-        }
+        if (typeof _data != 'string' && !(_data instanceof Uint8Array))
+            throw new TypeError('The "data" argument must be of type string or an instance of Buffer, TypedArray, or DataView. Received ' + typeof data);
         await handle.writeFile(_data, options);
     }
     catch (e_3) {
@@ -526,13 +664,10 @@ export async function appendFile(path, data, _options) {
     const env_4 = { stack: [], error: void 0, hasError: false };
     try {
         const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
-        const flag = parseFlag(options.flag);
-        if (!isAppendable(flag)) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending');
-        }
-        if (typeof data != 'string' && !options.encoding) {
-            throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
-        }
+        const flag = flags.parse(options.flag);
+        const $ex = { syscall: 'write', path: path instanceof FileHandle ? path.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);
         const handle = __addDisposableResource(env_4, typeof path == 'object' && 'fd' in path ? path : await open.call(this, path, options.flag, options.mode), true);
         await handle.appendFile(encodedData, options);
@@ -548,82 +683,72 @@ export async function appendFile(path, data, _options) {
     }
 }
 appendFile;
-// DIRECTORY-ONLY METHODS
 export async function rmdir(path) {
     path = await realpath.call(this, path);
     const { fs, path: resolved } = resolveMount(path, this);
-    try {
-        const stats = await fs.stat(resolved);
-        if (!stats) {
-            throw ErrnoError.With('ENOENT', path, 'rmdir');
-        }
-        if (!stats.isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
-        }
-        if (config.checkAccess && !stats.hasAccess(constants.W_OK, this)) {
-            throw ErrnoError.With('EACCES', resolved, 'rmdir');
-        }
-        await fs.rmdir(resolved);
-        emitChange(this, 'rename', path.toString());
-    }
-    catch (e) {
-        throw fixError(e, { [resolved]: path });
-    }
+    const $ex = { syscall: 'rmdir', path };
+    const stats = await fs.stat(resolved).catch(rethrow($ex));
+    if (!stats)
+        throw UV('ENOENT', $ex);
+    if (!isDirectory(stats))
+        throw UV('ENOTDIR', $ex);
+    if (checkAccess && !hasAccess(this, stats, constants.W_OK))
+        throw UV('EACCES', $ex);
+    await fs.rmdir(resolved).catch(rethrow($ex));
+    emitChange(this, 'rename', path.toString());
 }
 rmdir;
 export async function mkdir(path, options) {
-    var _a, _b;
-    const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : credentials;
+    var _a;
+    const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : defaultContext.credentials;
     options = typeof options === 'object' ? options : { mode: options };
     const mode = normalizeMode(options === null || options === void 0 ? void 0 : options.mode, 0o777);
     path = await realpath.call(this, path);
-    const { fs, path: resolved, root } = resolveMount(path, this);
-    const errorPaths = { [resolved]: path };
-    try {
-        if (!(options === null || options === void 0 ? void 0 : options.recursive)) {
-            if (config.checkAccess && !(await fs.stat(dirname(resolved))).hasAccess(constants.W_OK, this)) {
-                throw ErrnoError.With('EACCES', dirname(resolved), 'mkdir');
-            }
-            await fs.mkdir(resolved, mode, { uid, gid });
-            await applySetId(await fs.openFile(resolved, 'r+'), uid, gid);
-            emitChange(this, 'rename', path.toString());
-            return;
-        }
-        const dirs = [];
-        for (let dir = resolved, origDir = path; !(await fs.exists(dir)); dir = dirname(dir), origDir = dirname(origDir)) {
-            dirs.unshift(dir);
-            errorPaths[dir] = origDir;
-        }
-        for (const dir of dirs) {
-            if (config.checkAccess && !(await fs.stat(dirname(dir))).hasAccess(constants.W_OK, this)) {
-                throw ErrnoError.With('EACCES', dirname(dir), 'mkdir');
-            }
-            await fs.mkdir(dir, mode, { uid, gid });
-            await applySetId(await fs.openFile(dir, 'r+'), uid, gid);
-            emitChange(this, 'rename', dir);
-        }
-        return root.length == 1 ? dirs[0] : (_b = dirs[0]) === null || _b === void 0 ? void 0 : _b.slice(root.length);
+    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 === null || options === void 0 ? void 0 : options.recursive)) {
+        await __create(path, resolved, await fs.stat(dirname(resolved)).catch(rethrow({ path: dirname(path) })));
+        return;
     }
-    catch (e) {
-        throw fixError(e, errorPaths);
+    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];
 }
 mkdir;
 export async function readdir(path, options) {
     options = typeof options === 'object' ? options : { encoding: options };
     path = await realpath.call(this, path);
     const { fs, path: resolved } = resolveMount(path, this);
-    const stats = await fs.stat(resolved).catch((e) => _throw(fixError(e, { [resolved]: path })));
-    if (!stats) {
-        throw ErrnoError.With('ENOENT', path, 'readdir');
-    }
-    if (config.checkAccess && !stats.hasAccess(constants.R_OK, this)) {
-        throw ErrnoError.With('EACCES', path, 'readdir');
-    }
-    if (!stats.isDirectory()) {
-        throw ErrnoError.With('ENOTDIR', path, 'readdir');
-    }
-    const entries = await fs.readdir(resolved).catch((e) => _throw(fixError(e, { [resolved]: path })));
+    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 values = [];
     const addEntry = async (entry) => {
         let entryStats;
@@ -631,7 +756,7 @@ export async function readdir(path, options) {
             entryStats = await fs.stat(join(resolved, entry)).catch((e) => {
                 if (e.code == 'ENOENT')
                     return;
-                throw fixError(e, { [resolved]: path });
+                throw setUVMessage(Object.assign(e, { syscall: 'stat', path: join(path, entry) }));
             });
             if (!entryStats)
                 return;
@@ -645,7 +770,7 @@ export async function readdir(path, options) {
         else {
             values.push(entry);
         }
-        if (!(options === null || options === void 0 ? void 0 : options.recursive) || !(entryStats === null || entryStats === void 0 ? void 0 : entryStats.isDirectory()))
+        if (!(options === null || options === void 0 ? void 0 : options.recursive) || !isDirectory(entryStats))
             return;
         for (const subEntry of await readdir.call(this, join(path, entry), options)) {
             if (subEntry instanceof Dirent) {
@@ -665,49 +790,42 @@ export async function readdir(path, options) {
     return values;
 }
 readdir;
-export async function link(targetPath, linkPath) {
-    targetPath = normalizePath(targetPath);
-    linkPath = normalizePath(linkPath);
-    const { fs, path } = resolveMount(targetPath, this);
-    const link = resolveMount(linkPath, this);
-    if (fs != link.fs) {
-        throw ErrnoError.With('EXDEV', linkPath, 'link');
-    }
-    try {
-        if (config.checkAccess && !(await fs.stat(dirname(targetPath))).hasAccess(constants.R_OK, this)) {
-            throw ErrnoError.With('EACCES', dirname(path), 'link');
-        }
-        if (config.checkAccess && !(await stat.call(this, dirname(linkPath))).hasAccess(constants.W_OK, this)) {
-            throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
-        }
-        if (config.checkAccess && !(await fs.stat(path)).hasAccess(constants.R_OK, this)) {
-            throw ErrnoError.With('EACCES', path, 'link');
-        }
-        return await fs.link(path, link.path);
-    }
-    catch (e) {
-        throw fixError(e, { [link.path]: linkPath, [path]: targetPath });
-    }
+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));
 }
 link;
 /**
  * `symlink`.
- * @param target target path
+ * @param dest target path
  * @param path link path
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
-export async function symlink(target, path, type = 'file') {
+export async function symlink(dest, path, type = 'file') {
     const env_5 = { stack: [], error: void 0, hasError: false };
     try {
-        if (!['file', 'dir', 'junction'].includes(type)) {
-            throw new ErrnoError(Errno.EINVAL, 'Invalid symlink type: ' + type);
-        }
+        if (!['file', 'dir', 'junction'].includes(type))
+            throw new TypeError('Invalid symlink type: ' + type);
         path = normalizePath(path);
         if (await exists.call(this, path))
-            throw ErrnoError.With('EEXIST', path, 'symlink');
+            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(target, true));
-        await handle.file.chmod(constants.S_IFLNK);
+        await handle.writeFile(normalizePath(dest, true));
+        await handle.chmod(constants.S_IFLNK);
     }
     catch (e_5) {
         env_5.error = e_5;
@@ -723,7 +841,11 @@ symlink;
 export async function readlink(path, options) {
     const env_6 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_6, await _open(this, normalizePath(path), { flag: 'r', mode: 0o644, preserveSymlinks: true }), true);
+        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 === null || options === void 0 ? void 0 : options.encoding : options;
         // always defaults to utf-8 to avoid wrangler (cloudflare) worker "unknown encoding" exception
@@ -880,10 +1002,10 @@ async function _resolve($, path, preserveSymlinks) {
         const resolved = resolveMount(path, $);
         // Stat it to make sure it exists
         const stats = await resolved.fs.stat(resolved.path);
-        if (!stats.isSymbolicLink()) {
+        if (!isSymbolicLink(stats)) {
             return { ...resolved, fullPath: path, stats };
         }
-        const target = resolve(dirname(path), (await readlink.call($, path)).toString());
+        const target = resolve.call($, dirname(path), (await readlink.call($, path)).toString());
         return await _resolve($, target);
     }
     catch {
@@ -893,20 +1015,18 @@ async function _resolve($, path, preserveSymlinks) {
     const realDir = dir == '/' ? '/' : await realpath.call($, dir);
     const maybePath = join(realDir, base);
     const resolved = resolveMount(maybePath, $);
-    try {
-        const stats = await resolved.fs.stat(resolved.path);
-        if (!stats.isSymbolicLink()) {
-            return { ...resolved, fullPath: maybePath, stats };
-        }
-        const target = resolve(realDir, (await readlink.call($, maybePath)).toString());
-        return await _resolve($, target);
-    }
-    catch (e) {
-        if (e.code == 'ENOENT') {
-            return { ...resolved, fullPath: path };
-        }
-        throw fixError(e, { [resolved.path]: 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) {
     var _a;
@@ -959,12 +1079,11 @@ export function watch(filename, options = {}) {
 }
 watch;
 export async function access(path, mode = constants.F_OK) {
-    if (!config.checkAccess)
+    if (!checkAccess)
         return;
     const stats = await stat.call(this, path);
-    if (!stats.hasAccess(mode, this)) {
-        throw new ErrnoError(Errno.EACCES);
-    }
+    if (!stats.hasAccess(mode, this))
+        throw UV('EACCES', 'access', path.toString());
 }
 access;
 /**
@@ -998,7 +1117,7 @@ export async function rm(path, options) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
+            throw UV('ENOSYS', 'rm', path);
     }
 }
 rm;
@@ -1020,9 +1139,8 @@ mkdtemp;
 export async function copyFile(src, dest, mode) {
     src = normalizePath(src);
     dest = normalizePath(dest);
-    if (mode && mode & constants.COPYFILE_EXCL && (await exists.call(this, dest))) {
-        throw new ErrnoError(Errno.EEXIST, 'Destination file already exists', dest, 'copyFile');
-    }
+    if (mode && mode & constants.COPYFILE_EXCL && (await exists.call(this, dest)))
+        throw UV('EEXIST', 'copyFile', dest);
     await writeFile.call(this, dest, await readFile.call(this, src));
     emitChange(this, 'rename', dest.toString());
 }
@@ -1055,14 +1173,12 @@ export async function cp(source, destination, opts) {
     source = normalizePath(source);
     destination = normalizePath(destination);
     const srcStats = await lstat.call(this, source); // Use lstat to follow symlinks if not dereferencing
-    if ((opts === null || opts === void 0 ? void 0 : opts.errorOnExist) && (await exists.call(this, destination))) {
-        throw new ErrnoError(Errno.EEXIST, 'Destination file or directory already exists', destination, 'cp');
-    }
+    if ((opts === null || opts === void 0 ? void 0 : opts.errorOnExist) && (await exists.call(this, destination)))
+        throw UV('EEXIST', 'cp', destination);
     switch (srcStats.mode & constants.S_IFMT) {
         case constants.S_IFDIR: {
-            if (!(opts === null || opts === void 0 ? void 0 : opts.recursive)) {
-                throw new ErrnoError(Errno.EISDIR, source + ' is a directory (not copied)', source, 'cp');
-            }
+            if (!(opts === null || opts === void 0 ? void 0 : opts.recursive))
+                throw UV('EISDIR', 'cp', source);
             const [entries] = await Promise.all([
                 readdir.call(this, source, { withFileTypes: true }),
                 mkdir.call(this, destination, { recursive: true }),
@@ -1086,7 +1202,7 @@ export async function cp(source, destination, opts) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            throw new ErrnoError(Errno.EPERM, 'File type not supported', source, 'rm');
+            throw UV('ENOSYS', 'cp', source);
     }
     // Optionally preserve timestamps
     if (opts === null || opts === void 0 ? void 0 : opts.preserveTimestamps) {