@zenfs/core 2.4.0 → 2.4.2

package/dist/vfs/sync.js

@@ -1,189 +1,67 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { Buffer } from 'buffer';
-import { Errno, Exception, setUVMessage, UV } from 'kerium';
-import { encodeUTF8 } from 'utilium';
+import { setUVMessage, UV } from 'kerium';
+import { decodeUTF8 } from 'utilium';
+import * as constants from '../constants.js';
 import { defaultContext } from '../internal/contexts.js';
-import { wrap } from '../internal/error.js';
 import { hasAccess, isDirectory, isSymbolicLink } from '../internal/inode.js';
-import { basename, dirname, join, matchesGlob, parse, resolve } from '../path.js';
-import { __assertType, _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { basename, dirname, join, parse, resolve as resolvePath } from '../path.js';
+import { normalizeMode, normalizePath } 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 { Dirent, ifToDt } from './dir.js';
+import { Handle } from './file.js';
 import * as flags from './flags.js';
-import { _statfs, resolveMount } from './shared.js';
-import { BigIntStats, Stats } from './stats.js';
+import { resolveMount } from './shared.js';
 import { emitChange } from './watchers.js';
-export function renameSync(oldPath, newPath) {
-    oldPath = normalizePath(oldPath);
-    __assertType(oldPath);
-    newPath = normalizePath(newPath);
-    __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 {
-        src.fs.renameSync(src.path, dst.path);
-    }
-    catch (e) {
-        throw setUVMessage(Object.assign(e, $ex));
-    }
-    emitChange(this, 'rename', oldPath);
-    emitChange(this, 'change', newPath);
-}
-renameSync;
 /**
- * Test whether or not `path` exists by checking with the file system.
+ * Resolves the mount and real path for a path.
+ * Additionally, any stats fetched will be returned for de-duplication
+ * @category VFS
+ * @internal @hidden
  */
-export function existsSync(path) {
-    path = normalizePath(path);
+export function resolve($, path, preserveSymlinks, extra) {
+    /* Try to resolve it directly. If this works,
+    that means we don't need to perform any resolution for parent directories. */
     try {
-        const { fs, path: resolvedPath } = resolveMount(realpathSync.call(this, path), this);
-        return fs.existsSync(resolvedPath);
+        const resolved = resolveMount(path, $);
+        // Stat it to make sure it exists
+        const stats = resolved.fs.statSync(resolved.path);
+        if (!isSymbolicLink(stats) || preserveSymlinks) {
+            return { ...resolved, fullPath: path, stats };
+        }
+        const target = resolvePath.call($, dirname(path), readlink.call($, path));
+        return resolve($, target, preserveSymlinks, extra);
     }
     catch (e) {
-        if (e.errno == Errno.ENOENT)
-            return false;
-        throw e;
+        setUVMessage(Object.assign(e, { syscall: 'stat', path }));
+        if (preserveSymlinks)
+            throw e;
     }
-}
-existsSync;
-export function statSync(path, options) {
-    path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
+    const { base, dir } = parse(path);
+    const realDir = dir == '/' ? '/' : resolve($, dir, false, extra).fullPath;
+    const maybePath = join(realDir, base);
+    const resolved = resolveMount(maybePath, $);
     let stats;
     try {
-        stats = fs.statSync(resolved);
+        stats = resolved.fs.statSync(resolved.path);
     }
     catch (e) {
-        throw setUVMessage(Object.assign(e, { path }));
-    }
-    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
-        throw UV('EACCES', { syscall: 'stat', path });
-    return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
-}
-statSync;
-export function lstatSync(path, options) {
-    path = normalizePath(path);
-    const real = join(realpathSync.call(this, dirname(path)), basename(path));
-    const { fs, path: resolved } = resolveMount(real, this);
-    const stats = wrap(fs, 'statSync', path)(resolved);
-    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
-        throw UV('EACCES', { syscall: 'lstat', path });
-    return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
-}
-lstatSync;
-export function truncateSync(path, len = 0) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        const file = __addDisposableResource(env_1, _openSync.call(this, path, { flag: 'r+' }), false);
-        len ||= 0;
-        if (len < 0)
-            throw UV('EINVAL', 'truncate', path.toString());
-        file.truncate(len);
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        __disposeResources(env_1);
-    }
-}
-truncateSync;
-export function unlinkSync(path) {
-    path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(path, this);
-    try {
-        if (checkAccess && !hasAccess(this, fs.statSync(resolved), constants.W_OK)) {
-            throw UV('EACCES', 'unlink');
-        }
-        fs.unlinkSync(resolved);
+        if (e.code === 'ENOENT')
+            return { ...resolved, fullPath: path };
+        throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath }));
     }
