@zenfs/core 0.9.6 → 0.9.7

package/src/emulation/sync.ts

@@ -1,30 +1,29 @@
 import { Buffer } from 'buffer';
-import type * as Node from 'fs';
-import type { BufferEncodingOption, EncodingOption, ReadSyncOptions, StatOptions, symlink } from 'fs';
+import type * as fs from 'node:fs';
 import { ApiError, ErrorCode } from '../ApiError.js';
 import { ActionType, File, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
 import { FileContents, FileSystem } from '../filesystem.js';
 import { BigIntStats, FileType, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
 import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
-import { COPYFILE_EXCL, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK } from './constants.js';
+import { COPYFILE_EXCL, F_OK, S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK } from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { PathLike, cred, fd2file, fdMap, fixError, getFdForFile, mounts, resolveMount } from './shared.js';
+import { cred, fd2file, fdMap, fixError, file2fd, mounts, resolveMount } from './shared.js';
 
 type FileSystemMethod = {
-	[K in keyof FileSystem]: FileSystem[K] extends (...args) => unknown
+	[K in keyof FileSystem]: FileSystem[K] extends (...args: any[]) => unknown
 		? (name: K, resolveSymlinks: boolean, ...args: Parameters<FileSystem[K]>) => ReturnType<FileSystem[K]>
 		: never;
 }[keyof FileSystem]; // https://stackoverflow.com/a/76335220/17637456
 
 function doOp<M extends FileSystemMethod, RT extends ReturnType<M>>(...[name, resolveSymlinks, path, ...args]: Parameters<M>): RT {
-	path = normalizePath(path);
+	path = normalizePath(path!);
 	const { fs, path: resolvedPath } = resolveMount(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
 	try {
 		// @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
 		return fs[name](resolvedPath, ...args) as RT;
 	} catch (e) {
-		throw fixError(e, { [resolvedPath]: path });
+		throw fixError(<Error>e, { [resolvedPath]: path });
 	}
 }
 
@@ -33,7 +32,7 @@ function doOp<M extends FileSystemMethod, RT extends ReturnType<M>>(...[name, re
  * @param oldPath
  * @param newPath
  */
-export function renameSync(oldPath: PathLike, newPath: PathLike): void {
+export function renameSync(oldPath: fs.PathLike, newPath: fs.PathLike): void {
 	oldPath = normalizePath(oldPath);
 	newPath = normalizePath(newPath);
 	const _old = resolveMount(oldPath);
@@ -47,16 +46,16 @@ export function renameSync(oldPath: PathLike, newPath: PathLike): void {
 		writeFileSync(newPath, readFileSync(oldPath));
 		unlinkSync(oldPath);
 	} catch (e) {
-		throw fixError(e, paths);
+		throw fixError(<Error>e, paths);
 	}
 }
-renameSync satisfies typeof Node.renameSync;
+renameSync satisfies typeof fs.renameSync;
 
 /**
  * Test whether or not the given path exists by checking with the file system.
  * @param path
  */
-export function existsSync(path: PathLike): boolean {
+export function existsSync(path: fs.PathLike): boolean {
 	path = normalizePath(path);
 	try {
 		const { fs, path: resolvedPath } = resolveMount(realpathSync(path));
@@ -69,20 +68,20 @@ export function existsSync(path: PathLike): boolean {
 		throw e;
 	}
 }
-existsSync satisfies typeof Node.existsSync;
+existsSync satisfies typeof fs.existsSync;
 
 /**
  * Synchronous `stat`.
  * @param path
  * @returns Stats
  */
-export function statSync(path: PathLike, options?: { bigint?: false }): Stats;
-export function statSync(path: PathLike, options: { bigint: true }): BigIntStats;
-export function statSync(path: PathLike, options?: StatOptions): Stats | BigIntStats {
-	const stats: Stats = doOp('statSync', true, path, cred);
+export function statSync(path: fs.PathLike, options?: { bigint?: boolean }): Stats;
+export function statSync(path: fs.PathLike, options: { bigint: true }): BigIntStats;
+export function statSync(path: fs.PathLike, options?: fs.StatOptions): Stats | BigIntStats {
+	const stats: Stats = doOp('statSync', true, path.toString(), cred);
 	return options?.bigint ? new BigIntStats(stats) : stats;
 }
-statSync satisfies typeof Node.statSync;
+statSync satisfies typeof fs.statSync;
 
 /**
  * Synchronous `lstat`.
@@ -90,20 +89,20 @@ statSync satisfies typeof Node.statSync;
  * then the link itself is stat-ed, not the file that it refers to.
  * @param path
  */
-export function lstatSync(path: PathLike, options?: { bigint?: false }): Stats;
-export function lstatSync(path: PathLike, options: { bigint: true }): BigIntStats;
-export function lstatSync(path: PathLike, options?: StatOptions): Stats | BigIntStats {
-	const stats: Stats = doOp('statSync', false, path, cred);
+export function lstatSync(path: fs.PathLike, options?: { bigint?: boolean }): Stats;
+export function lstatSync(path: fs.PathLike, options: { bigint: true }): BigIntStats;
+export function lstatSync(path: fs.PathLike, options?: fs.StatOptions): Stats | BigIntStats {
+	const stats: Stats = doOp('statSync', false, path.toString(), cred);
 	return options?.bigint ? new BigIntStats(stats) : stats;
 }
-lstatSync satisfies typeof Node.lstatSync;
+lstatSync satisfies typeof fs.lstatSync;
 
 /**
  * Synchronous `truncate`.
  * @param path
  * @param len
  */
-export function truncateSync(path: PathLike, len: number = 0): void {
+export function truncateSync(path: fs.PathLike, len: number | null = 0): void {
 	const fd = openSync(path, 'r+');
 	try {
 		ftruncateSync(fd, len);
@@ -111,18 +110,18 @@ export function truncateSync(path: PathLike, len: number = 0): void {
 		closeSync(fd);
 	}
 }
-truncateSync satisfies typeof Node.truncateSync;
+truncateSync satisfies typeof fs.truncateSync;
 
 /**
  * Synchronous `unlink`.
  * @param path
  */
-export function unlinkSync(path: PathLike): void {
-	return doOp('unlinkSync', false, path, cred);
+export function unlinkSync(path: fs.PathLike): void {
+	return doOp('unlinkSync', false, path.toString(), cred);
 }
-unlinkSync satisfies typeof Node.unlinkSync;
+unlinkSync satisfies typeof fs.unlinkSync;
 
-function _openSync(_path: PathLike, _flag: string, _mode: Node.Mode, resolveSymlinks: boolean): File {
+function _openSync(_path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | null, resolveSymlinks: boolean = true): File {
 	const path = normalizePath(_path),
 		mode = normalizeMode(_mode, 0o644),
 		flag = parseFlag(_flag);
@@ -179,17 +178,17 @@ function _openSync(_path: PathLike, _flag: string, _mode: Node.Mode, resolveSyml
  * @param mode Mode to use to open the file. Can be ignored if the
  *   filesystem doesn't support permissions.
  */
-export function openSync(path: PathLike, flag: string, mode?: Node.Mode): number {
-	return getFdForFile(_openSync(path, flag, mode, true));
+export function openSync(path: fs.PathLike, flag: fs.OpenMode, mode: fs.Mode | null = F_OK): number {
+	return file2fd(_openSync(path, flag, mode, true));
 }
-openSync satisfies typeof Node.openSync;
+openSync satisfies typeof fs.openSync;
 
 /**
  * Opens a file or symlink
  * @internal
  */
-export function lopenSync(path: PathLike, flag: string, mode?: Node.Mode): number {
-	return getFdForFile(_openSync(path, flag, mode, false));
+export function lopenSync(path: fs.PathLike, flag: string, mode?: fs.Mode | null): number {
+	return file2fd(_openSync(path, flag, mode, false));
 }
 
 /**
@@ -212,24 +211,24 @@ function _readFileSync(fname: string, flag: string, resolveSymlinks: boolean): U
 
 /**
  * Synchronously reads the entire contents of a file.
- * @param filename
+ * @param path
  * @param options
  * @option options encoding The string encoding for the file contents. Defaults to `null`.
  * @option options flag Defaults to `'r'`.
  * @returns file contents
  */
-export function readFileSync(filename: string, options?: { flag?: string }): Buffer;
-export function readFileSync(filename: string, options: (Node.EncodingOption & { flag?: string }) | BufferEncoding): string;
-export function readFileSync(filename: string, arg2: Node.WriteFileOptions = {}): FileContents {
-	const options = normalizeOptions(arg2, null, 'r', 0o644);
+export function readFileSync(path: fs.PathOrFileDescriptor, options?: { flag?: string } | null): Buffer;
+export function readFileSync(path: fs.PathOrFileDescriptor, options?: (fs.EncodingOption & { flag?: string }) | BufferEncoding | null): string;
+export function readFileSync(path: fs.PathOrFileDescriptor, _options: fs.WriteFileOptions | null = {}): FileContents {
+	const options = normalizeOptions(_options, null, 'r', 0o644);
 	const flag = parseFlag(options.flag);
 	if (!isReadable(flag)) {
 		throw new ApiError(ErrorCode.EINVAL, 'Flag passed to readFile must allow for reading.');
 	}
-	const data: Buffer = Buffer.from(_readFileSync(filename, options.flag, true));
+	const data: Buffer = Buffer.from(_readFileSync(typeof path == 'number' ? fd2file(path).path! : path.toString(), options.flag, true));
 	return options.encoding ? data.toString(options.encoding) : data;
 }
-readFileSync satisfies typeof Node.readFileSync;
+readFileSync satisfies typeof fs.readFileSync;
 
 /**
  * Synchronously writes data to a file, replacing the file
@@ -240,7 +239,7 @@ readFileSync satisfies typeof Node.readFileSync;
 function _writeFileSync(fname: string, data: Uint8Array, flag: string, mode: number, resolveSymlinks: boolean): void {
 	const file = _openSync(fname, flag, mode, resolveSymlinks);
 	try {
-		file.writeSync(data, 0, data.length, 0);
+		file.writeSync(data, 0, data.byteLength, 0);
 	} finally {
 		file.closeSync();
 	}
@@ -251,16 +250,16 @@ function _writeFileSync(fname: string, data: Uint8Array, flag: string, mode: num
  * exists.
  *
  * The encoding option is ignored if data is a buffer.
- * @param filename
+ * @param path
  * @param data
  * @param options
  * @option options encoding Defaults to `'utf8'`.
  * @option options mode Defaults to `0644`.
  * @option options flag Defaults to `'w'`.
  */
-export function writeFileSync(filename: string, data: FileContents, options?: Node.WriteFileOptions): void;
-export function writeFileSync(filename: string, data: FileContents, encoding?: BufferEncoding): void;
-export function writeFileSync(filename: string, data: FileContents, _options?: Node.WriteFileOptions | BufferEncoding): void {
+export function writeFileSync(path: fs.PathOrFileDescriptor, data: FileContents, options?: fs.WriteFileOptions): void;
+export function writeFileSync(path: fs.PathOrFileDescriptor, data: FileContents, encoding?: BufferEncoding): void;
+export function writeFileSync(path: fs.PathOrFileDescriptor, data: FileContents, _options: fs.WriteFileOptions | BufferEncoding = {}): void {
 	const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
 	const flag = parseFlag(options.flag);
 	if (!isWriteable(flag)) {
@@ -269,13 +268,13 @@ export function writeFileSync(filename: string, data: FileContents, _options?: N
 	if (typeof data != 'string' && !options.encoding) {
 		throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
 	}
-	const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
-	if (encodedData === undefined) {
+	const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding!) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+	if (!encodedData) {
 		throw new ApiError(ErrorCode.EINVAL, 'Data not specified');
 	}
-	_writeFileSync(filename, encodedData, options.flag, options.mode, true);
+	_writeFileSync(typeof path == 'number' ? fd2file(path).path! : path.toString(), encodedData, options.flag, options.mode, true);
 }
-writeFileSync satisfies typeof Node.writeFileSync;
+writeFileSync satisfies typeof fs.writeFileSync;
 
 /**
  * Synchronously append data to a file, creating the file if
@@ -284,7 +283,7 @@ writeFileSync satisfies typeof Node.writeFileSync;
 function _appendFileSync(fname: string, data: Uint8Array, flag: string, mode: number, resolveSymlinks: boolean): void {
 	const file = _openSync(fname, flag, mode, resolveSymlinks);
 	try {
-		file.writeSync(data, 0, data.length, null);
+		file.writeSync(data, 0, data.byteLength, null);
 	} finally {
 		file.closeSync();
 	}
@@ -301,7 +300,7 @@ function _appendFileSync(fname: string, data: Uint8Array, flag: string, mode: nu
  * @option options mode Defaults to `0644`.
  * @option options flag Defaults to `'a'`.
  */
-export function appendFileSync(filename: string, data: FileContents, _options?: Node.WriteFileOptions): void {
+export function appendFileSync(filename: fs.PathOrFileDescriptor, data: FileContents, _options: fs.WriteFileOptions = {}): void {
 	const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
 	const flag = parseFlag(options.flag);
 	if (!isAppendable(flag)) {
@@ -310,10 +309,10 @@ export function appendFileSync(filename: string, data: FileContents, _options?:
 	if (typeof data != 'string' && !options.encoding) {
 		throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
 	}
-	const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
-	_appendFileSync(filename, encodedData, options.flag, options.mode, true);
+	const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding!) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+	_appendFileSync(typeof filename == 'number' ? fd2file(filename).path! : filename.toString(), encodedData, options.flag, options.mode, true);
 }
-appendFileSync satisfies typeof Node.appendFileSync;
+appendFileSync satisfies typeof fs.appendFileSync;
 
 /**
  * Synchronous `fstat`.
@@ -321,13 +320,13 @@ appendFileSync satisfies typeof Node.appendFileSync;
  * specified by the file descriptor `fd`.
  * @param fd
  */
-export function fstatSync(fd: number, options?: { bigint?: false }): Stats;
+export function fstatSync(fd: number, options?: { bigint?: boolean }): Stats;
 export function fstatSync(fd: number, options: { bigint: true }): BigIntStats;
-export function fstatSync(fd: number, options?: StatOptions): Stats | BigIntStats {
+export function fstatSync(fd: number, options?: fs.StatOptions): Stats | BigIntStats {
 	const stats: Stats = fd2file(fd).statSync();
 	return options?.bigint ? new BigIntStats(stats) : stats;
 }
-fstatSync satisfies typeof Node.fstatSync;
+fstatSync satisfies typeof fs.fstatSync;
 
 /**
  * Synchronous close.
@@ -337,20 +336,21 @@ export function closeSync(fd: number): void {
 	fd2file(fd).closeSync();
 	fdMap.delete(fd);
 }
-closeSync satisfies typeof Node.closeSync;
+closeSync satisfies typeof fs.closeSync;
 
 /**
  * Synchronous ftruncate.
  * @param fd
  * @param len
  */
-export function ftruncateSync(fd: number, len: number = 0): void {
+export function ftruncateSync(fd: number, len: number | null = 0): void {
+	len ||= 0;
 	if (len < 0) {
 		throw new ApiError(ErrorCode.EINVAL);
 	}
 	fd2file(fd).truncateSync(len);
 }
-ftruncateSync satisfies typeof Node.ftruncateSync;
+ftruncateSync satisfies typeof fs.ftruncateSync;
 
 /**
  * Synchronous fsync.
@@ -359,7 +359,7 @@ ftruncateSync satisfies typeof Node.ftruncateSync;
 export function fsyncSync(fd: number): void {
 	fd2file(fd).syncSync();
 }
-fsyncSync satisfies typeof Node.fsyncSync;
+fsyncSync satisfies typeof fs.fsyncSync;
 
 /**
  * Synchronous fdatasync.
@@ -368,7 +368,7 @@ fsyncSync satisfies typeof Node.fsyncSync;
 export function fdatasyncSync(fd: number): void {
 	fd2file(fd).datasyncSync();
 }
-fdatasyncSync satisfies typeof Node.fdatasyncSync;
+fdatasyncSync satisfies typeof fs.fdatasyncSync;
 
 /**
  * Write buffer to the file specified by `fd`.
@@ -383,35 +383,30 @@ fdatasyncSync satisfies typeof Node.fdatasyncSync;
  *   data should be written. If position is null, the data will be written at
  *   the current position.
  */
-export function writeSync(fd: number, data: Uint8Array, offset: number, length: number, position?: number): number;
-export function writeSync(fd: number, data: string, position?: number, encoding?: BufferEncoding): number;
-export function writeSync(fd: number, data: FileContents, posOrOff?: number, lenOrEnc?: BufferEncoding | number, pos?: number): number {
-	let buffer: Uint8Array,
-		offset: number = 0,
-		length: number,
-		position: number;
+export function writeSync(fd: number, data: ArrayBufferView, offset?: number | null, length?: number | null, position?: number | null): number;
+export function writeSync(fd: number, data: string, position?: number | null, encoding?: BufferEncoding | null): number;
+export function writeSync(fd: number, data: FileContents, posOrOff?: number | null, lenOrEnc?: BufferEncoding | number | null, pos?: number | null): number {
+	let buffer: Uint8Array, offset: number | undefined, length: number, position: number | null;
 	if (typeof data === 'string') {
 		// Signature 1: (fd, string, [position?, [encoding?]])
 		position = typeof posOrOff === 'number' ? posOrOff : null;
 		const encoding = <BufferEncoding>(typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8');
 		offset = 0;
 		buffer = Buffer.from(data, encoding);
-		length = buffer.length;
+		length = buffer.byteLength;
 	} else {
 		// Signature 2: (fd, buffer, offset, length, position?)
-		buffer = data;
-		offset = posOrOff;
-		length = lenOrEnc as number;
+		buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+		offset = posOrOff!;
+		length = <number>lenOrEnc;
 		position = typeof pos === 'number' ? pos : null;
 	}
 
 	const file = fd2file(fd);
-	if (position === undefined || position === null) {
-		position = file.position!;
-	}
+	position ??= file.position;
 	return file.writeSync(buffer, offset, length, position);
 }
-writeSync satisfies typeof Node.writeSync;
+writeSync satisfies typeof fs.writeSync;
 
 /**
  * Read data from the file specified by `fd`.
@@ -425,9 +420,9 @@ writeSync satisfies typeof Node.writeSync;
  *   in the file. If position is null, data will be read from the current file
  *   position.
  */
-export function readSync(fd: number, buffer: Uint8Array, opts?: ReadSyncOptions): number;
-export function readSync(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number): number;
-export function readSync(fd: number, buffer: Uint8Array, opts?: ReadSyncOptions | number, length?: number, position?: number | bigint): number {
+export function readSync(fd: number, buffer: ArrayBufferView, opts?: fs.ReadSyncOptions): number;
+export function readSync(fd: number, buffer: ArrayBufferView, offset: number, length: number, position?: fs.ReadPosition | null): number;
+export function readSync(fd: number, buffer: ArrayBufferView, opts?: fs.ReadSyncOptions | number, length?: number, position?: fs.ReadPosition | null): number {
 	const file = fd2file(fd);
 	const offset = typeof opts == 'object' ? opts.offset : opts;
 	if (typeof opts == 'object') {
@@ -442,7 +437,7 @@ export function readSync(fd: number, buffer: Uint8Array, opts?: ReadSyncOptions
 
 	return file.readSync(buffer, offset, length, position);
 }
-readSync satisfies typeof Node.readSync;
+readSync satisfies typeof fs.readSync;
 
 /**
  * Synchronous `fchown`.
@@ -453,7 +448,7 @@ readSync satisfies typeof Node.readSync;
 export function fchownSync(fd: number, uid: number, gid: number): void {
 	fd2file(fd).chownSync(uid, gid);
 }
-fchownSync satisfies typeof Node.fchownSync;
+fchownSync satisfies typeof fs.fchownSync;
 
 /**
  * Synchronous `fchmod`.
@@ -467,7 +462,7 @@ export function fchmodSync(fd: number, mode: number | string): void {
 	}
 	fd2file(fd).chmodSync(numMode);
 }
-fchmodSync satisfies typeof Node.fchmodSync;
+fchmodSync satisfies typeof fs.fchmodSync;
 
 /**
  * Change the file timestamps of a file referenced by the supplied file
@@ -479,16 +474,16 @@ fchmodSync satisfies typeof Node.fchmodSync;
 export function futimesSync(fd: number, atime: string | number | Date, mtime: string | number | Date): void {
 	fd2file(fd).utimesSync(normalizeTime(atime), normalizeTime(mtime));
 }
-futimesSync satisfies typeof Node.futimesSync;
+futimesSync satisfies typeof fs.futimesSync;
 
 /**
  * Synchronous `rmdir`.
  * @param path
  */
-export function rmdirSync(path: PathLike): void {
-	return doOp('rmdirSync', true, path, cred);
+export function rmdirSync(path: fs.PathLike): void {
+	return doOp('rmdirSync', true, path.toString(), cred);
 }
-rmdirSync satisfies typeof Node.rmdirSync;
+rmdirSync satisfies typeof fs.rmdirSync;
 
 /**
  * Synchronous `mkdir`.
@@ -496,23 +491,28 @@ rmdirSync satisfies typeof Node.rmdirSync;
  * @param mode defaults to o777
  * @todo Implement recursion
  */
-export function mkdirSync(path: PathLike, options: Node.MakeDirectoryOptions & { recursive: true }): string;
-export function mkdirSync(path: PathLike, options?: Node.Mode | (Node.MakeDirectoryOptions & { recursive?: false })): void;
-export function mkdirSync(path: PathLike, options?: Node.Mode | Node.MakeDirectoryOptions): string | void {
-	const mode: Node.Mode = typeof options == 'number' || typeof options == 'string' ? options : options?.mode;
+export function mkdirSync(path: fs.PathLike, options: fs.MakeDirectoryOptions & { recursive: true }): string | undefined;
+export function mkdirSync(path: fs.PathLike, options?: fs.Mode | (fs.MakeDirectoryOptions & { recursive?: false }) | null): void;
+export function mkdirSync(path: fs.PathLike, options?: fs.Mode | fs.MakeDirectoryOptions | null): string | undefined;
+export function mkdirSync(path: fs.PathLike, options?: fs.Mode | fs.MakeDirectoryOptions | null): string | undefined | void {
+	const mode: fs.Mode | undefined = typeof options == 'number' || typeof options == 'string' ? options : options?.mode;
 	const recursive = typeof options == 'object' && options?.recursive;
-	doOp('mkdirSync', true, path, normalizeMode(mode, 0o777), cred);
+	doOp('mkdirSync', true, path.toString(), normalizeMode(mode, 0o777), cred);
 }
-mkdirSync satisfies typeof Node.mkdirSync;
+mkdirSync satisfies typeof fs.mkdirSync;
 
 /**
  * Synchronous `readdir`. Reads the contents of a directory.
  * @param path
  */
-export function readdirSync(path: PathLike, options?: { encoding?: BufferEncoding; withFileTypes?: false } | BufferEncoding): string[];
-export function readdirSync(path: PathLike, options: { encoding: 'buffer'; withFileTypes?: false } | 'buffer'): Buffer[];
-export function readdirSync(path: PathLike, options: { withFileTypes: true }): Dirent[];
-export function readdirSync(path: PathLike, options?: { encoding?: BufferEncoding | 'buffer'; withFileTypes?: boolean } | string): string[] | Dirent[] | Buffer[] {
+export function readdirSync(path: fs.PathLike, options?: { recursive?: boolean; encoding?: BufferEncoding | null; withFileTypes?: false } | BufferEncoding | null): string[];
+export function readdirSync(path: fs.PathLike, options: { recursive?: boolean; encoding: 'buffer'; withFileTypes?: false } | 'buffer'): Buffer[];
+export function readdirSync(path: fs.PathLike, options: { recursive?: boolean; withFileTypes: true }): Dirent[];
+export function readdirSync(path: fs.PathLike, options?: (fs.ObjectEncodingOptions & { withFileTypes?: false; recursive?: boolean }) | BufferEncoding | null): string[] | Buffer[];
+export function readdirSync(
+	path: fs.PathLike,
+	options?: { recursive?: boolean; encoding?: BufferEncoding | 'buffer' | null; withFileTypes?: boolean } | BufferEncoding | 'buffer' | null
+): string[] | Dirent[] | Buffer[] {
 	path = normalizePath(path);
 	const entries: string[] = doOp('readdirSync', true, path, cred);
 	for (const mount of mounts.keys()) {
@@ -526,19 +526,19 @@ export function readdirSync(path: PathLike, options?: { encoding?: BufferEncodin
 		}
 		entries.push(entry);
 	}
-	return <string[] | Dirent[] | Buffer[]>entries.map((entry: string): string | Dirent | Buffer => {
+	return <string[] | Dirent[] | Buffer[]>entries.map((entry: string) => {
 		if (typeof options == 'object' && options?.withFileTypes) {
-			return new Dirent(entry, statSync(join(path, entry)));
+			return new Dirent(entry, statSync(join(path.toString(), entry)));
 		}
 
-		if (options == 'buffer' || (typeof options == 'object' && options.encoding == 'buffer')) {
+		if (options == 'buffer' || (typeof options == 'object' && options?.encoding == 'buffer')) {
 			return Buffer.from(entry);
 		}
 
 		return entry;
 	});
 }
-readdirSync satisfies typeof Node.readdirSync;
+readdirSync satisfies typeof fs.readdirSync;
 
 // SYMLINK METHODS
 
@@ -547,11 +547,11 @@ readdirSync satisfies typeof Node.readdirSync;
  * @param existing
  * @param newpath
  */
-export function linkSync(existing: PathLike, newpath: PathLike): void {
+export function linkSync(existing: fs.PathLike, newpath: fs.PathLike): void {
 	newpath = normalizePath(newpath);
-	return doOp('linkSync', false, existing, newpath, cred);
+	return doOp('linkSync', false, existing.toString(), newpath.toString(), cred);
 }
-linkSync satisfies typeof Node.linkSync;
+linkSync satisfies typeof fs.linkSync;
 
 /**
  * Synchronous `symlink`.
@@ -559,35 +559,35 @@ linkSync satisfies typeof Node.linkSync;
  * @param path link path
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
-export function symlinkSync(target: PathLike, path: PathLike, type: symlink.Type = 'file'): void {
-	if (!['file', 'dir', 'junction'].includes(type)) {
+export function symlinkSync(target: fs.PathLike, path: fs.PathLike, type: fs.symlink.Type | null = 'file'): void {
+	if (!['file', 'dir', 'junction'].includes(type!)) {
 		throw new ApiError(ErrorCode.EINVAL, 'Invalid type: ' + type);
 	}
 	if (existsSync(path)) {
-		throw ApiError.With('EEXIST', path, 'symlink');
+		throw ApiError.With('EEXIST', path.toString(), 'symlink');
 	}
 
-	writeFileSync(path, target);
+	writeFileSync(path, target.toString());
 	const file = _openSync(path, 'r+', 0o644, false);
 	file._setTypeSync(FileType.SYMLINK);
 }
-symlinkSync satisfies typeof Node.symlinkSync;
+symlinkSync satisfies typeof fs.symlinkSync;
 
 /**
  * Synchronous readlink.
  * @param path
  */
-export function readlinkSync(path: PathLike, options?: BufferEncodingOption): Buffer;
-export function readlinkSync(path: PathLike, options: EncodingOption | BufferEncoding): string;
-export function readlinkSync(path: PathLike, options?: EncodingOption | BufferEncoding | BufferEncodingOption): Buffer | string {
-	const value: Buffer = Buffer.from(_readFileSync(path, 'r', false));
-	const encoding: BufferEncoding | 'buffer' = typeof options == 'object' ? options.encoding : options;
+export function readlinkSync(path: fs.PathLike, options?: fs.BufferEncodingOption): Buffer;
+export function readlinkSync(path: fs.PathLike, options: fs.EncodingOption | BufferEncoding): string;
+export function readlinkSync(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding | fs.BufferEncodingOption): Buffer | string {
+	const value: Buffer = Buffer.from(_readFileSync(path.toString(), 'r', false));
+	const encoding = typeof options == 'object' ? options?.encoding : options;
 	if (encoding == 'buffer') {
 		return value;
 	}
-	return value.toString(encoding);
+	return value.toString(encoding!);
 }
-readlinkSync satisfies typeof Node.readlinkSync;
+readlinkSync satisfies typeof fs.readlinkSync;
 
 // PROPERTY OPERATIONS
 
@@ -597,12 +597,12 @@ readlinkSync satisfies typeof Node.readlinkSync;
  * @param uid
  * @param gid
  */
-export function chownSync(path: PathLike, uid: number, gid: number): void {
+export function chownSync(path: fs.PathLike, uid: number, gid: number): void {
 	const fd = openSync(path, 'r+');
 	fchownSync(fd, uid, gid);
 	closeSync(fd);
 }
-chownSync satisfies typeof Node.chownSync;
+chownSync satisfies typeof fs.chownSync;
 
 /**
  * Synchronous `lchown`.
@@ -610,36 +610,36 @@ chownSync satisfies typeof Node.chownSync;
  * @param uid
  * @param gid
  */
-export function lchownSync(path: PathLike, uid: number, gid: number): void {
+export function lchownSync(path: fs.PathLike, uid: number, gid: number): void {
 	const fd = lopenSync(path, 'r+');
 	fchownSync(fd, uid, gid);
 	closeSync(fd);
 }
-lchownSync satisfies typeof Node.lchownSync;
+lchownSync satisfies typeof fs.lchownSync;
 
 /**
  * Synchronous `chmod`.
  * @param path
  * @param mode
  */
-export function chmodSync(path: PathLike, mode: Node.Mode): void {
+export function chmodSync(path: fs.PathLike, mode: fs.Mode): void {
 	const fd = openSync(path, 'r+');
 	fchmodSync(fd, mode);
 	closeSync(fd);
 }
-chmodSync satisfies typeof Node.chmodSync;
+chmodSync satisfies typeof fs.chmodSync;
 
 /**
  * Synchronous `lchmod`.
  * @param path
  * @param mode
  */
-export function lchmodSync(path: PathLike, mode: number | string): void {
+export function lchmodSync(path: fs.PathLike, mode: number | string): void {
 	const fd = lopenSync(path, 'r+');
 	fchmodSync(fd, mode);
 	closeSync(fd);
 }
-lchmodSync satisfies typeof Node.lchmodSync;
+lchmodSync satisfies typeof fs.lchmodSync;
 
 /**
  * Change file timestamps of the file referenced by the supplied path.
@@ -647,12 +647,12 @@ lchmodSync satisfies typeof Node.lchmodSync;
  * @param atime
  * @param mtime
  */
-export function utimesSync(path: PathLike, atime: string | number | Date, mtime: string | number | Date): void {
+export function utimesSync(path: fs.PathLike, atime: string | number | Date, mtime: string | number | Date): void {
 	const fd = openSync(path, 'r+');
 	futimesSync(fd, atime, mtime);
 	closeSync(fd);
 }
-utimesSync satisfies typeof Node.utimesSync;
+utimesSync satisfies typeof fs.utimesSync;
 
 /**
  * Change file timestamps of the file referenced by the supplied path.
@@ -660,12 +660,12 @@ utimesSync satisfies typeof Node.utimesSync;
  * @param atime
  * @param mtime
  */
-export function lutimesSync(path: PathLike, atime: string | number | Date, mtime: string | number | Date): void {
+export function lutimesSync(path: fs.PathLike, atime: string | number | Date, mtime: string | number | Date): void {
 	const fd = lopenSync(path, 'r+');
 	futimesSync(fd, atime, mtime);
 	closeSync(fd);
 }
-lutimesSync satisfies typeof Node.lutimesSync;
+lutimesSync satisfies typeof fs.lutimesSync;
 
 /**
  * Synchronous `realpath`.
@@ -675,9 +675,9 @@ lutimesSync satisfies typeof Node.lutimesSync;
  *   known real paths.
  * @returns the real path
  */
-export function realpathSync(path: PathLike, options: BufferEncodingOption): Buffer;
-export function realpathSync(path: PathLike, options?: EncodingOption): string;
-export function realpathSync(path: PathLike, options?: EncodingOption | BufferEncodingOption): string | Buffer {
+export function realpathSync(path: fs.PathLike, options: fs.BufferEncodingOption): Buffer;
+export function realpathSync(path: fs.PathLike, options?: fs.EncodingOption): string;
+export function realpathSync(path: fs.PathLike, options?: fs.EncodingOption | fs.BufferEncodingOption): string | Buffer {
 	path = normalizePath(path);
 	const { base, dir } = parse(path);
 	const lpath = join(dir == '/' ? '/' : realpathSync(dir), base);
@@ -691,29 +691,29 @@ export function realpathSync(path: PathLike, options?: EncodingOption | BufferEn
 
 		return realpathSync(mountPoint + readlinkSync(lpath));
 	} catch (e) {
-		throw fixError(e, { [resolvedPath]: lpath });
+		throw fixError(<Error>e, { [resolvedPath]: lpath });
 	}
 }
-realpathSync satisfies Omit<typeof Node.realpathSync, 'native'>;
+realpathSync satisfies Omit<typeof fs.realpathSync, 'native'>;
 
 /**
  * Synchronous `access`.
  * @param path
  * @param mode
  */
-export function accessSync(path: PathLike, mode: number = 0o600): void {
+export function accessSync(path: fs.PathLike, mode: number = 0o600): void {
 	const stats = statSync(path);
 	if (!stats.hasAccess(mode, cred)) {
 		throw new ApiError(ErrorCode.EACCES);
 	}
 }
-accessSync satisfies typeof Node.accessSync;
+accessSync satisfies typeof fs.accessSync;
 
 /**
  * Synchronous `rm`. Removes files or directories (recursively).
  * @param path The path to the file or directory to remove.
  */
-export function rmSync(path: PathLike, options?: Node.RmOptions): void {
+export function rmSync(path: fs.PathLike, options?: fs.RmOptions): void {
 	path = normalizePath(path);
 
 	const stats = statSync(path);
@@ -740,7 +740,7 @@ export function rmSync(path: PathLike, options?: Node.RmOptions): void {
 			throw new ApiError(ErrorCode.EPERM, 'File type not supported', path, 'rm');
 	}
 }
-rmSync satisfies typeof Node.rmSync;
+rmSync satisfies typeof fs.rmSync;
 
 /**
  * Synchronous `mkdtemp`. Creates a unique temporary directory.
@@ -748,10 +748,10 @@ rmSync satisfies typeof Node.rmSync;
  * @param options The encoding (or an object including `encoding`).
  * @returns The path to the created temporary directory, encoded as a string or buffer.
  */
-export function mkdtempSync(prefix: string, options: BufferEncodingOption): Buffer;
-export function mkdtempSync(prefix: string, options?: EncodingOption): string;
-export function mkdtempSync(prefix: string, options?: EncodingOption | BufferEncodingOption): string | Buffer {
-	const encoding = typeof options === 'object' ? options.encoding : options || 'utf8';
+export function mkdtempSync(prefix: string, options: fs.BufferEncodingOption): Buffer;
+export function mkdtempSync(prefix: string, options?: fs.EncodingOption): string;
+export function mkdtempSync(prefix: string, options?: fs.EncodingOption | fs.BufferEncodingOption): string | Buffer {
+	const encoding = typeof options === 'object' ? options?.encoding : options || 'utf8';
 	const fsName = `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`;
 	const resolvedPath = '/tmp/' + fsName;
 
@@ -759,7 +759,7 @@ export function mkdtempSync(prefix: string, options?: EncodingOption | BufferEnc
 
 	return encoding == 'buffer' ? Buffer.from(resolvedPath) : resolvedPath;
 }
-mkdtempSync satisfies typeof Node.mkdtempSync;
+mkdtempSync satisfies typeof fs.mkdtempSync;
 
 /**
  * Synchronous `copyFile`. Copies a file.
@@ -768,7 +768,7 @@ mkdtempSync satisfies typeof Node.mkdtempSync;
  * @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(src: PathLike, dest: PathLike, flags?: number): void {
+export function copyFileSync(src: fs.PathLike, dest: fs.PathLike, flags?: number): void {
 	src = normalizePath(src);
 	dest = normalizePath(dest);
 
@@ -778,7 +778,7 @@ export function copyFileSync(src: PathLike, dest: PathLike, flags?: number): voi
 
 	writeFileSync(dest, readFileSync(src));
 }
-copyFileSync satisfies typeof Node.copyFileSync;
+copyFileSync satisfies typeof fs.copyFileSync;
 
 /**
  * Synchronous `readv`. Reads from a file descriptor into multiple buffers.
@@ -787,17 +787,17 @@ copyFileSync satisfies typeof Node.copyFileSync;
  * @param position The position in the file where to begin reading.
  * @returns The number of bytes read.
  */
-export function readvSync(fd: number, buffers: readonly Uint8Array[], position?: number): number {
+export function readvSync(fd: number, buffers: readonly NodeJS.ArrayBufferView[], position?: number): number {
 	const file = fd2file(fd);
 	let bytesRead = 0;
 
 	for (const buffer of buffers) {
-		bytesRead += file.readSync(buffer, 0, buffer.length, position + bytesRead);
+		bytesRead += file.readSync(buffer, 0, buffer.byteLength, position! + bytesRead);
 	}
 
 	return bytesRead;
 }
-readvSync satisfies typeof Node.readvSync;
+readvSync satisfies typeof fs.readvSync;
 
 /**
  * Synchronous `writev`. Writes from multiple buffers into a file descriptor.
@@ -806,17 +806,17 @@ readvSync satisfies typeof Node.readvSync;
  * @param position The position in the file where to begin writing.
  * @returns The number of bytes written.
  */
-export function writevSync(fd: number, buffers: readonly Uint8Array[], position?: number): number {
+export function writevSync(fd: number, buffers: readonly ArrayBufferView[], position?: number): number {
 	const file = fd2file(fd);
 	let bytesWritten = 0;
 
 	for (const buffer of buffers) {
-		bytesWritten += file.writeSync(buffer, 0, buffer.length, position + bytesWritten);
+		bytesWritten += file.writeSync(new Uint8Array(buffer.buffer), 0, buffer.byteLength, position! + bytesWritten);
 	}
 
 	return bytesWritten;
 }
-writevSync satisfies typeof Node.writevSync;
+writevSync satisfies typeof fs.writevSync;
 
 /**
  * Synchronous `opendir`. Opens a directory.
@@ -824,11 +824,11 @@ writevSync satisfies typeof Node.writevSync;
  * @param options Options for opening the directory.
  * @returns A `Dir` object representing the opened directory.
  */
-export function opendirSync(path: PathLike, options?: Node.OpenDirOptions): Dir {
+export function opendirSync(path: fs.PathLike, options?: fs.OpenDirOptions): Dir {
 	path = normalizePath(path);
 	return new Dir(path); // Re-use existing `Dir` class
 }
-opendirSync satisfies typeof Node.opendirSync;
+opendirSync satisfies typeof fs.opendirSync;
 
 /**
  * Synchronous `cp`. Recursively copies a file or directory.
@@ -842,7 +842,7 @@ opendirSync satisfies typeof Node.opendirSync;
  *   * `preserveTimestamps`: Preserve file timestamps.
  *   * `recursive`: If `true`, copies directories recursively.
  */
-export function cpSync(source: PathLike, destination: PathLike, opts?: Node.CopySyncOptions): void {
+export function cpSync(source: fs.PathLike, destination: fs.PathLike, opts?: fs.CopySyncOptions): void {
 	source = normalizePath(source);
 	destination = normalizePath(destination);
 
@@ -882,7 +882,7 @@ export function cpSync(source: PathLike, destination: PathLike, opts?: Node.Copy
 		utimesSync(destination, srcStats.atime, srcStats.mtime);
 	}
 }
-cpSync satisfies typeof Node.cpSync;
+cpSync satisfies typeof fs.cpSync;
 
 /**
  * Synchronous statfs(2). Returns information about the mounted file system which contains path.
@@ -890,9 +890,9 @@ cpSync satisfies typeof Node.cpSync;
  * @param path A path to an existing file or directory on the file system to be queried.
  * @param callback
  */
-export function statfsSync(path: PathLike, options?: Node.StatFsOptions & { bigint?: false }): StatsFs;
-export function statfsSync(path: PathLike, options: Node.StatFsOptions & { bigint: true }): BigIntStatsFs;
-export function statfsSync(path: PathLike, options?: Node.StatFsOptions): StatsFs | BigIntStatsFs;
-export function statfsSync(path: PathLike, options?: Node.StatFsOptions): StatsFs | BigIntStatsFs {
-	throw ApiError.With('ENOSYS', path, 'statfs');
+export function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions & { bigint?: false }): StatsFs;
+export function statfsSync(path: fs.PathLike, options: fs.StatFsOptions & { bigint: true }): BigIntStatsFs;
+export function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): StatsFs | BigIntStatsFs;
+export function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): StatsFs | BigIntStatsFs {
+	throw ApiError.With('ENOSYS', path.toString(), 'statfs');
 }