@zenfs/core 0.9.6 → 0.9.7

package/dist/emulation/sync.d.ts

@@ -1,32 +1,31 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { Buffer } from 'buffer';
-import type * as Node from 'fs';
-import type { BufferEncodingOption, EncodingOption, ReadSyncOptions, symlink } from 'fs';
+import type * as fs from 'node:fs';
 import { FileContents } from '../filesystem.js';
 import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
 import { Dir, Dirent } from './dir.js';
-import { PathLike } from './shared.js';
 /**
  * Synchronous rename.
  * @param oldPath
  * @param newPath
  */
-export declare function renameSync(oldPath: PathLike, newPath: PathLike): void;
+export declare function renameSync(oldPath: fs.PathLike, newPath: fs.PathLike): void;
 /**
  * Test whether or not the given path exists by checking with the file system.
  * @param path
  */
-export declare function existsSync(path: PathLike): boolean;
+export declare function existsSync(path: fs.PathLike): boolean;
 /**
  * Synchronous `stat`.
  * @param path
  * @returns Stats
  */
-export declare function statSync(path: PathLike, options?: {
-    bigint?: false;
+export declare function statSync(path: fs.PathLike, options?: {
+    bigint?: boolean;
 }): Stats;
-export declare function statSync(path: PathLike, options: {
+export declare function statSync(path: fs.PathLike, options: {
     bigint: true;
 }): BigIntStats;
 /**
@@ -35,10 +34,10 @@ export declare function statSync(path: PathLike, options: {
  * then the link itself is stat-ed, not the file that it refers to.
  * @param path
  */
-export declare function lstatSync(path: PathLike, options?: {
-    bigint?: false;
+export declare function lstatSync(path: fs.PathLike, options?: {
+    bigint?: boolean;
 }): Stats;
-export declare function lstatSync(path: PathLike, options: {
+export declare function lstatSync(path: fs.PathLike, options: {
     bigint: true;
 }): BigIntStats;
 /**
@@ -46,12 +45,12 @@ export declare function lstatSync(path: PathLike, options: {
  * @param path
  * @param len
  */
-export declare function truncateSync(path: PathLike, len?: number): void;
+export declare function truncateSync(path: fs.PathLike, len?: number | null): void;
 /**
  * Synchronous `unlink`.
  * @param path
  */
-export declare function unlinkSync(path: PathLike): void;
+export declare function unlinkSync(path: fs.PathLike): void;
 /**
  * Synchronous file open.
  * @see http://www.manpagez.com/man/2/open/
@@ -60,40 +59,40 @@ export declare function unlinkSync(path: PathLike): void;
  * @param mode Mode to use to open the file. Can be ignored if the
  *   filesystem doesn't support permissions.
  */
-export declare function openSync(path: PathLike, flag: string, mode?: Node.Mode): number;
+export declare function openSync(path: fs.PathLike, flag: fs.OpenMode, mode?: fs.Mode | null): number;
 /**
  * Opens a file or symlink
  * @internal
  */
-export declare function lopenSync(path: PathLike, flag: string, mode?: Node.Mode): number;
+export declare function lopenSync(path: fs.PathLike, flag: string, mode?: fs.Mode | null): number;
 /**
  * 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 declare function readFileSync(filename: string, options?: {
+export declare function readFileSync(path: fs.PathOrFileDescriptor, options?: {
     flag?: string;
-}): Buffer;
-export declare function readFileSync(filename: string, options: (Node.EncodingOption & {
+} | null): Buffer;
+export declare function readFileSync(path: fs.PathOrFileDescriptor, options?: (fs.EncodingOption & {
     flag?: string;
-}) | BufferEncoding): string;
+}) | BufferEncoding | null): string;
 /**
  * Synchronously writes data to a file, replacing the file if it already
  * 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 declare function writeFileSync(filename: string, data: FileContents, options?: Node.WriteFileOptions): void;
-export declare function writeFileSync(filename: string, data: FileContents, encoding?: BufferEncoding): void;
+export declare function writeFileSync(path: fs.PathOrFileDescriptor, data: FileContents, options?: fs.WriteFileOptions): void;
+export declare function writeFileSync(path: fs.PathOrFileDescriptor, data: FileContents, encoding?: BufferEncoding): void;
 /**
  * Asynchronously append data to a file, creating the file if it not yet
  * exists.
@@ -105,7 +104,7 @@ export declare function writeFileSync(filename: string, data: FileContents, enco
  * @option options mode Defaults to `0644`.
  * @option options flag Defaults to `'a'`.
  */
-export declare function appendFileSync(filename: string, data: FileContents, _options?: Node.WriteFileOptions): void;
+export declare function appendFileSync(filename: fs.PathOrFileDescriptor, data: FileContents, _options?: fs.WriteFileOptions): void;
 /**
  * Synchronous `fstat`.
  * `fstat()` is identical to `stat()`, except that the file to be stat-ed is
@@ -113,7 +112,7 @@ export declare function appendFileSync(filename: string, data: FileContents, _op
  * @param fd
  */
 export declare function fstatSync(fd: number, options?: {
-    bigint?: false;
+    bigint?: boolean;
 }): Stats;
 export declare function fstatSync(fd: number, options: {
     bigint: true;
@@ -128,7 +127,7 @@ export declare function closeSync(fd: number): void;
  * @param fd
  * @param len
  */
-export declare function ftruncateSync(fd: number, len?: number): void;
+export declare function ftruncateSync(fd: number, len?: number | null): void;
 /**
  * Synchronous fsync.
  * @param fd
@@ -152,8 +151,8 @@ export declare function fdatasyncSync(fd: number): void;
  *   data should be written. If position is null, the data will be written at
  *   the current position.
  */
-export declare function writeSync(fd: number, data: Uint8Array, offset: number, length: number, position?: number): number;
-export declare function writeSync(fd: number, data: string, position?: number, encoding?: BufferEncoding): number;
+export declare function writeSync(fd: number, data: ArrayBufferView, offset?: number | null, length?: number | null, position?: number | null): number;
+export declare function writeSync(fd: number, data: string, position?: number | null, encoding?: BufferEncoding | null): number;
 /**
  * Read data from the file specified by `fd`.
  * @param fd
@@ -166,8 +165,8 @@ export declare function writeSync(fd: number, data: string, position?: number, e
  *   in the file. If position is null, data will be read from the current file
  *   position.
  */
-export declare function readSync(fd: number, buffer: Uint8Array, opts?: ReadSyncOptions): number;
-export declare function readSync(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number): number;
+export declare function readSync(fd: number, buffer: ArrayBufferView, opts?: fs.ReadSyncOptions): number;
+export declare function readSync(fd: number, buffer: ArrayBufferView, offset: number, length: number, position?: fs.ReadPosition | null): number;
 /**
  * Synchronous `fchown`.
  * @param fd
@@ -193,93 +192,101 @@ export declare function futimesSync(fd: number, atime: string | number | Date, m
  * Synchronous `rmdir`.
  * @param path
  */
-export declare function rmdirSync(path: PathLike): void;
+export declare function rmdirSync(path: fs.PathLike): void;
 /**
  * Synchronous `mkdir`.
  * @param path
  * @param mode defaults to o777
  * @todo Implement recursion
  */
-export declare function mkdirSync(path: PathLike, options: Node.MakeDirectoryOptions & {
+export declare function mkdirSync(path: fs.PathLike, options: fs.MakeDirectoryOptions & {
     recursive: true;
-}): string;
-export declare function mkdirSync(path: PathLike, options?: Node.Mode | (Node.MakeDirectoryOptions & {
+}): string | undefined;
+export declare function mkdirSync(path: fs.PathLike, options?: fs.Mode | (fs.MakeDirectoryOptions & {
     recursive?: false;
-})): void;
+}) | null): void;
+export declare function mkdirSync(path: fs.PathLike, options?: fs.Mode | fs.MakeDirectoryOptions | null): string | undefined;
 /**
  * Synchronous `readdir`. Reads the contents of a directory.
  * @param path
  */
-export declare function readdirSync(path: PathLike, options?: {
-    encoding?: BufferEncoding;
+export declare function readdirSync(path: fs.PathLike, options?: {
+    recursive?: boolean;
+    encoding?: BufferEncoding | null;
     withFileTypes?: false;
-} | BufferEncoding): string[];
-export declare function readdirSync(path: PathLike, options: {
+} | BufferEncoding | null): string[];
+export declare function readdirSync(path: fs.PathLike, options: {
+    recursive?: boolean;
     encoding: 'buffer';
     withFileTypes?: false;
 } | 'buffer'): Buffer[];
-export declare function readdirSync(path: PathLike, options: {
+export declare function readdirSync(path: fs.PathLike, options: {
+    recursive?: boolean;
     withFileTypes: true;
 }): Dirent[];
+export declare function readdirSync(path: fs.PathLike, options?: (fs.ObjectEncodingOptions & {
+    withFileTypes?: false;
+    recursive?: boolean;
+}) | BufferEncoding | null): string[] | Buffer[];
 /**
  * Synchronous `link`.
  * @param existing
  * @param newpath
  */
-export declare function linkSync(existing: PathLike, newpath: PathLike): void;
+export declare function linkSync(existing: fs.PathLike, newpath: fs.PathLike): void;
 /**
  * Synchronous `symlink`.
  * @param target target path
  * @param path link path
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
-export declare function symlinkSync(target: PathLike, path: PathLike, type?: symlink.Type): void;
+export declare function symlinkSync(target: fs.PathLike, path: fs.PathLike, type?: fs.symlink.Type | null): void;
 /**
  * Synchronous readlink.
  * @param path
  */
-export declare function readlinkSync(path: PathLike, options?: BufferEncodingOption): Buffer;
-export declare function readlinkSync(path: PathLike, options: EncodingOption | BufferEncoding): string;
+export declare function readlinkSync(path: fs.PathLike, options?: fs.BufferEncodingOption): Buffer;
+export declare function readlinkSync(path: fs.PathLike, options: fs.EncodingOption | BufferEncoding): string;
 /**
  * Synchronous `chown`.
  * @param path
  * @param uid
  * @param gid
  */
-export declare function chownSync(path: PathLike, uid: number, gid: number): void;
+export declare function chownSync(path: fs.PathLike, uid: number, gid: number): void;
 /**
  * Synchronous `lchown`.
  * @param path
  * @param uid
  * @param gid
  */
-export declare function lchownSync(path: PathLike, uid: number, gid: number): void;
+export declare function lchownSync(path: fs.PathLike, uid: number, gid: number): void;
 /**
  * Synchronous `chmod`.
  * @param path
  * @param mode
  */
-export declare function chmodSync(path: PathLike, mode: Node.Mode): void;
+export declare function chmodSync(path: fs.PathLike, mode: fs.Mode): void;
 /**
  * Synchronous `lchmod`.
  * @param path
  * @param mode
  */
-export declare function lchmodSync(path: PathLike, mode: number | string): void;
+export declare function lchmodSync(path: fs.PathLike, mode: number | string): void;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  * @param path
  * @param atime
  * @param mtime
  */
-export declare function utimesSync(path: PathLike, atime: string | number | Date, mtime: string | number | Date): void;
+export declare function utimesSync(path: fs.PathLike, atime: string | number | Date, mtime: string | number | Date): void;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  * @param path
  * @param atime
  * @param mtime
  */
-export declare function lutimesSync(path: PathLike, atime: string | number | Date, mtime: string | number | Date): void;
+export declare function lutimesSync(path: fs.PathLike, atime: string | number | Date, mtime: string | number | Date): void;
 /**
  * Synchronous `realpath`.
  * @param path
@@ -288,27 +295,27 @@ export declare function lutimesSync(path: PathLike, atime: string | number | Dat
  *   known real paths.
  * @returns the real path
  */
-export declare function realpathSync(path: PathLike, options: BufferEncodingOption): Buffer;
-export declare function realpathSync(path: PathLike, options?: EncodingOption): string;
+export declare function realpathSync(path: fs.PathLike, options: fs.BufferEncodingOption): Buffer;
+export declare function realpathSync(path: fs.PathLike, options?: fs.EncodingOption): string;
 /**
  * Synchronous `access`.
  * @param path
  * @param mode
  */
-export declare function accessSync(path: PathLike, mode?: number): void;
+export declare function accessSync(path: fs.PathLike, mode?: number): void;
 /**
  * Synchronous `rm`. Removes files or directories (recursively).
  * @param path The path to the file or directory to remove.
  */
-export declare function rmSync(path: PathLike, options?: Node.RmOptions): void;
+export declare function rmSync(path: fs.PathLike, options?: fs.RmOptions): void;
 /**
  * Synchronous `mkdtemp`. Creates a unique temporary directory.
  * @param prefix The directory prefix.
  * @param options The encoding (or an object including `encoding`).
  * @returns The path to the created temporary directory, encoded as a string or buffer.
  */
-export declare function mkdtempSync(prefix: string, options: BufferEncodingOption): Buffer;
-export declare function mkdtempSync(prefix: string, options?: EncodingOption): string;
+export declare function mkdtempSync(prefix: string, options: fs.BufferEncodingOption): Buffer;
+export declare function mkdtempSync(prefix: string, options?: fs.EncodingOption): string;
 /**
  * Synchronous `copyFile`. Copies a file.
  * @param src The source file.
@@ -316,7 +323,7 @@ export declare function mkdtempSync(prefix: string, options?: EncodingOption): s
  * @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 declare function copyFileSync(src: PathLike, dest: PathLike, flags?: number): void;
+export declare function copyFileSync(src: fs.PathLike, dest: fs.PathLike, flags?: number): void;
 /**
  * Synchronous `readv`. Reads from a file descriptor into multiple buffers.
  * @param fd The file descriptor.
@@ -324,7 +331,7 @@ export declare function copyFileSync(src: PathLike, dest: PathLike, flags?: numb
  * @param position The position in the file where to begin reading.
  * @returns The number of bytes read.
  */
-export declare function readvSync(fd: number, buffers: readonly Uint8Array[], position?: number): number;
+export declare function readvSync(fd: number, buffers: readonly NodeJS.ArrayBufferView[], position?: number): number;
 /**
  * Synchronous `writev`. Writes from multiple buffers into a file descriptor.
  * @param fd The file descriptor.
@@ -332,14 +339,14 @@ export declare function readvSync(fd: number, buffers: readonly Uint8Array[], po
  * @param position The position in the file where to begin writing.
  * @returns The number of bytes written.
  */
-export declare function writevSync(fd: number, buffers: readonly Uint8Array[], position?: number): number;
+export declare function writevSync(fd: number, buffers: readonly ArrayBufferView[], position?: number): number;
 /**
  * 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.
  */
-export declare function opendirSync(path: PathLike, options?: Node.OpenDirOptions): Dir;
+export declare function opendirSync(path: fs.PathLike, options?: fs.OpenDirOptions): Dir;
 /**
  * Synchronous `cp`. Recursively copies a file or directory.
  * @param source The source file or directory.
@@ -352,17 +359,17 @@ export declare function opendirSync(path: PathLike, options?: Node.OpenDirOption
  *   * `preserveTimestamps`: Preserve file timestamps.
  *   * `recursive`: If `true`, copies directories recursively.
  */
-export declare function cpSync(source: PathLike, destination: PathLike, opts?: Node.CopySyncOptions): void;
+export declare function cpSync(source: fs.PathLike, destination: fs.PathLike, opts?: fs.CopySyncOptions): void;
 /**
  * Synchronous statfs(2). Returns information about the mounted file system which contains path.
  * In case of an error, the err.code will be one of Common System Errors.
  * @param path A path to an existing file or directory on the file system to be queried.
  * @param callback
  */
-export declare function statfsSync(path: PathLike, options?: Node.StatFsOptions & {
+export declare function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions & {
     bigint?: false;
 }): StatsFs;
-export declare function statfsSync(path: PathLike, options: Node.StatFsOptions & {
+export declare function statfsSync(path: fs.PathLike, options: fs.StatFsOptions & {
     bigint: true;
 }): BigIntStatsFs;
-export declare function statfsSync(path: PathLike, options?: Node.StatFsOptions): StatsFs | BigIntStatsFs;
+export declare function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): StatsFs | BigIntStatsFs;

package/dist/emulation/sync.js

@@ -3,10 +3,10 @@ import { ApiError, ErrorCode } from '../ApiError.js';
 import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
 import { BigIntStats, FileType } 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 { cred, fd2file, fdMap, fixError, getFdForFile, mounts, resolveMount } from './shared.js';
+import { cred, fd2file, fdMap, fixError, file2fd, mounts, resolveMount } from './shared.js';
 function doOp(...[name, resolveSymlinks, path, ...args]) {
     path = normalizePath(path);
     const { fs, path: resolvedPath } = resolveMount(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
@@ -60,12 +60,12 @@ export function existsSync(path) {
 }
 existsSync;
 export function statSync(path, options) {
-    const stats = doOp('statSync', true, path, cred);
+    const stats = doOp('statSync', true, path.toString(), cred);
     return options?.bigint ? new BigIntStats(stats) : stats;
 }
 statSync;
 export function lstatSync(path, options) {
-    const stats = doOp('statSync', false, path, cred);
+    const stats = doOp('statSync', false, path.toString(), cred);
     return options?.bigint ? new BigIntStats(stats) : stats;
 }
 lstatSync;
@@ -89,10 +89,10 @@ truncateSync;
  * @param path
  */
 export function unlinkSync(path) {
-    return doOp('unlinkSync', false, path, cred);
+    return doOp('unlinkSync', false, path.toString(), cred);
 }
 unlinkSync;
-function _openSync(_path, _flag, _mode, resolveSymlinks) {
+function _openSync(_path, _flag, _mode, resolveSymlinks = true) {
     const path = normalizePath(_path), mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
     // Check if the path exists, and is a file.
     let stats;
@@ -146,8 +146,8 @@ function _openSync(_path, _flag, _mode, resolveSymlinks) {
  * @param mode Mode to use to open the file. Can be ignored if the
  *   filesystem doesn't support permissions.
  */
-export function openSync(path, flag, mode) {
-    return getFdForFile(_openSync(path, flag, mode, true));
+export function openSync(path, flag, mode = F_OK) {
+    return file2fd(_openSync(path, flag, mode, true));
 }
 openSync;
 /**
@@ -155,7 +155,7 @@ openSync;
  * @internal
  */
 export function lopenSync(path, flag, mode) {
-    return getFdForFile(_openSync(path, flag, mode, false));
+    return file2fd(_openSync(path, flag, mode, false));
 }
 /**
  * Synchronously reads the entire contents of a file.
@@ -175,13 +175,13 @@ function _readFileSync(fname, flag, resolveSymlinks) {
         file.closeSync();
     }
 }
-export function readFileSync(filename, arg2 = {}) {
-    const options = normalizeOptions(arg2, null, 'r', 0o644);
+export function readFileSync(path, _options = {}) {
+    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.from(_readFileSync(filename, options.flag, true));
+    const data = Buffer.from(_readFileSync(typeof path == 'number' ? fd2file(path).path : path.toString(), options.flag, true));
     return options.encoding ? data.toString(options.encoding) : data;
 }
 readFileSync;
@@ -194,13 +194,13 @@ readFileSync;
 function _writeFileSync(fname, data, flag, mode, resolveSymlinks) {
     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();
     }
 }
-export function writeFileSync(filename, data, _options) {
+export function writeFileSync(path, data, _options = {}) {
     const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
     const flag = parseFlag(options.flag);
     if (!isWriteable(flag)) {
@@ -209,11 +209,11 @@ export function writeFileSync(filename, data, _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;
-    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;
 /**
@@ -223,7 +223,7 @@ writeFileSync;
 function _appendFileSync(fname, data, flag, mode, resolveSymlinks) {
     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();
@@ -240,7 +240,7 @@ function _appendFileSync(fname, data, flag, mode, resolveSymlinks) {
  * @option options mode Defaults to `0644`.
  * @option options flag Defaults to `'a'`.
  */
-export function appendFileSync(filename, data, _options) {
+export function appendFileSync(filename, data, _options = {}) {
     const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
     const flag = parseFlag(options.flag);
     if (!isAppendable(flag)) {
@@ -249,8 +249,8 @@ export function appendFileSync(filename, data, _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;
 export function fstatSync(fd, options) {
@@ -273,6 +273,7 @@ closeSync;
  * @param len
  */
 export function ftruncateSync(fd, len = 0) {
+    len || (len = 0);
     if (len < 0) {
         throw new ApiError(ErrorCode.EINVAL);
     }
@@ -296,26 +297,24 @@ export function fdatasyncSync(fd) {
 }
 fdatasyncSync;
 export function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
-    let buffer, offset = 0, length, position;
+    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.length;
+        length = buffer.byteLength;
     }
     else {
         // Signature 2: (fd, buffer, offset, length, position?)
-        buffer = data;
+        buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
         offset = posOrOff;
         length = lenOrEnc;
         position = typeof pos === 'number' ? pos : null;
     }
     const file = fd2file(fd);
-    if (position === undefined || position === null) {
-        position = file.position;
-    }
+    position ?? (position = file.position);
     return file.writeSync(buffer, offset, length, position);
 }
 writeSync;
@@ -372,13 +371,13 @@ futimesSync;
  * @param path
  */
 export function rmdirSync(path) {
-    return doOp('rmdirSync', true, path, cred);
+    return doOp('rmdirSync', true, path.toString(), cred);
 }
 rmdirSync;
 export function mkdirSync(path, options) {
     const mode = 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;
 export function readdirSync(path, options) {
@@ -397,9 +396,9 @@ export function readdirSync(path, options) {
     }
     return entries.map((entry) => {
         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;
@@ -414,7 +413,7 @@ readdirSync;
  */
 export function linkSync(existing, newpath) {
     newpath = normalizePath(newpath);
-    return doOp('linkSync', false, existing, newpath, cred);
+    return doOp('linkSync', false, existing.toString(), newpath.toString(), cred);
 }
 linkSync;
 /**
@@ -428,16 +427,16 @@ export function symlinkSync(target, path, type = 'file') {
         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;
 export function readlinkSync(path, options) {
-    const value = Buffer.from(_readFileSync(path, 'r', false));
-    const encoding = typeof options == 'object' ? options.encoding : options;
+    const value = Buffer.from(_readFileSync(path.toString(), 'r', false));
+    const encoding = typeof options == 'object' ? options?.encoding : options;
     if (encoding == 'buffer') {
         return value;
     }
@@ -574,7 +573,7 @@ export function rmSync(path, options) {
 }
 rmSync;
 export function mkdtempSync(prefix, options) {
-    const encoding = typeof options === 'object' ? options.encoding : options || 'utf8';
+    const encoding = typeof options === 'object' ? options?.encoding : options || 'utf8';
     const fsName = `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const resolvedPath = '/tmp/' + fsName;
     mkdirSync(resolvedPath);
@@ -608,7 +607,7 @@ export function readvSync(fd, buffers, position) {
     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;
 }
@@ -624,7 +623,7 @@ export function writevSync(fd, buffers, position) {
     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;
 }
@@ -690,5 +689,5 @@ export function cpSync(source, destination, opts) {
 }
 cpSync;
 export function statfsSync(path, options) {
-    throw ApiError.With('ENOSYS', path, 'statfs');
+    throw ApiError.With('ENOSYS', path.toString(), 'statfs');
 }