@zenfs/core 2.0.0 → 2.1.0

package/dist/vfs/promises.js

@@ -51,20 +51,20 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { Buffer } from 'buffer';
-import { _throw, decodeUTF8, pick } from 'utilium';
+import { Exception, rethrow, setUVMessage, UV } from 'kerium';
+import { decodeUTF8, pick } from 'utilium';
 import { defaultContext } from '../internal/contexts.js';
-import { Errno, ErrnoError } from '../internal/error.js';
 import { hasAccess, InodeFlags, isBlockDevice, isCharacterDevice, isDirectory, isSymbolicLink } from '../internal/inode.js';
 import { dirname, join, parse, resolve } from '../path.js';
 import '../polyfills.js';
 import { createInterface } from '../readline.js';
-import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.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 { deleteFD, fromFD, SyncHandle, toFD } from './file.js';
 import * as flags from './flags.js';
-import { _statfs, fixError, resolveMount } from './shared.js';
+import { _statfs, resolveMount } from './shared.js';
 import { _chown, BigIntStats, Stats } from './stats.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { emitChange, FSWatcher } from './watchers.js';
@@ -114,7 +114,7 @@ export class FileHandle {
      */
     async chown(uid, gid) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'chown');
+            throw UV('EBADF', 'chown', this.path);
         this.dirty = true;
         _chown(this.inode, uid, gid);
         if (this._isSync)
@@ -128,9 +128,9 @@ export class FileHandle {
     async chmod(mode) {
         const numMode = normalizeMode(mode, -1);
         if (numMode < 0)
-            throw new ErrnoError(Errno.EINVAL, 'Invalid mode');
+            throw UV('EINVAL', 'chmod', this.path);
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'chmod');
+            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)
@@ -148,7 +148,7 @@ export class FileHandle {
      */
     async sync() {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'sync');
+            throw UV('EBADF', 'sync', this.path);
         if (!this.dirty)
             return;
         if (!this.fs.attributes.has('no_write'))
@@ -161,13 +161,18 @@ export class FileHandle {
      */
     async truncate(length = 0) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'truncate');
+            throw UV('EBADF', 'truncate', this.path);
         if (length < 0)
-            throw new ErrnoError(Errno.EINVAL);
+            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 new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode', this.path, 'truncate');
-        }
+        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)
@@ -181,7 +186,7 @@ export class FileHandle {
      */
     async utimes(atime, mtime) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'utimes');
+            throw UV('EBADF', 'utimes', this.path);
         this.dirty = true;
         this.inode.atimeMs = normalizeTime(atime);
         this.inode.mtimeMs = normalizeTime(mtime);
@@ -201,12 +206,8 @@ export class FileHandle {
     async appendFile(data, _options = {}) {
         const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
         const flag = flags.parse(options.flag);
-        if (!(flag & constants.O_APPEND)) {
-            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');
-        }
+        if (!(flag & constants.O_APPEND))
+            throw UV('EBADF', 'write', this.path);
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
         await this._write(encodedData, 0, encodedData.length);
         this._emitChange();
@@ -221,10 +222,10 @@ export class FileHandle {
      */
     async _read(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'read');
+            throw UV('EBADF', 'read', this.path);
         if (this.flag & constants.O_WRONLY)
-            throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode');
-        if (!(this.inode.flags & InodeFlags.NoAtime)) {
+            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();
         }
@@ -259,11 +260,11 @@ export class FileHandle {
     async readFile(_options) {
         const options = normalizeOptions(_options, null, 'r', 0o444);
         const flag = flags.parse(options.flag);
-        if (flag & constants.O_WRONLY) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for reading', this.path, 'readFile');
-        }
+        if (flag & constants.O_WRONLY)
+            throw UV('EBADF', 'read', this.path);
         const { size } = await this.stat();
-        const { buffer: data } = await this._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;
     }
@@ -273,7 +274,7 @@ export class FileHandle {
      */
     readableWebStream(options = {}) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'readableWebStream');
+            throw UV('EBADF', 'readableWebStream', this.path);
         return this.fs.streamRead(this.internalPath, options);
     }
     /**
@@ -285,9 +286,9 @@ export class FileHandle {
      */
     writableWebStream(options = {}) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'writableWebStream');
+            throw UV('EBADF', 'writableWebStream', this.path);
         if (this.inode.flags & InodeFlags.Immutable)
-            throw new ErrnoError(Errno.EPERM, 'File is immutable', this.path, 'writableWebStream');
+            throw UV('EPERM', 'writableWebStream', this.path);
         return this.fs.streamWrite(this.internalPath, options);
     }
     /**
@@ -297,7 +298,7 @@ export class FileHandle {
      */
     readLines(options) {
         if (this.closed || this.flag & constants.O_WRONLY)
-            throw ErrnoError.With('EBADF', this.path, 'readLines');
+            throw UV('EBADF', 'read', this.path);
         return createInterface({ input: this.createReadStream(options), crlfDelay: Infinity });
     }
     [Symbol.asyncDispose]() {
@@ -305,10 +306,9 @@ export class FileHandle {
     }
     async stat(opts) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'stat');
