@zenfs/core 1.1.3 → 1.1.4

package/dist/backends/overlay.js

@@ -141,7 +141,7 @@ export class UnmutexedOverlayFS extends FileSystem {
         try {
             await this.writable.rename(oldPath, newPath);
         }
-        catch (e) {
+        catch {
             if (this._deletedFiles.has(oldPath)) {
                 throw ErrnoError.With('ENOENT', oldPath, 'rename');
             }
@@ -155,7 +155,7 @@ export class UnmutexedOverlayFS extends FileSystem {
         try {
             this.writable.renameSync(oldPath, newPath);
         }
-        catch (e) {
+        catch {
             if (this._deletedFiles.has(oldPath)) {
                 throw ErrnoError.With('ENOENT', oldPath, 'rename');
             }
@@ -166,7 +166,7 @@ export class UnmutexedOverlayFS extends FileSystem {
         try {
             return await this.writable.stat(path);
         }
-        catch (e) {
+        catch {
             if (this._deletedFiles.has(path)) {
                 throw ErrnoError.With('ENOENT', path, 'stat');
             }
@@ -181,7 +181,7 @@ export class UnmutexedOverlayFS extends FileSystem {
         try {
             return this.writable.statSync(path);
         }
-        catch (e) {
+        catch {
             if (this._deletedFiles.has(path)) {
                 throw ErrnoError.With('ENOENT', path, 'stat');
             }
@@ -323,13 +323,13 @@ export class UnmutexedOverlayFS extends FileSystem {
         try {
             contents.push(...(await this.writable.readdir(path)));
         }
-        catch (e) {
+        catch {
             // NOP.
         }
         try {
             contents.push(...(await this.readable.readdir(path)).filter((fPath) => !this._deletedFiles.has(`${path}/${fPath}`)));
         }
-        catch (e) {
+        catch {
             // NOP.
         }
         const seenMap = {};
@@ -350,13 +350,13 @@ export class UnmutexedOverlayFS extends FileSystem {
         try {
             contents = contents.concat(this.writable.readdirSync(path));
         }
-        catch (e) {
+        catch {
             // NOP.
         }
         try {
             contents = contents.concat(this.readable.readdirSync(path).filter((fPath) => !this._deletedFiles.has(`${path}/${fPath}`)));
         }
-        catch (e) {
+        catch {
             // NOP.
         }
         const seenMap = {};

package/dist/backends/port/fs.js

@@ -180,7 +180,7 @@ export async function handleRequest(port, fs, request) {
                     };
                 }
                 break;
-            case 'file':
+            case 'file': {
                 const { fd } = request;
                 if (!descriptors.has(fd)) {
                     throw new ErrnoError(Errno.EBADF);
@@ -191,6 +191,7 @@ export async function handleRequest(port, fs, request) {
                     descriptors.delete(fd);
                 }
                 break;
+            }
             default:
                 return;
         }

package/dist/backends/port/rpc.js

@@ -79,7 +79,7 @@ export function catchMessages(port) {
     return function (fs) {
         detach(port, handler);
         for (const event of events) {
-            const request = 'data' in event ? event.data : event;
+            const request = ('data' in event ? event.data : event);
             void handleRequest(port, fs, request);
         }
     };

package/dist/devices.js

@@ -105,14 +105,16 @@ export class DeviceFile extends File {
     closeSync() {
         this.driver.close?.(this);
     }
-    async close() {
+    close() {
         this.closeSync();
+        return Promise.resolve();
     }
     syncSync() {
         this.driver.sync?.(this);
     }
-    async sync() {
+    sync() {
         this.syncSync();
+        return Promise.resolve();
     }
     chown() {
         throw ErrnoError.With('ENOTSUP', this.path, 'chown');

package/dist/emulation/async.d.ts

@@ -181,7 +181,7 @@ export declare function link(existing: fs.PathLike, newpath: fs.PathLike, cb?: C
  */
 export declare function symlink(target: fs.PathLike, path: fs.PathLike, cb?: Callback): void;
 export declare function symlink(target: fs.PathLike, path: fs.PathLike, type?: fs.symlink.Type, cb?: Callback): void;
-export declare function readlink(path: fs.PathLike, callback: Callback<[string]> & any): void;
+export declare function readlink(path: fs.PathLike, callback: Callback<[string]>): void;
 export declare function readlink(path: fs.PathLike, options: fs.BufferEncodingOption, callback: Callback<[Uint8Array]>): void;
 export declare function readlink(path: fs.PathLike, options: fs.EncodingOption, callback: Callback<[string | Uint8Array]>): void;
 export declare function readlink(path: fs.PathLike, options: fs.EncodingOption, callback: Callback<[string]>): void;

package/dist/emulation/promises.d.ts

@@ -92,6 +92,9 @@ export declare class FileHandle implements promises.FileHandle {
      * @experimental
      */
     readableWebStream(options?: promises.ReadableWebStreamOptions): TReadableStream<Uint8Array>;
+    /**
+     * @todo Implement
+     */
     readLines(options?: promises.CreateReadStreamOptions): ReadlineInterface;
     [Symbol.asyncDispose](): Promise<void>;
     /**
@@ -296,6 +299,7 @@ export declare function lutimes(path: fs.PathLike, atime: fs.TimeLike, mtime: fs
  * Asynchronous realpath(3) - return the canonicalized absolute pathname.
  * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
  * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. Defaults to `'utf8'`.
+ * @todo handle options
  */
 export declare function realpath(path: fs.PathLike, options: fs.BufferEncodingOption): Promise<Buffer>;
 export declare function realpath(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding): Promise<string>;

package/dist/emulation/promises.js

@@ -206,6 +206,9 @@ export class FileHandle {
         }
         return new _gt.ReadableStream({ start, type: options.type });
     }
+    /**
+     * @todo Implement
+     */
     readLines(options) {
         throw ErrnoError.With('ENOSYS', this.file.path, 'FileHandle.readLines');
     }
@@ -383,11 +386,11 @@ export async function exists(path) {
 }
 export async function stat(path, options) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount((await exists(path)) ? await realpath(path) : path);
+    const { fs, path: resolved } = resolveMount(await realpath(path));
     try {
         const stats = await fs.stat(resolved);
         if (!stats.hasAccess(constants.R_OK)) {
-            throw ErrnoError.With('EACCES', path, 'stat');
+            throw ErrnoError.With('EACCES', resolved, 'stat');
         }
         return options?.bigint ? new BigIntStats(stats) : stats;
     }
@@ -448,7 +451,7 @@ unlink;
 async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
     path = normalizePath(path);
     const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
-    path = resolveSymlinks && (await exists(path)) ? await realpath(path) : path;
+    path = resolveSymlinks ? await realpath(path) : path;
     const { fs, path: resolved } = resolveMount(path);
     const stats = await fs.stat(resolved).catch(() => null);
     if (!stats) {
@@ -577,7 +580,7 @@ appendFile;
 // DIRECTORY-ONLY METHODS
 export async function rmdir(path) {
     path = normalizePath(path);
-    path = (await exists(path)) ? await realpath(path) : path;
+    path = await realpath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
         if (!(await fs.stat(resolved)).hasAccess(constants.W_OK)) {
@@ -594,8 +597,7 @@ rmdir;
 export async function mkdir(path, options) {
     options = typeof options === 'object' ? options : { mode: options };
     const mode = normalizeMode(options?.mode, 0o777);
-    path = normalizePath(path);
-    path = (await exists(path)) ? await realpath(path) : path;
+    path = await realpath(normalizePath(path));
     const { fs, path: resolved } = resolveMount(path);
     const errorPaths = { [resolved]: path };
     try {
@@ -628,12 +630,11 @@ export async function mkdir(path, options) {
 mkdir;
 export async function readdir(path, options) {
     options = typeof options === 'object' ? options : { encoding: options };
-    path = normalizePath(path);
-    if (!(await stat(path)).hasAccess(constants.R_OK)) {
+    path = await realpath(normalizePath(path));
+    const { fs, path: resolved } = resolveMount(path);
+    if (!(await fs.stat(resolved)).hasAccess(constants.R_OK)) {
         throw ErrnoError.With('EACCES', path, 'readdir');
     }
-    path = (await exists(path)) ? await realpath(path) : path;
-    const { fs, path: resolved } = resolveMount(path);
     const entries = await fs.readdir(resolved).catch((e) => {
         throw fixError(e, { [resolved]: path });
     });
@@ -649,8 +650,12 @@ export async function readdir(path, options) {
     }
     const values = [];
     for (const entry of entries) {
-        const fullPath = join(path, entry);
-        const stats = options?.recursive || options?.withFileTypes ? await stat(fullPath) : null;
+        let stats;
+        if (options?.recursive || options?.withFileTypes) {
+            stats = await fs.stat(join(resolved, entry)).catch((error) => {
+                throw fixError(error, { [resolved]: path });
+            });
+        }
         if (options?.withFileTypes) {
             values.push(new Dirent(entry, stats));
         }
@@ -663,7 +668,7 @@ export async function readdir(path, options) {
         if (!options?.recursive || !stats?.isDirectory()) {
             continue;
         }
-        for (const subEntry of await readdir(fullPath, options)) {
+        for (const subEntry of await readdir(join(path, entry), options)) {
             if (subEntry instanceof Dirent) {
                 subEntry.path = join(entry, subEntry.path);
                 values.push(subEntry);
@@ -861,9 +866,12 @@ export async function realpath(path, options) {
         if (!stats.isSymbolicLink()) {
             return lpath;
         }
-        return realpath(mountPoint + (await readlink(lpath)));
+        return await realpath(mountPoint + (await readlink(lpath)));
     }
     catch (e) {
+        if (e.code == 'ENOENT') {
+            return path;
+        }
         throw fixError(e, { [resolvedPath]: lpath });
     }
 }
@@ -972,9 +980,9 @@ copyFile;
  * @returns A `Dir` object representing the opened directory.
  * @todo Use options
  */
-export async function opendir(path, options) {
+export function opendir(path, options) {
     path = normalizePath(path);
-    return new Dir(path);
+    return Promise.resolve(new Dir(path));
 }
 opendir;
 /**
@@ -1026,8 +1034,8 @@ export async function cp(source, destination, opts) {
     }
 }
 cp;
-export async function statfs(path, opts) {
+export function statfs(path, opts) {
     path = normalizePath(path);
     const { fs } = resolveMount(path);
-    return _statfs(fs, opts?.bigint);
+    return Promise.resolve(_statfs(fs, opts?.bigint));
 }

package/dist/emulation/shared.d.ts

@@ -1,4 +1,5 @@
 import type { BigIntStatsFs, StatsFs } from 'node:fs';
+import { ErrnoError } from '../error.js';
 import type { File } from '../file.js';
 import type { FileSystem } from '../filesystem.js';
 import { type AbsolutePath } from './path.js';
@@ -36,7 +37,7 @@ export declare function fixPaths(text: string, paths: Record<string, string>): s
  * Fix paths in error stacks
  * @hidden
  */
-export declare function fixError<E extends Error>(e: E, paths: Record<string, string>): E;
+export declare function fixError<E extends ErrnoError>(e: E, paths: Record<string, string>): E;
 export declare function mountObject(mounts: MountObject): void;
 /**
  * @hidden

package/dist/emulation/sync.d.ts

@@ -199,6 +199,7 @@ export declare function writevSync(fd: number, buffers: readonly ArrayBufferView
  * @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 declare function opendirSync(path: fs.PathLike, options?: fs.OpenDirOptions): Dir;
 /**

package/dist/emulation/sync.js

@@ -97,11 +97,11 @@ export function existsSync(path) {
 existsSync;
 export function statSync(path, options) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    const { fs, path: resolved } = resolveMount(realpathSync(path));
     try {
         const stats = fs.statSync(resolved);
         if (!stats.hasAccess(constants.R_OK)) {
-            throw ErrnoError.With('EACCES', path, 'stat');
+            throw ErrnoError.With('EACCES', resolved, 'stat');
         }
         return options?.bigint ? new BigIntStats(stats) : stats;
     }
@@ -159,9 +159,16 @@ unlinkSync;
 function _openSync(path, _flag, _mode, resolveSymlinks = true) {
     path = normalizePath(path);
     const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
-    path = resolveSymlinks && existsSync(path) ? realpathSync(path) : path;
+    path = resolveSymlinks ? realpathSync(path) : path;
     const { fs, path: resolved } = resolveMount(path);
-    if (!fs.existsSync(resolved)) {
+    let stats;
+    try {
+        stats = fs.statSync(resolved);
+    }
+    catch {
+        // nothing
+    }
+    if (!stats) {
         if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
             throw ErrnoError.With('ENOENT', path, '_open');
         }
@@ -175,7 +182,6 @@ function _openSync(path, _flag, _mode, resolveSymlinks = true) {
         }
         return fs.createFileSync(resolved, flag, mode);
     }
-    const stats = fs.statSync(resolved);
     if (!stats.hasAccess(mode) || !stats.hasAccess(flagToMode(flag))) {
         throw ErrnoError.With('EACCES', path, '_open');
     }
@@ -384,7 +390,7 @@ export function futimesSync(fd, atime, mtime) {
 futimesSync;
 export function rmdirSync(path) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    const { fs, path: resolved } = resolveMount(realpathSync(path));
     try {
         if (!fs.statSync(resolved).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'rmdir');
@@ -400,8 +406,7 @@ rmdirSync;
 export function mkdirSync(path, options) {
     options = typeof options === 'object' ? options : { mode: options };
     const mode = normalizeMode(options?.mode, 0o777);
-    path = normalizePath(path);
-    path = existsSync(path) ? realpathSync(path) : path;
+    path = realpathSync(normalizePath(path));
     const { fs, path: resolved } = resolveMount(path);
     const errorPaths = { [resolved]: path };
     try {
@@ -433,12 +438,12 @@ mkdirSync;
 export function readdirSync(path, options) {
     options = typeof options === 'object' ? options : { encoding: options };
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    const { fs, path: resolved } = resolveMount(realpathSync(path));
     let entries;
-    if (!statSync(path).hasAccess(constants.R_OK)) {
-        throw ErrnoError.With('EACCES', path, 'readdir');
-    }
     try {
+        if (!fs.statSync(resolved).hasAccess(constants.R_OK)) {
+            throw ErrnoError.With('EACCES', path, 'readdir');
+        }
         entries = fs.readdirSync(resolved);
     }
     catch (e) {
@@ -458,8 +463,7 @@ export function readdirSync(path, options) {
     // Iterate over entries and handle recursive case if needed
     const values = [];
     for (const entry of entries) {
-        const fullPath = join(path, entry);
-        const entryStat = statSync(fullPath);
+        const entryStat = fs.statSync(join(resolved, entry));
         if (options?.withFileTypes) {
             values.push(new Dirent(entry, entryStat));
         }
@@ -471,7 +475,7 @@ export function readdirSync(path, options) {
         }
         if (!entryStat.isDirectory() || !options?.recursive)
             continue;
-        for (const subEntry of readdirSync(fullPath, options)) {
+        for (const subEntry of readdirSync(join(path, entry), options)) {
             if (subEntry instanceof Dirent) {
                 subEntry.path = join(entry, subEntry.path);
                 values.push(subEntry);
@@ -596,13 +600,15 @@ export function realpathSync(path, options) {
         return realpathSync(mountPoint + readlinkSync(lpath, options).toString());
     }
     catch (e) {
+        if (e.code == 'ENOENT') {
+            return path;
+        }
         throw fixError(e, { [resolvedPath]: lpath });
     }
 }
 realpathSync;
 export function accessSync(path, mode = 0o600) {
-    const stats = statSync(path);
-    if (!stats.hasAccess(mode)) {
+    if (!statSync(path).hasAccess(mode)) {
         throw new ErrnoError(Errno.EACCES);
     }
 }
@@ -706,6 +712,7 @@ writevSync;
  * @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);

package/dist/error.js

@@ -261,7 +261,7 @@ export class ErrnoError extends Error {
         this.path = path;
         this.syscall = syscall;
         this.code = Errno[errno];
-        this.message = `${this.code}: ${message}${this.path ? `, '${this.path}'` : ''}`;
+        this.message = this.code + ': ' + message + (this.path ? `, '${this.path}'` : '');
     }
     /**
      * @returns A friendly error message.

package/eslint.shared.js

@@ -44,6 +44,7 @@ export default [
 			'@typescript-eslint/no-redundant-type-constituents': 'warn',
 			'@typescript-eslint/no-unsafe-call': 'warn',
 			'@typescript-eslint/restrict-plus-operands': 'off',
+			'@typescript-eslint/no-base-to-string': 'off',
 		},
 	},
 	{

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.1.3",
+	"version": "1.1.4",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/src/backends/backend.ts

@@ -1,4 +1,4 @@
-import type { RequiredKeys } from 'utilium';
+import type { Entries, RequiredKeys } from 'utilium';
 import { ErrnoError, Errno } from '../error.js';
 import type { FileSystem } from '../filesystem.js';
 import { levenshtein } from '../utils.js';
@@ -102,7 +102,7 @@ export async function checkOptions<T extends Backend>(backend: T, options: Recor
 	}
 
 	// Check for required options.
-	for (const [optName, opt] of Object.entries(backend.options)) {
+	for (const [optName, opt] of Object.entries(backend.options) as Entries<OptionsConfig<Record<string, any>>>) {
 		const providedValue = options?.[optName];
 
 		if (providedValue === undefined || providedValue === null) {
@@ -133,7 +133,7 @@ export async function checkOptions<T extends Backend>(backend: T, options: Recor
 			throw new ErrnoError(
 				Errno.EINVAL,
 				`${backend.name}: Value provided for option ${optName} is not the proper type. Expected ${
-					Array.isArray(opt.type) ? `one of {${opt.type.join(', ')}}` : opt.type
+					Array.isArray(opt.type) ? `one of {${opt.type.join(', ')}}` : (opt.type as string)
 				}, but received ${typeof providedValue}`
 			);
 		}

package/src/backends/file_index.ts

@@ -202,7 +202,7 @@ export abstract class IndexFS extends Readonly(FileSystem) {
 		if (!content.every(item => typeof item == 'string')) {
 			throw ErrnoError.With('ENODATA', path, 'readdir');
 		}
-		return content as string[];
+		return content;
 	}
 
 	protected abstract getData(path: string, stats: Stats): Promise<Uint8Array>;

package/src/backends/overlay.ts

@@ -128,7 +128,7 @@ export class UnmutexedOverlayFS extends FileSystem {
 
 		try {
 			await this.writable.rename(oldPath, newPath);
-		} catch (e) {
+		} catch {
 			if (this._deletedFiles.has(oldPath)) {
 				throw ErrnoError.With('ENOENT', oldPath, 'rename');
 			}
@@ -144,7 +144,7 @@ export class UnmutexedOverlayFS extends FileSystem {
 
 		try {
 			this.writable.renameSync(oldPath, newPath);
-		} catch (e) {
+		} catch {
 			if (this._deletedFiles.has(oldPath)) {
 				throw ErrnoError.With('ENOENT', oldPath, 'rename');
 			}
@@ -155,7 +155,7 @@ export class UnmutexedOverlayFS extends FileSystem {
 		this.checkInitialized();
 		try {
 			return await this.writable.stat(path);
-		} catch (e) {
+		} catch {
 			if (this._deletedFiles.has(path)) {
 				throw ErrnoError.With('ENOENT', path, 'stat');
 			}
@@ -170,7 +170,7 @@ export class UnmutexedOverlayFS extends FileSystem {
 		this.checkInitialized();
 		try {
 			return this.writable.statSync(path);
-		} catch (e) {
+		} catch {
 			if (this._deletedFiles.has(path)) {
 				throw ErrnoError.With('ENOENT', path, 'stat');
 			}
@@ -329,12 +329,12 @@ export class UnmutexedOverlayFS extends FileSystem {
 		const contents: string[] = [];
 		try {
 			contents.push(...(await this.writable.readdir(path)));
-		} catch (e) {
+		} catch {
 			// NOP.
 		}
 		try {
 			contents.push(...(await this.readable.readdir(path)).filter((fPath: string) => !this._deletedFiles.has(`${path}/${fPath}`)));
-		} catch (e) {
+		} catch {
 			// NOP.
 		}
 		const seenMap: { [name: string]: boolean } = {};
@@ -356,12 +356,12 @@ export class UnmutexedOverlayFS extends FileSystem {
 		let contents: string[] = [];
 		try {
 			contents = contents.concat(this.writable.readdirSync(path));
-		} catch (e) {
+		} catch {
 			// NOP.
 		}
 		try {
 			contents = contents.concat(this.readable.readdirSync(path).filter((fPath: string) => !this._deletedFiles.has(`${path}/${fPath}`)));
-		} catch (e) {
+		} catch {
 			// NOP.
 		}
 		const seenMap: { [name: string]: boolean } = {};

package/src/backends/port/fs.ts

@@ -260,7 +260,7 @@ export async function handleRequest(port: RPC.Port, fs: FileSystem, request: Fil
 					};
 				}
 				break;
-			case 'file':
+			case 'file': {
 				const { fd } = request;
 				if (!descriptors.has(fd)) {
 					throw new ErrnoError(Errno.EBADF);
@@ -271,11 +271,12 @@ export async function handleRequest(port: RPC.Port, fs: FileSystem, request: Fil
 					descriptors.delete(fd);
 				}
 				break;
+			}
 			default:
 				return;
 		}
-	} catch (e: any) {
-		value = e instanceof ErrnoError ? e.toJSON() : e.toString();
+	} catch (e) {
+		value = e instanceof ErrnoError ? e.toJSON() : (e as object).toString();
 		error = true;
 	}
 

package/src/backends/port/rpc.ts

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Errno, ErrnoError, type ErrnoErrorJSON } from '../../error.js';
+import type { FileSystem } from '../../filesystem.js';
 import type { Backend, FilesystemOf } from '../backend.js';
 import { handleRequest, PortFile, type PortFS } from './fs.js';
 import type { FileOrFSRequest } from './fs.js';
@@ -156,10 +157,10 @@ export function catchMessages<T extends Backend>(port: Port): (fs: FilesystemOf<
 	const events: _MessageEvent[] = [];
 	const handler = events.push.bind(events);
 	attach(port, handler);
-	return function (fs: any) {
+	return function (fs: FileSystem) {
 		detach(port, handler);
 		for (const event of events) {
-			const request: FileOrFSRequest = 'data' in event ? event.data : event;
+			const request = ('data' in event ? event.data : event) as FileOrFSRequest;
 			void handleRequest(port, fs, request);
 		}
 	};

package/src/devices.ts

@@ -134,16 +134,18 @@ export class DeviceFile extends File {
 		this.driver.close?.(this);
 	}
 
-	public async close(): Promise<void> {
+	public close(): Promise<void> {
 		this.closeSync();
+		return Promise.resolve();
 	}
 
 	public syncSync(): void {
 		this.driver.sync?.(this);
 	}
 
-	public async sync(): Promise<void> {
+	public sync(): Promise<void> {
 		this.syncSync();
+		return Promise.resolve();
 	}
 
 	public chown(): Promise<void> {

package/src/emulation/async.ts

@@ -425,7 +425,7 @@ export function symlink(target: fs.PathLike, path: fs.PathLike, typeOrCB?: fs.sy
 }
 symlink satisfies Omit<typeof fs.symlink, '__promisify__'>;
 
-export function readlink(path: fs.PathLike, callback: Callback<[string]> & any): void;
+export function readlink(path: fs.PathLike, callback: Callback<[string]>): void;
 export function readlink(path: fs.PathLike, options: fs.BufferEncodingOption, callback: Callback<[Uint8Array]>): void;
 export function readlink(path: fs.PathLike, options: fs.EncodingOption, callback: Callback<[string | Uint8Array]>): void;
 export function readlink(path: fs.PathLike, options: fs.EncodingOption, callback: Callback<[string]>): void;

package/src/emulation/promises.ts

@@ -202,6 +202,9 @@ export class FileHandle implements promises.FileHandle {
 		return new (_gt as { ReadableStream: new (...args: unknown[]) => TReadableStream<Uint8Array> }).ReadableStream({ start, type: options.type });
 	}
 
+	/**
+	 * @todo Implement
+	 */
 	public readLines(options?: promises.CreateReadStreamOptions): ReadlineInterface {
 		throw ErrnoError.With('ENOSYS', this.file.path, 'FileHandle.readLines');
 	}
@@ -396,7 +399,7 @@ export async function rename(oldPath: fs.PathLike, newPath: fs.PathLike): Promis
 		await unlink(oldPath);
 		emitChange('rename', oldPath.toString());
 	} catch (e) {
-		throw fixError(e as Error, { [src.path]: oldPath, [dst.path]: newPath });
+		throw fixError(e as ErrnoError, { [src.path]: oldPath, [dst.path]: newPath });
 	}
 }
 rename satisfies typeof promises.rename;
@@ -422,15 +425,15 @@ export async function stat(path: fs.PathLike, options?: { bigint?: false }): Pro
 export async function stat(path: fs.PathLike, options?: fs.StatOptions): Promise<Stats | BigIntStats>;
 export async function stat(path: fs.PathLike, options?: fs.StatOptions): Promise<Stats | BigIntStats> {
 	path = normalizePath(path);
-	const { fs, path: resolved } = resolveMount((await exists(path)) ? await realpath(path) : path);
+	const { fs, path: resolved } = resolveMount(await realpath(path));
 	try {
 		const stats = await fs.stat(resolved);
 		if (!stats.hasAccess(constants.R_OK)) {
-			throw ErrnoError.With('EACCES', path, 'stat');
+			throw ErrnoError.With('EACCES', resolved, 'stat');
 		}
 		return options?.bigint ? new BigIntStats(stats) : stats;
 	} catch (e) {
-		throw fixError(e as Error, { [resolved]: path });
+		throw fixError(e as ErrnoError, { [resolved]: path });
 	}
 }
 stat satisfies typeof promises.stat;
@@ -449,7 +452,7 @@ export async function lstat(path: fs.PathLike, options?: fs.StatOptions): Promis
 		const stats = await fs.stat(resolved);
 		return options?.bigint ? new BigIntStats(stats) : stats;
 	} catch (e) {
-		throw fixError(e as Error, { [resolved]: path });
+		throw fixError(e as ErrnoError, { [resolved]: path });
 	}
 }
 lstat satisfies typeof promises.lstat;
@@ -472,7 +475,7 @@ export async function unlink(path: fs.PathLike): Promise<void> {
 		await fs.unlink(resolved);
 		emitChange('rename', path.toString());
 	} catch (e) {
-		throw fixError(e as Error, { [resolved]: path });
+		throw fixError(e as ErrnoError, { [resolved]: path });
 	}
 }
 unlink satisfies typeof promises.unlink;
@@ -486,7 +489,7 @@ async function _open(path: fs.PathLike, _flag: fs.OpenMode, _mode: fs.Mode = 0o6
 	const mode = normalizeMode(_mode, 0o644),
 		flag = parseFlag(_flag);
 
-	path = resolveSymlinks && (await exists(path)) ? await realpath(path) : path;
+	path = resolveSymlinks ? await realpath(path) : path;
 	const { fs, path: resolved } = resolveMount(path);
 
 	const stats = await fs.stat(resolved).catch(() => null);
@@ -617,7 +620,7 @@ appendFile satisfies typeof promises.appendFile;
 
 export async function rmdir(path: fs.PathLike): Promise<void> {
 	path = normalizePath(path);
-	path = (await exists(path)) ? await realpath(path) : path;
+	path = await realpath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
 		if (!(await fs.stat(resolved)).hasAccess(constants.W_OK)) {
@@ -626,7 +629,7 @@ export async function rmdir(path: fs.PathLike): Promise<void> {
 		await fs.rmdir(resolved);
 		emitChange('rename', path.toString());
 	} catch (e) {
-		throw fixError(e as Error, { [resolved]: path });
+		throw fixError(e as ErrnoError, { [resolved]: path });
 	}
 }
 rmdir satisfies typeof promises.rmdir;
@@ -644,8 +647,7 @@ export async function mkdir(path: fs.PathLike, options?: fs.Mode | fs.MakeDirect
 	options = typeof options === 'object' ? options : { mode: options };
 	const mode = normalizeMode(options?.mode, 0o777);
 
-	path = normalizePath(path);
-	path = (await exists(path)) ? await realpath(path) : path;
+	path = await realpath(normalizePath(path));
 	const { fs, path: resolved } = resolveMount(path);
 	const errorPaths: Record<string, string> = { [resolved]: path };
 
@@ -673,7 +675,7 @@ export async function mkdir(path: fs.PathLike, options?: fs.Mode | fs.MakeDirect
 		}
 		return dirs[0];
 	} catch (e) {
-		throw fixError(e as Error, errorPaths);
+		throw fixError(e as ErrnoError, errorPaths);
 	}
 }
 mkdir satisfies typeof promises.mkdir;
@@ -699,17 +701,16 @@ export async function readdir(
 	options?: { withFileTypes?: boolean; recursive?: boolean; encoding?: BufferEncoding | 'buffer' | null } | BufferEncoding | 'buffer' | null
 ): Promise<string[] | Dirent[] | Buffer[]> {
 	options = typeof options === 'object' ? options : { encoding: options };
-	path = normalizePath(path);
+	path = await realpath(normalizePath(path));
+
+	const { fs, path: resolved } = resolveMount(path);
 
-	if (!(await stat(path)).hasAccess(constants.R_OK)) {
+	if (!(await fs.stat(resolved)).hasAccess(constants.R_OK)) {
 		throw ErrnoError.With('EACCES', path, 'readdir');
 	}
 
-	path = (await exists(path)) ? await realpath(path) : path;
-	const { fs, path: resolved } = resolveMount(path);
-
-	const entries = await fs.readdir(resolved).catch((e: Error) => {
-		throw fixError(e as Error, { [resolved]: path });
+	const entries = await fs.readdir(resolved).catch((e: ErrnoError) => {
+		throw fixError(e, { [resolved]: path });
 	});
 
 	for (const point of mounts.keys()) {
@@ -725,9 +726,12 @@ export async function readdir(
 
 	const values: (string | Dirent | Buffer)[] = [];
 	for (const entry of entries) {
-		const fullPath = join(path, entry);
-
-		const stats = options?.recursive || options?.withFileTypes ? await stat(fullPath) : null;
+		let stats: Stats | undefined | void;
+		if (options?.recursive || options?.withFileTypes) {
+			stats = await fs.stat(join(resolved, entry)).catch((error: ErrnoError) => {
+				throw fixError(error, { [resolved]: path });
+			});
+		}
 		if (options?.withFileTypes) {
 			values.push(new Dirent(entry, stats!));
 		} else if (options?.encoding === 'buffer') {
@@ -740,7 +744,7 @@ export async function readdir(
 			continue;
 		}
 
-		for (const subEntry of await readdir(fullPath, options)) {
+		for (const subEntry of await readdir(join(path, entry), options)) {
 			if (subEntry instanceof Dirent) {
 				subEntry.path = join(entry, subEntry.path);
 				values.push(subEntry);
@@ -778,7 +782,7 @@ export async function link(targetPath: fs.PathLike, linkPath: fs.PathLike): Prom
 		}
 		return await fs.link(path, link.path);
 	} catch (e) {
-		throw fixError(e as Error, { [link.path]: linkPath, [path]: targetPath });
+		throw fixError(e as ErrnoError, { [link.path]: linkPath, [path]: targetPath });
 	}
 }
 link satisfies typeof promises.link;
@@ -863,6 +867,7 @@ lutimes satisfies typeof promises.lutimes;
  * Asynchronous realpath(3) - return the canonicalized absolute pathname.
  * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
  * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. Defaults to `'utf8'`.
+ * @todo handle options
  */
 export async function realpath(path: fs.PathLike, options: fs.BufferEncodingOption): Promise<Buffer>;
 export async function realpath(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding): Promise<string>;
@@ -878,9 +883,12 @@ export async function realpath(path: fs.PathLike, options?: fs.EncodingOption |
 			return lpath;
 		}
 
-		return realpath(mountPoint + (await readlink(lpath)));
+		return await realpath(mountPoint + (await readlink(lpath)));
 	} catch (e) {
-		throw fixError(e as Error, { [resolvedPath]: lpath });
+		if ((e as ErrnoError).code == 'ENOENT') {
+			return path;
+		}
+		throw fixError(e as ErrnoError, { [resolvedPath]: lpath });
 	}
 }
 realpath satisfies typeof promises.realpath;
@@ -1016,9 +1024,9 @@ copyFile satisfies typeof promises.copyFile;
  * @returns A `Dir` object representing the opened directory.
  * @todo Use options
  */
-export async function opendir(path: fs.PathLike, options?: fs.OpenDirOptions): Promise<Dir> {
+export function opendir(path: fs.PathLike, options?: fs.OpenDirOptions): Promise<Dir> {
 	path = normalizePath(path);
-	return new Dir(path);
+	return Promise.resolve(new Dir(path));
 }
 opendir satisfies typeof promises.opendir;
 
@@ -1083,8 +1091,8 @@ cp satisfies typeof promises.cp;
 export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions & { bigint?: false }): Promise<fs.StatsFs>;
 export async function statfs(path: fs.PathLike, opts: fs.StatFsOptions & { bigint: true }): Promise<fs.BigIntStatsFs>;
 export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<fs.StatsFs | fs.BigIntStatsFs>;
-export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<fs.StatsFs | fs.BigIntStatsFs> {
+export function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<fs.StatsFs | fs.BigIntStatsFs> {
 	path = normalizePath(path);
 	const { fs } = resolveMount(path);
-	return _statfs(fs, opts?.bigint);
+	return Promise.resolve(_statfs(fs, opts?.bigint));
 }

package/src/emulation/shared.ts

@@ -99,7 +99,7 @@ export function fixPaths(text: string, paths: Record<string, string>): string {
  * Fix paths in error stacks
  * @hidden
  */
-export function fixError<E extends Error>(e: E, paths: Record<string, string>): E {
+export function fixError<E extends ErrnoError>(e: E, paths: Record<string, string>): E {
 	if (typeof e.stack == 'string') {
 		e.stack = fixPaths(e.stack, paths);
 	}

package/src/emulation/sync.ts

@@ -31,7 +31,7 @@ export function renameSync(oldPath: fs.PathLike, newPath: fs.PathLike): void {
 		unlinkSync(oldPath);
 		emitChange('rename', oldPath.toString());
 	} catch (e) {
-		throw fixError(e as Error, { [oldMount.path]: oldPath, [newMount.path]: newPath });
+		throw fixError(e as ErrnoError, { [oldMount.path]: oldPath, [newMount.path]: newPath });
 	}
 }
 renameSync satisfies typeof fs.renameSync;
@@ -58,15 +58,15 @@ export function statSync(path: fs.PathLike, options?: { bigint?: boolean }): Sta
 export function statSync(path: fs.PathLike, options: { bigint: true }): BigIntStats;
 export function statSync(path: fs.PathLike, options?: fs.StatOptions): Stats | BigIntStats {
 	path = normalizePath(path);
-	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	try {
 		const stats = fs.statSync(resolved);
 		if (!stats.hasAccess(constants.R_OK)) {
-			throw ErrnoError.With('EACCES', path, 'stat');
+			throw ErrnoError.With('EACCES', resolved, 'stat');
 		}
 		return options?.bigint ? new BigIntStats(stats) : stats;
 	} catch (e) {
-		throw fixError(e as Error, { [resolved]: path });
+		throw fixError(e as ErrnoError, { [resolved]: path });
 	}
 }
 statSync satisfies typeof fs.statSync;
@@ -85,7 +85,7 @@ export function lstatSync(path: fs.PathLike, options?: fs.StatOptions): Stats |
 		const stats = fs.statSync(resolved);
 		return options?.bigint ? new BigIntStats(stats) : stats;
 	} catch (e) {
-		throw fixError(e as Error, { [resolved]: path });
+		throw fixError(e as ErrnoError, { [resolved]: path });
 	}
 }
 lstatSync satisfies typeof fs.lstatSync;
@@ -110,7 +110,7 @@ export function unlinkSync(path: fs.PathLike): void {
 		fs.unlinkSync(resolved);
 		emitChange('rename', path.toString());
 	} catch (e) {
-		throw fixError(e as Error, { [resolved]: path });
+		throw fixError(e as ErrnoError, { [resolved]: path });
 	}
 }
 unlinkSync satisfies typeof fs.unlinkSync;
@@ -120,10 +120,17 @@ function _openSync(path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | null
 	const mode = normalizeMode(_mode, 0o644),
 		flag = parseFlag(_flag);
 
-	path = resolveSymlinks && existsSync(path) ? realpathSync(path) : path;
+	path = resolveSymlinks ? realpathSync(path) : path;
 	const { fs, path: resolved } = resolveMount(path);
 
-	if (!fs.existsSync(resolved)) {
+	let stats: Stats | undefined;
+	try {
+		stats = fs.statSync(resolved);
+	} catch {
+		// nothing
+	}
+
+	if (!stats) {
 		if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
 			throw ErrnoError.With('ENOENT', path, '_open');
 		}
@@ -138,8 +145,6 @@ function _openSync(path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | null
 		return fs.createFileSync(resolved, flag, mode);
 	}
 
-	const stats: Stats = fs.statSync(resolved);
-
 	if (!stats.hasAccess(mode) || !stats.hasAccess(flagToMode(flag))) {
 		throw ErrnoError.With('EACCES', path, '_open');
 	}
@@ -378,7 +383,7 @@ futimesSync satisfies typeof fs.futimesSync;
 
 export function rmdirSync(path: fs.PathLike): void {
 	path = normalizePath(path);
-	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	try {
 		if (!fs.statSync(resolved).hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'rmdir');
@@ -386,7 +391,7 @@ export function rmdirSync(path: fs.PathLike): void {
 		fs.rmdirSync(resolved);
 		emitChange('rename', path.toString());
 	} catch (e) {
-		throw fixError(e as Error, { [resolved]: path });
+		throw fixError(e as ErrnoError, { [resolved]: path });
 	}
 }
 rmdirSync satisfies typeof fs.rmdirSync;
@@ -401,8 +406,7 @@ export function mkdirSync(path: fs.PathLike, options?: fs.Mode | fs.MakeDirector
 	options = typeof options === 'object' ? options : { mode: options };
 	const mode = normalizeMode(options?.mode, 0o777);
 
-	path = normalizePath(path);
-	path = existsSync(path) ? realpathSync(path) : path;
+	path = realpathSync(normalizePath(path));
 	const { fs, path: resolved } = resolveMount(path);
 	const errorPaths: Record<string, string> = { [resolved]: path };
 
@@ -428,7 +432,7 @@ export function mkdirSync(path: fs.PathLike, options?: fs.Mode | fs.MakeDirector
 		}
 		return dirs[0];
 	} catch (e) {
-		throw fixError(e as Error, errorPaths);
+		throw fixError(e as ErrnoError, errorPaths);
 	}
 }
 mkdirSync satisfies typeof fs.mkdirSync;
@@ -447,15 +451,15 @@ export function readdirSync(
 ): string[] | Dirent[] | Buffer[] {
 	options = typeof options === 'object' ? options : { encoding: options };
 	path = normalizePath(path);
-	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	let entries: string[];
-	if (!statSync(path).hasAccess(constants.R_OK)) {
-		throw ErrnoError.With('EACCES', path, 'readdir');
-	}
 	try {
+		if (!fs.statSync(resolved).hasAccess(constants.R_OK)) {
+			throw ErrnoError.With('EACCES', path, 'readdir');
+		}
 		entries = fs.readdirSync(resolved);
 	} catch (e) {
-		throw fixError(e as Error, { [resolved]: path });
+		throw fixError(e as ErrnoError, { [resolved]: path });
 	}
 
 	for (const mount of mounts.keys()) {
@@ -473,8 +477,7 @@ export function readdirSync(
 	// Iterate over entries and handle recursive case if needed
 	const values: (string | Dirent | Buffer)[] = [];
 	for (const entry of entries) {
-		const fullPath = join(path, entry);
-		const entryStat = statSync(fullPath);
+		const entryStat = fs.statSync(join(resolved, entry));
 
 		if (options?.withFileTypes) {
 			values.push(new Dirent(entry, entryStat));
@@ -485,7 +488,7 @@ export function readdirSync(
 		}
 		if (!entryStat.isDirectory() || !options?.recursive) continue;
 
-		for (const subEntry of readdirSync(fullPath, options)) {
+		for (const subEntry of readdirSync(join(path, entry), options)) {
 			if (subEntry instanceof Dirent) {
 				subEntry.path = join(entry, subEntry.path);
 				values.push(subEntry);
@@ -524,7 +527,7 @@ export function linkSync(targetPath: fs.PathLike, linkPath: fs.PathLike): void {
 		}
 		return fs.linkSync(path, linkPath);
 	} catch (e) {
-		throw fixError(e as Error, { [path]: targetPath, [link.path]: linkPath });
+		throw fixError(e as ErrnoError, { [path]: targetPath, [link.path]: linkPath });
 	}
 }
 linkSync satisfies typeof fs.linkSync;
@@ -628,14 +631,16 @@ export function realpathSync(path: fs.PathLike, options?: fs.EncodingOption | fs
 
 		return realpathSync(mountPoint + readlinkSync(lpath, options).toString());
 	} catch (e) {
-		throw fixError(e as Error, { [resolvedPath]: lpath });
+		if ((e as ErrnoError).code == 'ENOENT') {
+			return path;
+		}
+		throw fixError(e as ErrnoError, { [resolvedPath]: lpath });
 	}
 }
 realpathSync satisfies Omit<typeof fs.realpathSync, 'native'>;
 
 export function accessSync(path: fs.PathLike, mode: number = 0o600): void {
-	const stats = statSync(path);
-	if (!stats.hasAccess(mode)) {
+	if (!statSync(path).hasAccess(mode)) {
 		throw new ErrnoError(Errno.EACCES);
 	}
 }
@@ -651,8 +656,8 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions): void {
 	let stats: Stats | undefined;
 	try {
 		stats = statSync(path);
-	} catch (error: any) {
-		if (error.code != 'ENOENT' || !options?.force) throw error;
+	} catch (error) {
+		if ((error as ErrnoError).code != 'ENOENT' || !options?.force) throw error;
 	}
 
 	if (!stats) {
@@ -763,6 +768,7 @@ writevSync satisfies typeof fs.writevSync;
  * @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: fs.PathLike, options?: fs.OpenDirOptions): Dir {
 	path = normalizePath(path);

package/src/error.ts

@@ -276,7 +276,7 @@ export class ErrnoError extends Error implements NodeJS.ErrnoException {
 	) {
 		super(message);
 		this.code = Errno[errno] as keyof typeof Errno;
-		this.message = `${this.code}: ${message}${this.path ? `, '${this.path}'` : ''}`;
+		this.message = this.code + ': ' + message + (this.path ? `, '${this.path}'` : '');
 	}
 
 	/**