-    catch (e) {
-        throw setUVMessage(Object.assign(e, { path }));
+    if (!isSymbolicLink(stats)) {
+        return { ...resolved, fullPath: maybePath, stats };
     }
-    emitChange(this, 'rename', path.toString());
+    const target = resolvePath.call($, realDir, readlink.call($, maybePath));
+    return resolve($, target, false, extra);
 }
-unlinkSync;
-function _openSync(path, opt) {
+/**
+ * @category VFS
+ * @internal
+ */
+export function open(path, opt) {
     path = normalizePath(path);
     const mode = normalizeMode(opt.mode, 0o644), flag = flags.parse(opt.flag);
-    path = opt.preserveSymlinks ? path : realpathSync.call(this, path);
+    path = opt.preserveSymlinks ? path : resolve(this, path).fullPath;
     const { fs, path: resolved } = resolveMount(path, this);
     let stats;
     try {
@@ -215,241 +93,43 @@ function _openSync(path, opt) {
             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);
+        return new Handle(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);
+    const file = new Handle(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);
+        file.truncateSync(0);
     return file;
 }
-/**
- * Synchronous file 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 toFD(_openSync.call(this, path, { flag, mode }));
-}
-openSync;
-/**
- * Opens a file or symlink
- * @internal
- */
-export function lopenSync(path, flag, mode) {
-    return toFD(_openSync.call(this, path, { flag, mode, preserveSymlinks: true }));
-}
-export function readFileSync(path, _options = {}) {
-    const env_2 = { stack: [], error: void 0, hasError: false };
-    try {
-        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;
-        env_2.hasError = true;
-    }
-    finally {
-        __disposeResources(env_2);
-    }
-}
-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 = 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 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 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) {
-        env_3.error = e_3;
-        env_3.hasError = true;
-    }
-    finally {
-        __disposeResources(env_3);
-    }
-}
-writeFileSync;
-/**
- * Asynchronously append data to a file, creating the file if it not yet exists.
- * @option encoding Defaults to `'utf8'`.
- * @option mode Defaults to `0644`.
- * @option flag Defaults to `'a+'`.
- */
-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 = 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 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(), {
-            flag,
-            mode: options.mode,
-            preserveSymlinks: true,
-        }), false);
-        file.write(encodedData, 0, encodedData.byteLength);
-    }
-    catch (e_4) {
-        env_4.error = e_4;
-        env_4.hasError = true;
-    }
-    finally {
-        __disposeResources(env_4);
-    }
-}
-appendFileSync;
-export function fstatSync(fd, options) {
-    const stats = fromFD(this, fd).stat();
-    return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
-}
-fstatSync;
-export function closeSync(fd) {
-    fromFD(this, fd).close();
-    deleteFD(this, fd);
-}
-closeSync;
-export function ftruncateSync(fd, len = 0) {
-    len ||= 0;
-    if (len < 0) {
-        throw new Exception(Errno.EINVAL);
-    }
-    fromFD(this, fd).truncate(len);
-}
-ftruncateSync;
-export function fsyncSync(fd) {
-    fromFD(this, fd).sync();
-}
-fsyncSync;
-export function fdatasyncSync(fd) {
-    fromFD(this, fd).datasync();
-}
-fdatasyncSync;
-export function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
-    let buffer, offset, length, position;
-    if (typeof data === 'string') {
-        // Signature 1: (fd, string, [position?, [encoding?]])
-        position = typeof posOrOff === 'number' ? posOrOff : null;
-        const encoding = typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8';
-        offset = 0;
-        buffer = Buffer.from(data, encoding);
-        length = buffer.byteLength;
-    }
-    else {
-        // Signature 2: (fd, buffer, offset, length, position?)
-        buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-        offset = posOrOff;
-        length = lenOrEnc;
-        position = typeof pos === 'number' ? pos : null;
-    }
-    const file = fromFD(this, fd);
-    position ??= file.position;
-    const bytesWritten = file.write(buffer, offset, length, position);
-    emitChange(this, 'change', file.path);
-    return bytesWritten;
-}
-writeSync;
-/**
- * Read data from the file specified by `fd`.
- * @param buffer The buffer that the data will be written to.
- * @param offset The offset within the buffer where writing will start.
- * @param length An integer specifying the number of bytes to read.
- * @param position An integer specifying where to begin reading from in the file.
- * If position is null, data will be read from the current file position.
- */
-export function readSync(fd, buffer, options, length, position) {
-    const file = fromFD(this, fd);
-    const offset = typeof options == 'object' ? options.offset : options;
-    if (typeof options == 'object') {
-        length = options.length;
-        position = options.position;
-    }
-    position = Number(position);
-    if (isNaN(position)) {
-        position = file.position;
-    }
-    return file.read(buffer, offset, length, position);
-}
-readSync;
-export function fchownSync(fd, uid, gid) {
-    fromFD(this, fd).chown(uid, gid);
-}
-fchownSync;
-export function fchmodSync(fd, mode) {
-    const numMode = normalizeMode(mode, -1);
-    if (numMode < 0) {
-        throw new Exception(Errno.EINVAL, `Invalid mode.`);
-    }
-    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) {
-    fromFD(this, fd).utimes(normalizeTime(atime), normalizeTime(mtime));
-}
-futimesSync;
-export function rmdirSync(path) {
+export function readlink(path) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
-    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) {
+    const { fs, stats, path: resolved } = resolve(this, path, true);
+    if (!stats)
+        throw UV('ENOENT', 'readlink', path);
+    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
+        throw UV('EACCES', 'readlink', path);
+    if (!isSymbolicLink(stats))
+        throw UV('EINVAL', 'readlink', path);
+    const size = stats.size;
+    const data = new Uint8Array(size);
+    fs.readSync(resolved, data, 0, size);
+    return decodeUTF8(data);
+}
+export function mkdir(path, options = {}) {
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolve(this, path);
     const { euid: uid, egid: gid } = this?.credentials ?? defaultContext.credentials;
-    options = typeof options === 'object' ? options : { mode: options };
-    const mode = normalizeMode(options?.mode, 0o777);
-    path = realpathSync.call(this, path);
-    const { fs, path: resolved } = resolveMount(path, this);
+    const { mode = 0o777, recursive } = options;
     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, {
+        const inode = fs.mkdirSync(resolved, {
             mode,
             uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
             gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
@@ -457,33 +137,31 @@ export function mkdirSync(path, options) {
         emitChange(this, 'rename', path);
         return inode;
     };
-    if (!options?.recursive) {
-        __create(path, resolved, wrap(fs, 'statSync', dirname(path))(dirname(resolved)));
+    if (!recursive) {
+        __create(path, resolved, fs.statSync(dirname(resolved)));
         return;
     }
     const dirs = [];
-    for (let dir = resolved, original = path; !wrap(fs, 'existsSync', original)(dir); dir = dirname(dir), original = dirname(original)) {
+    for (let dir = resolved, original = path; !fs.existsSync(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))];
+    const stats = [fs.statSync(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 };
+export function readdir(path, options = {}) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(realpathSync.call(this, path), this);
-    const stats = wrap(fs, 'statSync', path)(resolved);
+    const { fs, path: resolved } = resolve(this, path);
+    const stats = fs.statSync(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);
+    const entries = fs.readdirSync(resolved);
     // Iterate over entries and handle recursive case if needed
     const values = [];
     const addEntry = (entry) => {
@@ -494,20 +172,17 @@ export function readdirSync(path, options) {
         catch (e) {
             if (e.code == 'ENOENT')
                 return;
-            throw setUVMessage(Object.assign(e, { syscall: 'stat', path: join(path, entry) }));
-        }
-        if (options?.withFileTypes) {
-            values.push(Dirent.from(entry, entryStat, options.encoding));
-        }
-        else if (options?.encoding == 'buffer') {
-            values.push(Buffer.from(entry));
-        }
-        else {
-            values.push(entry);
+            throw e;
         }
+        const ent = new Dirent();
+        ent.ino = entryStat.ino;
+        ent.type = ifToDt(entryStat.mode);
+        ent.path = entry;
+        ent.name = basename(entry);
+        values.push(ent);
         if (!isDirectory(entryStat) || !options?.recursive)
             return;
-        const children = wrap(fs, 'readdirSync', join(path, entry))(join(resolved, entry));
+        const children = fs.readdirSync(join(resolved, entry));
         for (const child of children)
             addEntry(join(entry, child));
     };
@@ -515,376 +190,57 @@ export function readdirSync(path, options) {
         addEntry(entry);
     return values;
 }
-readdirSync;
-export function linkSync(targetPath, linkPath) {
-    targetPath = normalizePath(targetPath);
-    if (checkAccess && !statSync(dirname(targetPath)).hasAccess(constants.R_OK, this)) {
-        throw UV('EACCES', 'link', dirname(targetPath));
-    }
-    linkPath = normalizePath(linkPath);
-    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 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;
-/**
- * Synchronous `symlink`.
- * @param target target path
- * @param path link path
- * @param type can be either `'dir'` or `'file'` (default is `'file'`)
- */
-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 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);
-    }
-    catch (e_5) {
-        env_5.error = e_5;
-        env_5.hasError = true;
-    }
-    finally {
-        __disposeResources(env_5);
-    }
-}
-symlinkSync;
-export function readlinkSync(path, options) {
-    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?.encoding : options;
-        if (encoding == 'buffer') {
-            return data;
-        }
-        // always defaults to utf-8 to avoid wrangler (cloudflare) worker "unknown encoding" exception
-        return data.toString(encoding ?? 'utf-8');
-    }
-    catch (e_6) {
-        env_6.error = e_6;
-        env_6.hasError = true;
-    }
-    finally {
-        __disposeResources(env_6);
-    }
-}
-readlinkSync;
-export function chownSync(path, uid, gid) {
-    const fd = openSync.call(this, path, 'r+');
-    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.call(this, fd, uid, gid);
-    closeSync.call(this, fd);
-}
-lchownSync;
-export function chmodSync(path, mode) {
-    const fd = openSync.call(this, path, 'r+');
-    fchmodSync.call(this, fd, mode);
-    closeSync.call(this, fd);
-}
-chmodSync;
-export function lchmodSync(path, mode) {
-    const fd = lopenSync.call(this, path, 'r+');
-    fchmodSync.call(this, fd, mode);
-    closeSync.call(this, fd);
-}
-lchmodSync;
-/**
- * Change file timestamps of the file referenced by the supplied path.
- */
-export function utimesSync(path, atime, mtime) {
-    const fd = openSync.call(this, path, 'r+');
-    futimesSync.call(this, fd, atime, mtime);
-    closeSync.call(this, fd);
-}
-utimesSync;
-/**
- * Change file timestamps of the file referenced by the supplied path.
- */
-export function lutimesSync(path, atime, mtime) {
-    const fd = lopenSync.call(this, path, 'r+');
-    futimesSync.call(this, fd, atime, mtime);
-    closeSync.call(this, fd);
-}
-lutimesSync;
-/**
- * Resolves the mount and real path for a path.
- * Additionally, any stats fetched will be returned for de-duplication
- * @internal @hidden
- */
-function _resolveSync($, path, preserveSymlinks) {
-    if (preserveSymlinks) {
-        const resolved = resolveMount(path, $);
-        const stats = resolved.fs.statSync(resolved.path);
-        return { ...resolved, fullPath: path, stats };
-    }
-    /* Try to resolve it directly. If this works,
-    that means we don't need to perform any resolution for parent directories. */
-    try {
-        const resolved = resolveMount(path, $);
-        // Stat it to make sure it exists
-        const stats = resolved.fs.statSync(resolved.path);
-        if (!isSymbolicLink(stats)) {
-            return { ...resolved, fullPath: path, stats };
-        }
-        const target = resolve.call($, dirname(path), readlinkSync.call($, path).toString());
-        return _resolveSync($, target);
-    }
-    catch {
-        // Go the long way
-    }
-    const { base, dir } = parse(path);
-    const realDir = dir == '/' ? '/' : realpathSync.call($, dir);
-    const maybePath = join(realDir, base);
-    const resolved = resolveMount(maybePath, $);
-    let stats;
+export function rename(oldPath, newPath) {
+    oldPath = normalizePath(oldPath);
+    newPath = normalizePath(newPath);
+    const $ex = { syscall: 'rename', path: oldPath, dest: newPath };
+    const src = resolve(this, oldPath, true, $ex);
+    const dst = resolveMount(newPath, this, $ex);
+    if (src.fs.uuid !== dst.fs.uuid)
+        throw UV('EXDEV', $ex);
+    if (dst.path.startsWith(src.path + '/'))
+        throw UV('EBUSY', $ex);
+    if (!src.stats)
+        throw UV('ENOENT', $ex);
+    const fs = src.fs;
+    const oldParent = fs.statSync(dirname(src.path));
+    const newParent = fs.statSync(dirname(dst.path));
+    let newStats;
     try {
-        stats = resolved.fs.statSync(resolved.path);
+        newStats = fs.statSync(dst.path);
     }
     catch (e) {
-        if (e.code === 'ENOENT')
-            return { ...resolved, fullPath: path };
-        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) {
-    const encoding = typeof options == 'string' ? options : (options?.encoding ?? 'utf8');
-    path = normalizePath(path);
-    const { fullPath } = _resolveSync(this, path);
-    if (encoding == 'utf8' || encoding == 'utf-8')
-        return fullPath;
-    const buf = Buffer.from(fullPath, 'utf-8');
-    if (encoding == 'buffer')
-        return buf;
-    return buf.toString(encoding);
-}
-realpathSync;
-export function accessSync(path, mode = 0o600) {
-    if (!checkAccess)
-        return;
-    if (!hasAccess(this, statSync.call(this, path), mode)) {
-        throw new Exception(Errno.EACCES);
-    }
-}
-accessSync;
-/**
- * Synchronous `rm`. Removes files or directories (recursively).
- * @param path The path to the file or directory to remove.
- */
-export function rmSync(path, options) {
-    path = normalizePath(path);
-    let stats;
-    try {
-        stats = lstatSync.bind(this)(path);
-    }
-    catch (error) {
-        if (error.code != 'ENOENT' || !options?.force)
-            throw error;
-    }
-    if (!stats)
-        return;
-    switch (stats.mode & constants.S_IFMT) {
-        case constants.S_IFDIR:
-            if (options?.recursive) {
-                for (const entry of readdirSync.call(this, path)) {
-                    rmSync.call(this, join(path, entry), options);
-                }
-            }
-            rmdirSync.call(this, path);
-            break;
-        case constants.S_IFREG:
-        case constants.S_IFLNK:
-        case constants.S_IFBLK:
-        case constants.S_IFCHR:
-            unlinkSync.call(this, path);
-            break;
-        case constants.S_IFIFO:
-        case constants.S_IFSOCK:
-        default:
-            throw UV('ENOSYS', 'rm', path);
-    }
-}
-rmSync;
-export function mkdtempSync(prefix, options) {
-    const encoding = typeof options === 'object' ? options?.encoding : options || 'utf8';
-    const path = _tempDirName(prefix);
-    mkdirSync.call(this, path);
-    return encoding == 'buffer' ? Buffer.from(path) : path;
-}
-mkdtempSync;
-/**
- * Returns a disposable object whose `path` property holds the created directory path.
- * When the object is disposed, the directory and its contents will be removed if it still exists.
- * If the directory cannot be deleted, disposal will throw an error.
- * The object has a `remove()` method which will perform the same task.
- * @todo Add `satisfies` and maybe change return type once @types/node adds this.
- */
-export function mkdtempDisposableSync(prefix, options) {
-    const path = _tempDirName(prefix);
-    mkdirSync.call(this, path);
-    const remove = () => rmSync(path, { recursive: true, force: true });
-    return { path, remove, [Symbol.dispose]: remove };
-}
-/**
- * Synchronous `copyFile`. Copies a file.
- * @param flags Optional flags for the copy operation. Currently supports these flags:
- * - `fs.constants.COPYFILE_EXCL`: If the destination file already exists, the operation fails.
- */
-export function copyFileSync(source, destination, flags) {
-    source = normalizePath(source);
-    destination = normalizePath(destination);
-    if (flags && flags & constants.COPYFILE_EXCL && existsSync(destination))
-        throw UV('EEXIST', 'copyFile', destination);
-    writeFileSync.call(this, destination, readFileSync(source));
-    emitChange(this, 'rename', destination.toString());
-}
-copyFileSync;
-/**
- * Synchronous `readv`. Reads from a file descriptor into multiple buffers.
- * @param fd The file descriptor.
- * @param buffers An array of Uint8Array buffers.
- * @param position The position in the file where to begin reading.
- * @returns The number of bytes read.
- */
-export function readvSync(fd, buffers, position) {
-    const file = fromFD(this, fd);
-    let bytesRead = 0;
-    for (const buffer of buffers) {
-        bytesRead += file.read(buffer, 0, buffer.byteLength, position + bytesRead);
-    }
-    return bytesRead;
-}
-readvSync;
-/**
- * Synchronous `writev`. Writes from multiple buffers into a file descriptor.
- * @param fd The file descriptor.
- * @param buffers An array of Uint8Array buffers.
- * @param position The position in the file where to begin writing.
- * @returns The number of bytes written.
- */
-export function writevSync(fd, buffers, position) {
-    const file = fromFD(this, fd);
-    let bytesWritten = 0;
-    for (const buffer of buffers) {
-        bytesWritten += file.write(new Uint8Array(buffer.buffer), 0, buffer.byteLength, position + bytesWritten);
-    }
-    return bytesWritten;
-}
-writevSync;
-/**
- * Synchronous `opendir`. Opens a directory.
- * @param path The path to the directory.
- * @param options Options for opening the directory.
- * @returns A `Dir` object representing the opened directory.
- * @todo Handle options
- */
-export function opendirSync(path, options) {
-    path = normalizePath(path);
-    return new Dir(path, this);
-}
-opendirSync;
-/**
- * Synchronous `cp`. Recursively copies a file or directory.
- * @param source The source file or directory.
- * @param destination The destination file or directory.
- * @param opts Options for the copy operation. Currently supports these options from Node.js 'fs.cpSync':
- * - `dereference`: Dereference symbolic links. *(unconfirmed)*
- * - `errorOnExist`: Throw an error if the destination file or directory already exists.
- * - `filter`: A function that takes a source and destination path and returns a boolean, indicating whether to copy `source` element.
- * - `force`: Overwrite the destination if it exists, and overwrite existing readonly destination files. *(unconfirmed)*
- * - `preserveTimestamps`: Preserve file timestamps.
- * - `recursive`: If `true`, copies directories recursively.
- */
-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?.errorOnExist && existsSync.call(this, destination))
-        throw UV('EEXIST', 'cp', destination);
-    switch (srcStats.mode & constants.S_IFMT) {
-        case constants.S_IFDIR:
-            if (!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))) {
-                    continue; // Skip if the filter returns false
-                }
-                cpSync.call(this, join(source, dirent.name), join(destination, dirent.name), opts);
-            }
-            break;
-        case constants.S_IFREG:
-        case constants.S_IFLNK:
-            copyFileSync.call(this, source, destination);
-            break;
-        case constants.S_IFBLK:
-        case constants.S_IFCHR:
-        case constants.S_IFIFO:
-        case constants.S_IFSOCK:
-        default:
-            throw UV('ENOSYS', 'cp', source);
-    }
-    // Optionally preserve timestamps
-    if (opts?.preserveTimestamps) {
-        utimesSync.call(this, destination, srcStats.atime, srcStats.mtime);
+        if (e.code != 'ENOENT')
+            throw e;
     }
+    if (checkAccess && (!hasAccess(this, oldParent, constants.R_OK) || !hasAccess(this, newParent, constants.W_OK)))
+        throw UV('EACCES', $ex);
+    if (newStats && !isDirectory(src.stats) && isDirectory(newStats))
+        throw UV('EISDIR', $ex);
+    if (newStats && isDirectory(src.stats) && !isDirectory(newStats))
+        throw UV('ENOTDIR', $ex);
+    src.fs.renameSync(src.path, dst.path);
+    emitChange(this, 'rename', oldPath);
+    emitChange(this, 'change', newPath);
 }
-cpSync;
-export function statfsSync(path, options) {
-    path = normalizePath(path);
-    const { fs } = resolveMount(path, this);
-    return _statfs(fs, options?.bigint);
-}
-export function globSync(pattern, options = {}) {
-    pattern = Array.isArray(pattern) ? pattern : [pattern];
-    const { cwd = '/', withFileTypes = false, exclude = () => false } = options;
-    // Escape special characters in pattern
-    const regexPatterns = pattern.map(globToRegex);
-    const results = [];
-    function recursiveList(dir) {
-        const entries = readdirSync(dir, { withFileTypes, encoding: 'utf8' });
-        for (const entry of entries) {
-            const fullPath = withFileTypes ? join(entry.parentPath, entry.name) : dir + '/' + entry;
-            if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, fullPath)) : exclude((withFileTypes ? entry : fullPath)))
-                continue;
-            /**
-             * @todo is the pattern.source check correct?
-             */
-            if (statSync(fullPath).isDirectory() && regexPatterns.some(pattern => pattern.source.includes('.*'))) {
-                recursiveList(fullPath);
-            }
-            if (regexPatterns.some(pattern => pattern.test(fullPath.replace(/^\/+/g, '')))) {
-                results.push(withFileTypes ? entry : fullPath.replace(/^\/+/g, ''));
-            }
-        }
-    }
-    recursiveList(cwd);
-    return results;
+export function link(target, link) {
+    target = normalizePath(target);
+    link = normalizePath(link);
+    const $ex = { syscall: 'link', path: link, dest: target };
+    const { fs, path: resolved } = resolveMount(target, this, $ex);
+    const dst = resolveMount(link, this, $ex);
+    if (fs.uuid !== dst.fs.uuid)
+        throw UV('EXDEV', $ex);
+    const stats = fs.statSync(resolved);
+    if (checkAccess) {
+        if (!hasAccess(this, stats, constants.R_OK))
+            throw UV('EACCES', $ex);
+        const dirStats = fs.statSync(dirname(resolved));
+        if (!hasAccess(this, dirStats, constants.R_OK))
+            throw UV('EACCES', $ex);
+        const destStats = fs.statSync(dirname(dst.path));
+        if (!hasAccess(this, destStats, constants.W_OK))
+            throw UV('EACCES', $ex);
+    }
+    return fs.linkSync(resolved, dst.path);
 }
-globSync;