-        if (checkAccess && !hasAccess(this.context, this.inode, constants.R_OK)) {
-            throw ErrnoError.With('EACCES', this.path, 'stat');
-        }
+            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);
     }
     /**
@@ -321,11 +321,13 @@ export class FileHandle {
      */
     async _write(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'write');
+            throw UV('EBADF', 'write', this.path);
         if (this.inode.flags & InodeFlags.Immutable)
-            throw new ErrnoError(Errno.EPERM, 'File is immutable', this.path, 'write');
+            throw UV('EPERM', 'write', this.path);
         if (!(this.flag & constants.O_WRONLY || this.flag & constants.O_RDWR))
-            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode', this.path, 'write');
+            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);
@@ -382,12 +384,8 @@ export class FileHandle {
     async writeFile(data, _options = {}) {
         const options = normalizeOptions(_options, 'utf8', 'w', 0o644);
         const flag = flags.parse(options.flag);
-        if (!(flag & constants.O_WRONLY || flag & constants.O_RDWR)) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for writing', this.path, 'writeFile');
-        }
-        if (typeof data != 'string' && !options.encoding) {
-            throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
-        }
+        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._write(encodedData, 0, encodedData.length, 0);
         this._emitChange();
@@ -397,7 +395,7 @@ export class FileHandle {
      */
     async close() {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'close');
+            throw UV('EBADF', 'close', this.path);
         await this.sync();
         this.dispose();
         deleteFD(this.context, this.fd);
@@ -407,9 +405,9 @@ export class FileHandle {
      */
     dispose(force) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'dispose');
+            throw UV('EBADF', 'close', this.path);
         if (this.dirty && !force)
-            throw ErrnoError.With('EBUSY', this.path, 'dispose');
+            throw UV('EBUSY', 'close', this.path);
         this.closed = true;
     }
     /**
@@ -448,7 +446,7 @@ export class FileHandle {
      */
     createReadStream(options = {}) {
         if (this.closed || this.flag & constants.O_WRONLY)
-            throw ErrnoError.With('EBADF', this.path, 'createReadStream');
+            throw UV('EBADF', 'createReadStream', this.path);
         return new ReadStream(options, this);
     }
     /**
@@ -457,34 +455,43 @@ export class FileHandle {
      */
     createWriteStream(options = {}) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'createWriteStream');
+            throw UV('EBADF', 'createWriteStream', this.path);
         if (this.inode.flags & InodeFlags.Immutable)
