@zenfs/core 2.0.0 → 2.1.0

package/dist/vfs/sync.js

@@ -50,44 +50,60 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { deleteFD, fromFD, SyncHandle, toFD } from './file.js';
-import { Stats } from './stats.js';
 import { Buffer } from 'buffer';
+import { Errno, Exception, setUVMessage, UV } from 'kerium';
 import { decodeUTF8, encodeUTF8 } from 'utilium';
 import { defaultContext } from '../internal/contexts.js';
-import { Errno, ErrnoError } from '../internal/error.js';
+import { wrap } from '../internal/error.js';
 import { hasAccess, isDirectory, isSymbolicLink } from '../internal/inode.js';
 import { dirname, join, parse, resolve } from '../path.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 { BigIntStats } from './stats.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 (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;
 /**
@@ -100,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;
     }
 }
@@ -110,31 +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 (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);
+        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);
-        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 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) {
@@ -142,9 +151,8 @@ 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);
-        }
+        if (len < 0)
+            throw UV('EINVAL', 'truncate', path.toString());
         file.truncate(len);
     }
     catch (e_1) {
@@ -161,14 +169,14 @@ export function unlinkSync(path) {
     const { fs, path: resolved } = resolveMount(path, this);
     try {
         if (checkAccess && !hasAccess(this, fs.statSync(resolved), constants.W_OK)) {
-            throw ErrnoError.With('EACCES', resolved, 'unlink');
+            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;
 function _openSync(path, opt) {
@@ -186,20 +194,20 @@ function _openSync(path, opt) {
     }
     if (!stats) {
         if (!(flag & constants.O_CREAT)) {
-            throw ErrnoError.With('ENOENT', path, '_open');
+            throw UV('ENOENT', 'open', path);
         }
         // Create the file
         const parentStats = fs.statSync(dirname(resolved));
         if (checkAccess && !hasAccess(this, parentStats, constants.W_OK)) {
-            throw ErrnoError.With('EACCES', dirname(path), '_open');
+            throw UV('EACCES', 'open', path);
         }
         if (!isDirectory(parentStats)) {
-            throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
+            throw UV('ENOTDIR', 'open', path);
         }
         if (!opt.allowDirectory && mode & constants.S_IFDIR)
-            throw ErrnoError.With('EISDIR', path, '_open');
+            throw UV('EISDIR', 'open', path);
         if (checkAccess && !hasAccess(this, parentStats, constants.W_OK)) {
-            throw ErrnoError.With('EACCES', dirname(resolved), '_open');
+            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, {
@@ -210,15 +218,15 @@ function _openSync(path, opt) {
         return new SyncHandle(this, path, fs, resolved, flag, inode);
     }
     if (checkAccess && (!hasAccess(this, stats, mode) || !hasAccess(this, stats, flags.toMode(flag)))) {
-        throw ErrnoError.With('EACCES', path, '_open');
+        throw UV('EACCES', 'open', path);
     }
     if (flag & constants.O_EXCL)
-        throw ErrnoError.With('EEXIST', path, '_open');
+        throw UV('EEXIST', 'open', path);
     const file = new SyncHandle(this, path, fs, resolved, flag, stats);
+    if (!opt.allowDirectory && stats.mode & constants.S_IFDIR)
+        throw UV('EISDIR', 'open', path);
     if (flag & constants.O_TRUNC)
         file.truncate(0);
-    if (!opt.allowDirectory && stats.mode & constants.S_IFDIR)
-        throw ErrnoError.With('EISDIR', path, '_open');
     return file;
 }
 /**
@@ -237,14 +245,20 @@ openSync;
 export function lopenSync(path, flag, mode) {
     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 {
-        const file = __addDisposableResource(env_2, typeof path == 'number' ? fromFD(this, path) : _openSync.call(this, path.toString(), { flag, mode: 0o644, preserveSymlinks }), false);
+        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 = new Uint8Array(size);
+        const data = Buffer.alloc(size);
         file.read(data, 0, size, 0);
-        return data;
+        return options.encoding ? data.toString(options.encoding) : data;
     }
     catch (e_2) {
         env_2.error = e_2;
@@ -254,15 +268,6 @@ function _readFileSync(path, flag, preserveSymlinks) {
         __disposeResources(env_2);
     }
 }
-export function readFileSync(path, _options = {}) {
-    const options = normalizeOptions(_options, null, 'r', 0o644);
-    const flag = flags.parse(options.flag);
-    if (flag & constants.O_WRONLY) {
-        throw new ErrnoError(Errno.EINVAL, 'Flag passed to readFile must allow for reading');
-    }
-    const data = Buffer.from(_readFileSync.call(this, 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 };
@@ -270,14 +275,14 @@ export function writeFileSync(path, 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 to writeFile must allow for writing');
+            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');
+            throw new Exception(Errno.EINVAL, 'Data not specified');
         }
         const file = __addDisposableResource(env_3, typeof path == 'number'
             ? fromFD(this, path)
@@ -310,10 +315,10 @@ export function appendFileSync(filename, 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');
+            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' ? fromFD(this, filename).path : filename.toString(), {
@@ -345,7 +350,7 @@ closeSync;
 export function ftruncateSync(fd, len = 0) {
     len || (len = 0);
     if (len < 0) {
-        throw new ErrnoError(Errno.EINVAL);
+        throw new Exception(Errno.EINVAL);
     }
     fromFD(this, fd).truncate(len);
 }
@@ -411,7 +416,7 @@ 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.`);
     }
     fromFD(this, fd).chmod(numMode);
 }
@@ -426,35 +431,26 @@ 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 (!isDirectory(stats)) {
-            throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
-        }
-        if (checkAccess && !hasAccess(this, stats, constants.W_OK)) {
-            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;
+    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 };
-    const __create = (path, parent) => {
-        if (checkAccess && !hasAccess(this, parent, constants.W_OK)) {
-            throw ErrnoError.With('EACCES', dirname(path), 'mkdir');
-        }
-        const inode = fs.mkdirSync(path, {
+    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,
@@ -462,47 +458,33 @@ export function mkdirSync(path, options) {
         emitChange(this, 'rename', path);
         return inode;
     };
-    try {
-        if (!(options === null || options === void 0 ? void 0 : options.recursive)) {
-            __create(resolved, fs.statSync(dirname(resolved)));
-            return;
-        }
-        const dirs = [];
-        for (let dir = resolved, original = path; !fs.existsSync(dir); dir = dirname(dir), original = dirname(original)) {
-            dirs.unshift(dir);
-            errorPaths[dir] = original;
-        }
-        if (!dirs.length)
-            return;
-        const stats = [fs.statSync(dirname(dirs[0]))];
-        for (const [i, dir] of dirs.entries()) {
-            stats.push(__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)) {
+        __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 (checkAccess && !hasAccess(this, stats, constants.R_OK)) {
-            throw ErrnoError.With('EACCES', resolved, 'readdir');
-        }
-        if (!isDirectory(stats)) {
-            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) {
@@ -543,26 +525,21 @@ readdirSync;
 export function linkSync(targetPath, linkPath) {
     targetPath = normalizePath(targetPath);
     if (checkAccess && !statSync(dirname(targetPath)).hasAccess(constants.R_OK, this)) {
-        throw ErrnoError.With('EACCES', dirname(targetPath), 'link');
+        throw UV('EACCES', 'link', dirname(targetPath));
     }
     linkPath = normalizePath(linkPath);
     if (checkAccess && !statSync(dirname(linkPath)).hasAccess(constants.W_OK, this)) {
-        throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
+        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 (checkAccess && !hasAccess(this, fs.statSync(path), constants.R_OK)) {
-            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;
 /**
@@ -574,9 +551,8 @@ linkSync;
 export function symlinkSync(target, 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 type: ' + type);
-        }
+        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)));
@@ -592,13 +568,28 @@ export function symlinkSync(target, path, type = 'file') {
 }
 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) {
@@ -673,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 (!isSymbolicLink(stats)) {
-            return { ...resolved, fullPath: maybePath, stats };
-        }
-        const target = resolve.call($, 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;
@@ -705,7 +696,7 @@ export function accessSync(path, mode = 0o600) {
     if (!checkAccess)
         return;
     if (!hasAccess(this, statSync.call(this, path), mode)) {
-        throw new ErrnoError(Errno.EACCES);
+        throw new Exception(Errno.EACCES);
     }
 }
 accessSync;
@@ -743,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;
@@ -763,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());
 }
@@ -830,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))) {
@@ -855,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) {

package/dist/vfs/watchers.js

@@ -1,8 +1,8 @@
 import { EventEmitter } from 'eventemitter3';
-import { ErrnoError } from '../internal/error.js';
-import { isStatsEqual } from './stats.js';
-import { normalizePath } from '../utils.js';
+import { UV } from 'kerium';
 import { basename, dirname, join, relative } from '../path.js';
+import { normalizePath } from '../utils.js';
+import { isStatsEqual } from './stats.js';
 import { statSync } from './sync.js';
 /**
  * Base class for file system watchers.
@@ -29,19 +29,19 @@ class Watcher extends EventEmitter {
         this.path = path;
     }
     setMaxListeners() {
-        throw ErrnoError.With('ENOSYS', this.path, 'Watcher.setMaxListeners');
+        throw UV('ENOSYS', 'Watcher.setMaxListeners');
     }
     getMaxListeners() {
-        throw ErrnoError.With('ENOSYS', this.path, 'Watcher.getMaxListeners');
+        throw UV('ENOSYS', 'Watcher.getMaxListeners');
     }
     prependListener() {
-        throw ErrnoError.With('ENOSYS', this.path, 'Watcher.prependListener');
+        throw UV('ENOSYS', 'Watcher.prependListener');
     }
     prependOnceListener() {
-        throw ErrnoError.With('ENOSYS', this.path, 'Watcher.prependOnceListener');
+        throw UV('ENOSYS', 'Watcher.prependOnceListener');
     }
     rawListeners() {
-        throw ErrnoError.With('ENOSYS', this.path, 'Watcher.rawListeners');
+        throw UV('ENOSYS', 'Watcher.rawListeners');
     }
     ref() {
         return this;