@zenfs/core 1.11.4 → 2.1.0

package/dist/vfs/sync.js

@@ -51,39 +51,59 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { Buffer } from 'buffer';
-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 { BigIntStats } from '../stats.js';
-import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
-import { config } from './config.js';
+import { Errno, Exception, setUVMessage, UV } from 'kerium';
+import { decodeUTF8, encodeUTF8 } from 'utilium';
+import { defaultContext } from '../internal/contexts.js';
+import { wrap } from '../internal/error.js';
+import { hasAccess, isDirectory, isSymbolicLink } from '../internal/inode.js';
+import { dirname, join, parse, resolve } from '../path.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 { BigIntStats, Stats } from './stats.js';
 import { emitChange } from './watchers.js';
 export function renameSync(oldPath, newPath) {
     oldPath = normalizePath(oldPath);
+    __assertType(oldPath);
     newPath = normalizePath(newPath);
-    const oldMount = resolveMount(oldPath, this);
-    const newMount = resolveMount(newPath, this);
-    if (config.checkAccess && !statSync.call(this, dirname(oldPath)).hasAccess(constants.W_OK, this)) {
-        throw ErrnoError.With('EACCES', oldPath, 'rename');
+    __assertType(newPath);
+    const src = resolveMount(oldPath, this);
+    const dst = resolveMount(newPath, this);
+    const $ex = { syscall: 'rename', path: oldPath, dest: newPath };
+    if (src.fs !== dst.fs)
+        throw UV('EXDEV', $ex);
+    if (dst.path.startsWith(src.path + '/'))
+        throw UV('EBUSY', $ex);
+    const oldStats = statSync.call(this, oldPath);
+    const oldParent = statSync.call(this, dirname(oldPath));
+    const newParent = statSync.call(this, dirname(newPath));
+    let newStats;
+    try {
+        newStats = statSync.call(this, newPath);
     }
+    catch (e) {
+        setUVMessage(Object.assign(e, $ex));
+        if (e.code != 'ENOENT')
+            throw e;
+    }
+    if (checkAccess && (!oldParent.hasAccess(constants.R_OK, this) || !newParent.hasAccess(constants.W_OK, this)))
+        throw UV('EACCES', $ex);
+    if (newStats && !isDirectory(oldStats) && isDirectory(newStats))
+        throw UV('EISDIR', $ex);
+    if (newStats && isDirectory(oldStats) && !isDirectory(newStats))
+        throw UV('ENOTDIR', $ex);
     try {
-        if (oldMount === newMount) {
-            oldMount.fs.renameSync(oldMount.path, newMount.path);
-            emitChange(this, 'rename', oldPath.toString());
-            emitChange(this, 'change', newPath.toString());
-            return;
-        }
-        writeFileSync.call(this, newPath, readFileSync(oldPath));
-        unlinkSync.call(this, oldPath);
-        emitChange(this, 'rename', oldPath.toString());
+        src.fs.renameSync(src.path, dst.path);
     }
     catch (e) {
-        throw fixError(e, { [oldMount.path]: oldPath, [newMount.path]: newPath });
+        throw setUVMessage(Object.assign(e, $ex));
     }
+    emitChange(this, 'rename', oldPath);
+    emitChange(this, 'change', newPath);
 }
 renameSync;
 /**
@@ -96,9 +116,8 @@ export function existsSync(path) {
         return fs.existsSync(resolvedPath);
     }
     catch (e) {
-        if (e.errno == Errno.ENOENT) {
+        if (e.errno == Errno.ENOENT)
             return false;
-        }
         throw e;
     }
 }
@@ -106,28 +125,25 @@ existsSync;
 export function statSync(path, options) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
+    let stats;
     try {
-        const stats = fs.statSync(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;
+        stats = fs.statSync(resolved);
     }
     catch (e) {
-        throw fixError(e, { [resolved]: path });
+        throw setUVMessage(Object.assign(e, { path }));
     }
+    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
+        throw UV('EACCES', { syscall: 'stat', path });
+    return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new Stats(stats);
 }
 statSync;
 export function lstatSync(path, options) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
-    try {
-        const stats = fs.statSync(resolved);
-        return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : stats;
-    }
-    catch (e) {
-        throw fixError(e, { [resolved]: path });
-    }
+    const stats = wrap(fs, 'statSync', path)(resolved);
+    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
+        throw UV('EACCES', { syscall: 'lstat', path });
+    return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new Stats(stats);
 }
 lstatSync;
 export function truncateSync(path, len = 0) {
@@ -135,10 +151,9 @@ export function truncateSync(path, len = 0) {
     try {
         const file = __addDisposableResource(env_1, _openSync.call(this, path, { flag: 'r+' }), false);
         len || (len = 0);
-        if (len < 0) {
-            throw new ErrnoError(Errno.EINVAL);
-        }
-        file.truncateSync(len);
+        if (len < 0)
+            throw UV('EINVAL', 'truncate', path.toString());
+        file.truncate(len);
     }
     catch (e_1) {
         env_1.error = e_1;
@@ -153,31 +168,21 @@ export function unlinkSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     try {
-        if (config.checkAccess && !fs.statSync(resolved).hasAccess(constants.W_OK, this)) {
-            throw ErrnoError.With('EACCES', resolved, 'unlink');
+        if (checkAccess && !hasAccess(this, fs.statSync(resolved), constants.W_OK)) {
+            throw UV('EACCES', 'unlink');
         }
         fs.unlinkSync(resolved);
-        emitChange(this, 'rename', path.toString());
     }
     catch (e) {
-        throw fixError(e, { [resolved]: path });
+        throw setUVMessage(Object.assign(e, { path }));
     }
+    emitChange(this, 'rename', path.toString());
 }
 unlinkSync;
-/**
- * Manually apply setuid/setgid.
- */
-function applySetId(file, uid, gid) {
-    if (file.fs.attributes.has('setid'))
-        return;
-    const parent = file.fs.statSync(dirname(file.path));
-    file.chownSync(parent.mode & constants.S_ISUID ? parent.uid : uid, // manually apply setuid/setgid
-    parent.mode & constants.S_ISGID ? parent.gid : gid);
-}
 function _openSync(path, opt) {
     var _a;
     path = normalizePath(path);
-    const mode = normalizeMode(opt.mode, 0o644), flag = parseFlag(opt.flag);
+    const mode = normalizeMode(opt.mode, 0o644), flag = flags.parse(opt.flag);
     path = opt.preserveSymlinks ? path : realpathSync.call(this, path);
     const { fs, path: resolved } = resolveMount(path, this);
     let stats;
@@ -188,44 +193,49 @@ function _openSync(path, opt) {
         // nothing
     }
     if (!stats) {
-        if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
-            throw ErrnoError.With('ENOENT', path, '_open');
+        if (!(flag & constants.O_CREAT)) {
+            throw UV('ENOENT', 'open', path);
         }
         // Create the file
         const parentStats = fs.statSync(dirname(resolved));
-        if (config.checkAccess && !parentStats.hasAccess(constants.W_OK, this)) {
-            throw ErrnoError.With('EACCES', dirname(path), '_open');
+        if (checkAccess && !hasAccess(this, parentStats, constants.W_OK)) {
+            throw UV('EACCES', 'open', path);
         }
-        if (!parentStats.isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
+        if (!isDirectory(parentStats)) {
+            throw UV('ENOTDIR', 'open', path);
         }
-        const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : credentials;
-        const file = fs.createFileSync(resolved, flag, mode, { uid, gid });
         if (!opt.allowDirectory && mode & constants.S_IFDIR)
-            throw ErrnoError.With('EISDIR', path, '_open');
-        applySetId(file, uid, gid);
-        return file;
-    }
-    if (config.checkAccess && (!stats.hasAccess(mode, this) || !stats.hasAccess(flagToMode(flag), this))) {
-        throw ErrnoError.With('EACCES', path, '_open');
-    }
-    if (isExclusive(flag)) {
-        throw ErrnoError.With('EEXIST', path, '_open');
-    }
-    const file = fs.openFileSync(resolved, flag);
-    if (isTruncating(flag)) {
-        file.truncateSync(0);
-    }
+            throw UV('EISDIR', 'open', path);
+        if (checkAccess && !hasAccess(this, parentStats, constants.W_OK)) {
+            throw UV('EACCES', 'open', path);
+        }
+        const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : defaultContext.credentials;
+        const inode = fs.createFileSync(resolved, {
+            mode,
+            uid: parentStats.mode & constants.S_ISUID ? parentStats.uid : uid,
+            gid: parentStats.mode & constants.S_ISGID ? parentStats.gid : gid,
+        });
+        return new SyncHandle(this, path, fs, resolved, flag, inode);
+    }
+    if (checkAccess && (!hasAccess(this, stats, mode) || !hasAccess(this, stats, flags.toMode(flag)))) {
+        throw UV('EACCES', 'open', path);
+    }
+    if (flag & constants.O_EXCL)
+        throw UV('EEXIST', 'open', path);
+    const file = new SyncHandle(this, path, fs, resolved, flag, stats);
     if (!opt.allowDirectory && stats.mode & constants.S_IFDIR)
-        throw ErrnoError.With('EISDIR', path, '_open');
+        throw UV('EISDIR', 'open', path);
+    if (flag & constants.O_TRUNC)
+        file.truncate(0);
     return file;
 }
 /**
  * Synchronous file open.
- * @see http://www.manpagez.com/man/2/open/
+ * @see https://nodejs.org/api/fs.html#fsopensyncpath-flags-mode
+ * @param flag {@link https://nodejs.org/api/fs.html#file-system-flags}
  */
 export function openSync(path, flag, mode = constants.F_OK) {
-    return file2fd(_openSync.call(this, path, { flag, mode }));
+    return toFD(_openSync.call(this, path, { flag, mode }));
 }
 openSync;
 /**
@@ -233,19 +243,22 @@ openSync;
  * @internal
  */
 export function lopenSync(path, flag, mode) {
-    return file2fd(_openSync.call(this, path, { flag, mode, preserveSymlinks: true }));
+    return toFD(_openSync.call(this, path, { flag, mode, preserveSymlinks: true }));
 }
-function _readFileSync(path, flag, preserveSymlinks) {
+export function readFileSync(path, _options = {}) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
-        path = normalizePath(path);
-        // Get file.
-        const file = __addDisposableResource(env_2, _openSync.call(this, path, { flag, mode: 0o644, preserveSymlinks }), false);
-        const stat = file.statSync();
-        // Allocate buffer.
-        const data = new Uint8Array(stat.size);
-        file.readSync(data, 0, stat.size, 0);
-        return data;
+        const options = normalizeOptions(_options, null, 'r', 0o644);
+        const flag = flags.parse(options.flag);
+        if (flag & constants.O_WRONLY)
+            throw UV('EBADF', 'read', path.toString());
+        const file = __addDisposableResource(env_2, typeof path == 'number'
+            ? fromFD(this, path)
+            : _openSync.call(this, path.toString(), { flag: options.flag, mode: 0o644, preserveSymlinks: false }), false);
+        const { size } = file.stat();
+        const data = Buffer.alloc(size);
+        file.read(data, 0, size, 0);
+        return options.encoding ? data.toString(options.encoding) : data;
     }
     catch (e_2) {
         env_2.error = e_2;
@@ -255,37 +268,30 @@ function _readFileSync(path, flag, preserveSymlinks) {
         __disposeResources(env_2);
     }
 }
-export function readFileSync(path, _options = {}) {
-    const options = normalizeOptions(_options, null, 'r', 0o644);
-    const flag = parseFlag(options.flag);
-    if (!isReadable(flag)) {
-        throw new ErrnoError(Errno.EINVAL, 'Flag passed to readFile must allow for reading');
-    }
-    const data = Buffer.from(_readFileSync.call(this, typeof path == 'number' ? fd2file(path).path : path, options.flag, false));
-    return options.encoding ? data.toString(options.encoding) : data;
-}
 readFileSync;
 export function writeFileSync(path, data, _options = {}) {
     const env_3 = { stack: [], error: void 0, hasError: false };
     try {
         const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
-        const flag = parseFlag(options.flag);
-        if (!isWriteable(flag)) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed to writeFile must allow for writing');
+        const flag = flags.parse(options.flag);
+        if (!(flag & constants.O_WRONLY || flag & constants.O_RDWR)) {
+            throw new Exception(Errno.EINVAL, 'Flag passed to writeFile must allow for writing');
         }
         if (typeof data != 'string' && !options.encoding) {
-            throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
+            throw new Exception(Errno.EINVAL, 'Encoding not specified');
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
         if (!encodedData) {
-            throw new ErrnoError(Errno.EINVAL, 'Data not specified');
-        }
-        const file = __addDisposableResource(env_3, _openSync.call(this, typeof path == 'number' ? fd2file(path).path : path.toString(), {
-            flag,
-            mode: options.mode,
-            preserveSymlinks: true,
-        }), false);
-        file.writeSync(encodedData, 0, encodedData.byteLength, 0);
+            throw new Exception(Errno.EINVAL, 'Data not specified');
+        }
+        const file = __addDisposableResource(env_3, typeof path == 'number'
+            ? fromFD(this, path)
+            : _openSync.call(this, path.toString(), {
+                flag,
+                mode: options.mode,
+                preserveSymlinks: true,
+            }), false);
+        file.write(encodedData, 0, encodedData.byteLength, 0);
         emitChange(this, 'change', path.toString());
     }
     catch (e_3) {
@@ -307,20 +313,20 @@ export function appendFileSync(filename, 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');
+        const flag = flags.parse(options.flag);
+        if (!(flag & constants.O_APPEND)) {
+            throw new Exception(Errno.EINVAL, 'Flag passed to appendFile must allow for appending');
         }
         if (typeof data != 'string' && !options.encoding) {
-            throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
+            throw new Exception(Errno.EINVAL, 'Encoding not specified');
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-        const file = __addDisposableResource(env_4, _openSync.call(this, typeof filename == 'number' ? fd2file(filename).path : filename.toString(), {
+        const file = __addDisposableResource(env_4, _openSync.call(this, typeof filename == 'number' ? fromFD(this, filename).path : filename.toString(), {
             flag,
             mode: options.mode,
             preserveSymlinks: true,
         }), false);
-        file.writeSync(encodedData, 0, encodedData.byteLength);
+        file.write(encodedData, 0, encodedData.byteLength);
     }
     catch (e_4) {
         env_4.error = e_4;
@@ -332,29 +338,29 @@ export function appendFileSync(filename, data, _options = {}) {
 }
 appendFileSync;
 export function fstatSync(fd, options) {
-    const stats = fd2file(fd).statSync();
-    return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : stats;
+    const stats = fromFD(this, fd).stat();
+    return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new Stats(stats);
 }
 fstatSync;
 export function closeSync(fd) {
-    fd2file(fd).closeSync();
-    fdMap.delete(fd);
+    fromFD(this, fd).close();
+    deleteFD(this, fd);
 }
 closeSync;
 export function ftruncateSync(fd, len = 0) {
     len || (len = 0);
     if (len < 0) {
-        throw new ErrnoError(Errno.EINVAL);
+        throw new Exception(Errno.EINVAL);
     }
-    fd2file(fd).truncateSync(len);
+    fromFD(this, fd).truncate(len);
 }
 ftruncateSync;
 export function fsyncSync(fd) {
-    fd2file(fd).syncSync();
+    fromFD(this, fd).sync();
 }
 fsyncSync;
 export function fdatasyncSync(fd) {
-    fd2file(fd).datasyncSync();
+    fromFD(this, fd).datasync();
 }
 fdatasyncSync;
 export function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
@@ -374,9 +380,9 @@ export function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
         length = lenOrEnc;
         position = typeof pos === 'number' ? pos : null;
     }
-    const file = fd2file(fd);
+    const file = fromFD(this, fd);
     position !== null && position !== void 0 ? position : (position = file.position);
-    const bytesWritten = file.writeSync(buffer, offset, length, position);
+    const bytesWritten = file.write(buffer, offset, length, position);
     emitChange(this, 'change', file.path);
     return bytesWritten;
 }
@@ -390,7 +396,7 @@ writeSync;
  * If position is null, data will be read from the current file position.
  */
 export function readSync(fd, buffer, options, length, position) {
-    const file = fd2file(fd);
+    const file = fromFD(this, fd);
     const offset = typeof options == 'object' ? options.offset : options;
     if (typeof options == 'object') {
         length = options.length;
@@ -400,102 +406,85 @@ export function readSync(fd, buffer, options, length, position) {
     if (isNaN(position)) {
         position = file.position;
     }
-    return file.readSync(buffer, offset, length, position);
+    return file.read(buffer, offset, length, position);
 }
 readSync;
 export function fchownSync(fd, uid, gid) {
-    fd2file(fd).chownSync(uid, gid);
+    fromFD(this, fd).chown(uid, gid);
 }
 fchownSync;
 export function fchmodSync(fd, mode) {
     const numMode = normalizeMode(mode, -1);
     if (numMode < 0) {
-        throw new ErrnoError(Errno.EINVAL, `Invalid mode.`);
+        throw new Exception(Errno.EINVAL, `Invalid mode.`);
     }
-    fd2file(fd).chmodSync(numMode);
+    fromFD(this, fd).chmod(numMode);
 }
 fchmodSync;
 /**
  * Change the file timestamps of a file referenced by the supplied file descriptor.
  */
 export function futimesSync(fd, atime, mtime) {
-    fd2file(fd).utimesSync(normalizeTime(atime), normalizeTime(mtime));
+    fromFD(this, fd).utimes(normalizeTime(atime), normalizeTime(mtime));
 }
 futimesSync;
 export function rmdirSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
-    try {
-        const stats = fs.statSync(resolved);
-        if (!stats.isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
-        }
-        if (config.checkAccess && !stats.hasAccess(constants.W_OK, this)) {
-            throw ErrnoError.With('EACCES', resolved, 'rmdir');
-        }
-        fs.rmdirSync(resolved);
-        emitChange(this, 'rename', path.toString());
-    }
-    catch (e) {
-        throw fixError(e, { [resolved]: path });
-    }
+    const stats = wrap(fs, 'statSync', path)(resolved);
+    if (!isDirectory(stats))
+        throw UV('ENOTDIR', 'rmdir', path);
+    if (checkAccess && !hasAccess(this, stats, constants.W_OK))
+        throw UV('EACCES', 'rmdir', path);
+    wrap(fs, 'rmdirSync', path)(resolved);
+    emitChange(this, 'rename', path.toString());
 }
 rmdirSync;
 export function mkdirSync(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 = realpathSync.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 && !fs.statSync(dirname(resolved)).hasAccess(constants.W_OK, this)) {
-                throw ErrnoError.With('EACCES', dirname(resolved), 'mkdir');
-            }
-            fs.mkdirSync(resolved, mode, { uid, gid });
-            applySetId(fs.openFileSync(resolved, 'r+'), uid, gid);
-            return;
-        }
-        const dirs = [];
-        for (let dir = resolved, original = path; !fs.existsSync(dir); dir = dirname(dir), original = dirname(original)) {
-            dirs.unshift(dir);
-            errorPaths[dir] = original;
-        }
-        for (const dir of dirs) {
-            if (config.checkAccess && !fs.statSync(dirname(dir)).hasAccess(constants.W_OK, this)) {
-                throw ErrnoError.With('EACCES', dirname(dir), 'mkdir');
-            }
-            fs.mkdirSync(dir, mode, { uid, gid });
-            applySetId(fs.openFileSync(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 = (path, resolved, parent) => {
+        if (checkAccess && !hasAccess(this, parent, constants.W_OK))
+            throw UV('EACCES', 'mkdir', dirname(path));
+        const inode = wrap(fs, 'mkdirSync', path)(resolved, {
+            mode,
+            uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
+            gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
+        });
+        emitChange(this, 'rename', path);
+        return inode;
+    };
+    if (!(options === null || options === void 0 ? void 0 : options.recursive)) {
+        __create(path, resolved, wrap(fs, 'statSync', dirname(path))(dirname(resolved)));
+        return;
     }
-    catch (e) {
-        throw fixError(e, errorPaths);
+    const dirs = [];
+    for (let dir = resolved, original = path; !wrap(fs, 'existsSync', original)(dir); dir = dirname(dir), original = dirname(original)) {
+        dirs.unshift({ resolved: dir, original });
     }
+    if (!dirs.length)
+        return;
+    const stats = [wrap(fs, 'statSync', dirname(dirs[0].original))(dirname(dirs[0].resolved))];
+    for (const [i, dir] of dirs.entries()) {
+        stats.push(__create(dir.original, dir.resolved, stats[i]));
+    }
+    return dirs[0].original;
 }
 mkdirSync;
 export function readdirSync(path, options) {
     options = typeof options === 'object' ? options : { encoding: options };
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
-    let entries;
-    try {
-        const stats = fs.statSync(resolved);
-        if (config.checkAccess && !stats.hasAccess(constants.R_OK, this)) {
-            throw ErrnoError.With('EACCES', resolved, 'readdir');
-        }
-        if (!stats.isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', resolved, 'readdir');
-        }
-        entries = fs.readdirSync(resolved);
-    }
-    catch (e) {
-        throw fixError(e, { [resolved]: path });
-    }
+    const stats = wrap(fs, 'statSync', path)(resolved);
+    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
+        throw UV('EACCES', 'readdir', path);
+    if (!isDirectory(stats))
+        throw UV('ENOTDIR', 'readdir', path);
+    const entries = wrap(fs, 'readdirSync', path)(resolved);
     // Iterate over entries and handle recursive case if needed
     const values = [];
     for (const entry of entries) {
@@ -515,7 +504,7 @@ export function readdirSync(path, options) {
         else {
             values.push(entry);
         }
-        if (!entryStat.isDirectory() || !(options === null || options === void 0 ? void 0 : options.recursive))
+        if (!isDirectory(entryStat) || !(options === null || options === void 0 ? void 0 : options.recursive))
             continue;
         for (const subEntry of readdirSync.call(this, join(path, entry), options)) {
             if (subEntry instanceof Dirent) {
@@ -535,27 +524,22 @@ export function readdirSync(path, options) {
 readdirSync;
 export function linkSync(targetPath, linkPath) {
     targetPath = normalizePath(targetPath);
-    if (config.checkAccess && !statSync(dirname(targetPath)).hasAccess(constants.R_OK, this)) {
-        throw ErrnoError.With('EACCES', dirname(targetPath), 'link');
+    if (checkAccess && !statSync(dirname(targetPath)).hasAccess(constants.R_OK, this)) {
+        throw UV('EACCES', 'link', dirname(targetPath));
     }
     linkPath = normalizePath(linkPath);
-    if (config.checkAccess && !statSync(dirname(linkPath)).hasAccess(constants.W_OK, this)) {
-        throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
+    if (checkAccess && !statSync(dirname(linkPath)).hasAccess(constants.W_OK, this)) {
+        throw UV('EACCES', 'link', dirname(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 && !fs.statSync(path).hasAccess(constants.R_OK, this)) {
-            throw ErrnoError.With('EACCES', path, 'link');
-        }
-        return fs.linkSync(path, link.path);
-    }
-    catch (e) {
-        throw fixError(e, { [path]: targetPath, [link.path]: linkPath });
+        throw UV('EXDEV', 'link', linkPath);
     }
+    const stats = wrap(fs, 'statSync', targetPath)(path);
+    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
+        throw UV('EACCES', 'link', path);
+    return wrap(fs, 'linkSync', targetPath, linkPath)(path, link.path);
 }
 linkSync;
 /**
@@ -565,49 +549,71 @@ linkSync;
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
 export function symlinkSync(target, path, type = 'file') {
-    if (!['file', 'dir', 'junction'].includes(type)) {
-        throw new ErrnoError(Errno.EINVAL, 'Invalid type: ' + type);
+    const env_5 = { stack: [], error: void 0, hasError: false };
+    try {
+        if (!['file', 'dir', 'junction'].includes(type))
+            throw new TypeError('Invalid symlink type: ' + type);
+        path = normalizePath(path);
+        const file = __addDisposableResource(env_5, _openSync.call(this, path, { flag: 'wx', mode: 0o644 }), false);
+        file.write(encodeUTF8(normalizePath(target, true)));
+        file.chmod(constants.S_IFLNK);
     }
-    if (existsSync.call(this, path)) {
-        throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
+    catch (e_5) {
+        env_5.error = e_5;
+        env_5.hasError = true;
+    }
+    finally {
+        __disposeResources(env_5);
     }
-    writeFileSync.call(this, path, normalizePath(target, true));
-    const file = _openSync.call(this, path, { flag: 'r+', mode: 0o644, preserveSymlinks: true });
-    file.chmodSync(constants.S_IFLNK);
 }
 symlinkSync;
 export function readlinkSync(path, options) {
-    const value = Buffer.from(_readFileSync.call(this, path, 'r', true));
-    const encoding = typeof options == 'object' ? options === null || options === void 0 ? void 0 : options.encoding : options;
-    if (encoding == 'buffer') {
-        return value;
+    const env_6 = { stack: [], error: void 0, hasError: false };
+    try {
+        const handle = __addDisposableResource(env_6, _openSync.call(this, normalizePath(path), { flag: 'r', mode: 0o644, preserveSymlinks: true }), false);
+        if (!isSymbolicLink(handle.inode))
+            throw new Exception(Errno.EINVAL, 'Not a symbolic link: ' + path);
+        const size = handle.inode.size;
+        const data = Buffer.alloc(size);
+        handle.read(data, 0, size, 0);
+        const encoding = typeof options == 'object' ? options === null || options === void 0 ? void 0 : options.encoding : options;
+        if (encoding == 'buffer') {
+            return data;
+        }
+        // always defaults to utf-8 to avoid wrangler (cloudflare) worker "unknown encoding" exception
+        return data.toString(encoding !== null && encoding !== void 0 ? encoding : 'utf-8');
+    }
+    catch (e_6) {
+        env_6.error = e_6;
+        env_6.hasError = true;
+    }
+    finally {
+        __disposeResources(env_6);
     }
-    // always defaults to utf-8 to avoid wrangler (cloudflare) worker "unknown encoding" exception
-    return value.toString(encoding !== null && encoding !== void 0 ? encoding : 'utf-8');
 }
 readlinkSync;
 export function chownSync(path, uid, gid) {
     const fd = openSync.call(this, path, 'r+');
-    fchownSync(fd, uid, gid);
-    closeSync(fd);
+    fchownSync.call(this, fd, uid, gid);
+    closeSync.call(this, fd);
 }
 chownSync;
 export function lchownSync(path, uid, gid) {
     const fd = lopenSync.call(this, path, 'r+');
-    fchownSync(fd, uid, gid);
-    closeSync(fd);
+    fchownSync.call(this, fd, uid, gid);
+    closeSync.call(this, fd);
 }
 lchownSync;
 export function chmodSync(path, mode) {
     const fd = openSync.call(this, path, 'r+');
-    fchmodSync(fd, mode);
-    closeSync(fd);
+    fchmodSync.call(this, fd, mode);
+    closeSync.call(this, fd);
 }
 chmodSync;
 export function lchmodSync(path, mode) {
     const fd = lopenSync.call(this, path, 'r+');
-    fchmodSync(fd, mode);
-    closeSync(fd);
+    fchmodSync.call(this, fd, mode);
+    closeSync.call(this, fd);
 }
 lchmodSync;
 /**
@@ -615,8 +621,8 @@ lchmodSync;
  */
 export function utimesSync(path, atime, mtime) {
     const fd = openSync.call(this, path, 'r+');
-    futimesSync(fd, atime, mtime);
-    closeSync(fd);
+    futimesSync.call(this, fd, atime, mtime);
+    closeSync.call(this, fd);
 }
 utimesSync;
 /**
@@ -624,8 +630,8 @@ utimesSync;
  */
 export function lutimesSync(path, atime, mtime) {
     const fd = lopenSync.call(this, path, 'r+');
-    futimesSync(fd, atime, mtime);
-    closeSync(fd);
+    futimesSync.call(this, fd, atime, mtime);
+    closeSync.call(this, fd);
 }
 lutimesSync;
 /**
@@ -645,10 +651,10 @@ function _resolveSync($, path, preserveSymlinks) {
         const resolved = resolveMount(path, $);
         // Stat it to make sure it exists
         const stats = resolved.fs.statSync(resolved.path);
-        if (!stats.isSymbolicLink()) {
+        if (!isSymbolicLink(stats)) {
             return { ...resolved, fullPath: path, stats };
         }
-        const target = resolve(dirname(path), readlinkSync.call($, path).toString());
+        const target = resolve.call($, dirname(path), readlinkSync.call($, path).toString());
         return _resolveSync($, target);
     }
     catch {
@@ -658,20 +664,20 @@ function _resolveSync($, path, preserveSymlinks) {
     const realDir = dir == '/' ? '/' : realpathSync.call($, dir);
     const maybePath = join(realDir, base);
     const resolved = resolveMount(maybePath, $);
+    let stats;
     try {
-        const stats = resolved.fs.statSync(resolved.path);
-        if (!stats.isSymbolicLink()) {
-            return { ...resolved, fullPath: maybePath, stats };
-        }
-        const target = resolve(realDir, readlinkSync.call($, maybePath).toString());
-        return _resolveSync($, target);
+        stats = resolved.fs.statSync(resolved.path);
     }
     catch (e) {
-        if (e.code == 'ENOENT') {
+        if (e.code === 'ENOENT')
             return { ...resolved, fullPath: path };
-        }
-        throw fixError(e, { [resolved.path]: maybePath });
+        throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath }));
     }
+    if (!isSymbolicLink(stats)) {
+        return { ...resolved, fullPath: maybePath, stats };
+    }
+    const target = resolve.call($, realDir, readlinkSync.call($, maybePath).toString());
+    return _resolveSync($, target);
 }
 export function realpathSync(path, options) {
     var _a;
@@ -687,10 +693,10 @@ export function realpathSync(path, options) {
 }
 realpathSync;
 export function accessSync(path, mode = 0o600) {
-    if (!config.checkAccess)
+    if (!checkAccess)
         return;
-    if (!statSync.call(this, path).hasAccess(mode, this)) {
-        throw new ErrnoError(Errno.EACCES);
+    if (!hasAccess(this, statSync.call(this, path), mode)) {
+        throw new Exception(Errno.EACCES);
     }
 }
 accessSync;
@@ -728,7 +734,7 @@ export function rmSync(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);
     }
 }
 rmSync;
@@ -748,9 +754,8 @@ mkdtempSync;
 export function copyFileSync(source, destination, flags) {
     source = normalizePath(source);
     destination = normalizePath(destination);
-    if (flags && flags & constants.COPYFILE_EXCL && existsSync(destination)) {
-        throw new ErrnoError(Errno.EEXIST, 'Destination file already exists', destination, 'copyFile');
-    }
+    if (flags && flags & constants.COPYFILE_EXCL && existsSync(destination))
+        throw UV('EEXIST', 'copyFile', destination);
     writeFileSync.call(this, destination, readFileSync(source));
     emitChange(this, 'rename', destination.toString());
 }
@@ -763,10 +768,10 @@ copyFileSync;
  * @returns The number of bytes read.
  */
 export function readvSync(fd, buffers, position) {
-    const file = fd2file(fd);
+    const file = fromFD(this, fd);
     let bytesRead = 0;
     for (const buffer of buffers) {
-        bytesRead += file.readSync(buffer, 0, buffer.byteLength, position + bytesRead);
+        bytesRead += file.read(buffer, 0, buffer.byteLength, position + bytesRead);
     }
     return bytesRead;
 }
@@ -779,10 +784,10 @@ readvSync;
  * @returns The number of bytes written.
  */
 export function writevSync(fd, buffers, position) {
-    const file = fd2file(fd);
+    const file = fromFD(this, fd);
     let bytesWritten = 0;
     for (const buffer of buffers) {
-        bytesWritten += file.writeSync(new Uint8Array(buffer.buffer), 0, buffer.byteLength, position + bytesWritten);
+        bytesWritten += file.write(new Uint8Array(buffer.buffer), 0, buffer.byteLength, position + bytesWritten);
     }
     return bytesWritten;
 }
@@ -815,14 +820,12 @@ export function cpSync(source, destination, opts) {
     source = normalizePath(source);
     destination = normalizePath(destination);
     const srcStats = lstatSync.call(this, source); // Use lstat to follow symlinks if not dereferencing
-    if ((opts === null || opts === void 0 ? void 0 : opts.errorOnExist) && existsSync.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) && existsSync.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);
             mkdirSync.call(this, destination, { recursive: true }); // Ensure the destination directory exists
             for (const dirent of readdirSync.call(this, source, { withFileTypes: true })) {
                 if (opts.filter && !opts.filter(join(source, dirent.name), join(destination, dirent.name))) {
@@ -840,7 +843,7 @@ export function cpSync(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) {