-            throw new ErrnoError(Errno.EPERM, 'File is immutable', this.path, 'createWriteStream');
+            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 (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;
 /**
@@ -496,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;
@@ -505,34 +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 (checkAccess && !hasAccess(this, stats, constants.R_OK)) {
-            throw ErrnoError.With('EACCES', resolved, 'stat');
-        }
-        return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new 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);
-        if (checkAccess && !hasAccess(this, stats, constants.R_OK)) {
-            throw ErrnoError.With('EACCES', resolved, 'lstat');
-        }
-        return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new 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 {
@@ -553,16 +549,12 @@ truncate;
 export async function unlink(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
-    try {
-        if (checkAccess && !hasAccess(this, await fs.stat(resolved), constants.W_OK)) {
-            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;
 /**
@@ -573,19 +565,19 @@ async function _open($, path, opt) {
     var _a;
     path = normalizePath(path);
     const mode = normalizeMode(opt.mode, 0o644), flag = flags.parse(opt.flag);
-    const { fullPath, fs, path: resolved, stats } = await _resolve($, path.toString(), opt.preserveSymlinks);
+    const $ex = { syscall: 'open', path };
+    const { fs, path: resolved, stats } = await _resolve($, path.toString(), opt.preserveSymlinks);
     if (!stats) {
-        if (!(flag & constants.O_CREAT)) {
-            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 (checkAccess && !hasAccess($, parentStats, constants.W_OK)) {
-            throw ErrnoError.With('EACCES', dirname(fullPath), '_open');
-        }
-        if (!isDirectory(parentStats)) {
-            throw ErrnoError.With('ENOTDIR', dirname(fullPath), '_open');
-        }
+        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,
@@ -594,18 +586,13 @@ async function _open($, path, opt) {
         });
         return new FileHandle($, toFD(new SyncHandle($, path, fs, resolved, flag, inode)));
     }
-    if (checkAccess && !hasAccess($, stats, flags.toMode(flag))) {
-        throw ErrnoError.With('EACCES', fullPath, '_open');
-    }
+    if (checkAccess && !hasAccess($, stats, flags.toMode(flag)))
+        throw UV('EACCES', $ex);
     if (flag & constants.O_EXCL)
-        throw ErrnoError.With('EEXIST', fullPath, '_open');
+        throw UV('EEXIST', $ex);
     const handle = new FileHandle($, toFD(new SyncHandle($, path, fs, resolved, flag, stats)));
-    /*
-        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 (!opt.allowDirectory && mode & constants.S_IFDIR)
+        throw UV('EISDIR', 'open', path);
     if (flag & constants.O_TRUNC)
         await handle.truncate(0);
     return handle;
@@ -652,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.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) {
@@ -679,12 +665,9 @@ export async function appendFile(path, data, _options) {
     try {
         const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
         const flag = flags.parse(options.flag);
-        if (!(flag & constants.O_APPEND)) {
-            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 $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);
@@ -703,77 +686,69 @@ appendFile;
 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 (!isDirectory(stats))
-            throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
-        if (checkAccess && !hasAccess(this, stats, constants.W_OK))
-            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;
+    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 };
-    const __create = async (path, parent) => {
+    const { fs, path: resolved } = resolveMount(path, this);
+    const __create = async (path, resolved, parent) => {
         if (checkAccess && !hasAccess(this, parent, constants.W_OK))
-            throw ErrnoError.With('EACCES', dirname(path), 'mkdir');
-        const inode = await fs.mkdir(path, {
+            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;
     };
-    try {
-        if (!(options === null || options === void 0 ? void 0 : options.recursive)) {
-            await __create(resolved, await fs.stat(dirname(resolved)));
-            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;
-        }
-        if (!dirs.length)
-            return;
-        const stats = [await fs.stat(dirname(dirs[0]))];
-        for (const [i, dir] of dirs.entries()) {
-            stats.push(await __create(dir, stats[i]));
-        }
-        return root.length == 1 ? dirs[0] : (_b = dirs[0]) === null || _b === void 0 ? void 0 : _b.slice(root.length);
+    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');
-    }
+    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 ErrnoError.With('EACCES', path, 'readdir');
+        throw UV('EACCES', $ex);
     if (!isDirectory(stats))
-        throw ErrnoError.With('ENOTDIR', path, 'readdir');
-    const entries = await fs.readdir(resolved).catch((e) => _throw(fixError(e, { [resolved]: path })));
+        throw UV('ENOTDIR', $ex);
+    const entries = await fs.readdir(resolved).catch(rethrow($ex));
     const values = [];
     const addEntry = async (entry) => {
         let entryStats;
@@ -781,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;
@@ -815,49 +790,41 @@ 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 (checkAccess && !hasAccess(this, await fs.stat(dirname(path)), constants.R_OK)) {
-            throw ErrnoError.With('EACCES', dirname(path), 'link');
-        }
-        // We need to use the VFS here since the link path may be a mount point
-        if (checkAccess && !(await stat.call(this, dirname(linkPath))).hasAccess(constants.W_OK, this)) {
-            throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
-        }
-        if (checkAccess && !hasAccess(this, await fs.stat(path), constants.R_OK)) {
-            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.writeFile(normalizePath(dest, true));
         await handle.chmod(constants.S_IFLNK);
     }
     catch (e_5) {
@@ -874,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
@@ -1044,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 (!isSymbolicLink(stats)) {
-            return { ...resolved, fullPath: maybePath, stats };
-        }
-        const target = resolve.call($, 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;
@@ -1113,9 +1082,8 @@ export async function access(path, mode = constants.F_OK) {
     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;
 /**
@@ -1149,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;
@@ -1171,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());
 }
@@ -1206,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 }),
@@ -1237,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) {