@zenfs/core 0.12.0 → 0.12.2

package/dist/config.d.ts

@@ -1,25 +1,47 @@
-import type { Backend, BackendConfiguration } from './backends/backend.js';
-import { FileSystem } from './filesystem.js';
+import type { Backend, BackendConfiguration, FilesystemOf } from './backends/backend.js';
 import type { AbsolutePath } from './emulation/path.js';
 /**
  * Configuration for a specific mount point
  */
-export type MountConfiguration<FS extends FileSystem = FileSystem, TOptions extends object = object> = FS | BackendConfiguration<Backend<FS, TOptions>> | Backend<FS, TOptions>;
+export type MountConfiguration<T extends Backend> = FilesystemOf<T> | BackendConfiguration<T> | T;
 /**
  * Retrieve a file system with the given configuration.
  * @param config A BackendConfig object.
  */
-export declare function resolveMountConfig<FS extends FileSystem, TOptions extends object = object>(config: MountConfiguration<FS, TOptions>, _depth?: number): Promise<FS>;
+export declare function resolveMountConfig<T extends Backend>(config: MountConfiguration<T>, _depth?: number): Promise<FilesystemOf<T>>;
+type ConfigMounts = {
+    [K in AbsolutePath]: Backend;
+};
 /**
  * Configuration
  */
-export interface Configuration {
-    mounts: Record<AbsolutePath, MountConfiguration>;
-    uid?: number;
-    gid?: number;
+export interface Configuration<T extends ConfigMounts> {
+    /**
+     * An object mapping mount points to mount configuration
+     */
+    mounts: {
+        [K in keyof T & AbsolutePath]: MountConfiguration<T[K]>;
+    };
+    /**
+     * The uid to use
+     */
+    uid: number;
+    /**
+     * The gid to use
+     */
+    gid: number;
+    /**
+     * If set, disables the sync cache and sync operations on async file systems.
+     */
+    disableAsyncCache: boolean;
 }
 /**
- * Creates filesystems with the given configuration, and initializes ZenFS with it.
- * @see Configuration for more info on the configuration object.
+ * Configures ZenFS with single mount point /
  */
-export declare function configure<T extends MountConfiguration | Configuration>(config: T | Configuration): Promise<void>;
+export declare function configure<T extends Backend>(config: MountConfiguration<T>): Promise<void>;
+/**
+ * Configures ZenFS with the given configuration
+ * @see Configuration
+ */
+export declare function configure<T extends ConfigMounts>(config: Partial<Configuration<T>>): Promise<void>;
+export {};

package/dist/config.js

@@ -1,7 +1,7 @@
-import { ErrnoError, Errno } from './error.js';
 import { checkOptions, isBackend, isBackendConfig } from './backends/backend.js';
 import * as fs from './emulation/index.js';
 import { setCred } from './emulation/shared.js';
+import { Errno, ErrnoError } from './error.js';
 import { FileSystem } from './filesystem.js';
 function isMountConfig(arg) {
     return isBackendConfig(arg) || isBackend(arg) || arg instanceof FileSystem;
@@ -40,13 +40,16 @@ export async function resolveMountConfig(config, _depth = 0) {
         throw new ErrnoError(Errno.EPERM, 'Backend not available: ' + backend);
     }
     checkOptions(backend, config);
-    const mount = await backend.create(config);
+    const mount = (await backend.create(config));
+    if ('_disableSync' in mount) {
+        mount._disableSync = config.disableAsyncCache || false;
+    }
     await mount.ready();
     return mount;
 }
 /**
- * Creates filesystems with the given configuration, and initializes ZenFS with it.
- * @see Configuration for more info on the configuration object.
+ * Configures ZenFS with the given configuration
+ * @see Configuration
  */
 export async function configure(config) {
     const uid = 'uid' in config ? config.uid || 0 : 0;
@@ -55,12 +58,18 @@ export async function configure(config) {
         // single FS
         config = { mounts: { '/': config } };
     }
-    for (const [point, value] of Object.entries(config.mounts)) {
+    setCred({ uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
+    if (!config.mounts) {
+        return;
+    }
+    for (const [point, mountConfig] of Object.entries(config.mounts)) {
         if (!point.startsWith('/')) {
             throw new ErrnoError(Errno.EINVAL, 'Mount points must have absolute paths');
         }
-        config.mounts[point] = await resolveMountConfig(value);
+        if (isBackendConfig(mountConfig)) {
+            mountConfig.disableAsyncCache ?? (mountConfig.disableAsyncCache = config.disableAsyncCache || false);
+        }
+        config.mounts[point] = await resolveMountConfig(mountConfig);
     }
     fs.mountObject(config.mounts);
-    setCred({ uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
 }

package/dist/emulation/async.d.ts

@@ -1,9 +1,10 @@
 /// <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 fs from 'node:fs';
 import type { FileContents } from '../filesystem.js';
-import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
+import { BigIntStats, type Stats } from '../stats.js';
 import { type Callback } from '../utils.js';
 import { Dirent, type Dir } from './dir.js';
 import * as promises from './promises.js';
@@ -440,12 +441,12 @@ export declare function opendir(path: fs.PathLike, cb: Callback<[Dir]>): void;
 export declare function opendir(path: fs.PathLike, options: fs.OpenDirOptions, cb: Callback<[Dir]>): void;
 export declare function cp(source: fs.PathLike, destination: fs.PathLike, callback: Callback): void;
 export declare function cp(source: fs.PathLike, destination: fs.PathLike, opts: fs.CopyOptions, callback: Callback): void;
-export declare function statfs(path: fs.PathLike, callback: Callback<[StatsFs]>): void;
+export declare function statfs(path: fs.PathLike, callback: Callback<[fs.StatsFs]>): void;
 export declare function statfs(path: fs.PathLike, options: fs.StatFsOptions & {
     bigint?: false;
-}, callback: Callback<[StatsFs]>): void;
+}, callback: Callback<[fs.StatsFs]>): void;
 export declare function statfs(path: fs.PathLike, options: fs.StatFsOptions & {
     bigint: true;
-}, callback: Callback<[BigIntStatsFs]>): void;
+}, callback: Callback<[fs.BigIntStatsFs]>): void;
 export declare function openAsBlob(path: fs.PathLike, options?: fs.OpenAsBlobOptions): Promise<Blob>;
 export {};

package/dist/emulation/async.js

@@ -1,3 +1,4 @@
+import { Buffer } from 'buffer';
 import { ErrnoError, Errno } from '../error.js';
 import { BigIntStats } from '../stats.js';
 import { nop, normalizeMode } from '../utils.js';
@@ -173,7 +174,7 @@ export function write(fd, data, cbPosOff, cbLenEnc, cbPos, cb = nop) {
             case 'number':
                 // (fd, string, position, encoding?, cb?)
                 position = cbPosOff;
-                encoding = (typeof cbLenEnc === 'string' ? cbLenEnc : 'utf8');
+                encoding = typeof cbLenEnc === 'string' ? cbLenEnc : 'utf8';
                 cb = typeof cbPos === 'function' ? cbPos : cb;
                 break;
             default:
@@ -197,7 +198,7 @@ export function write(fd, data, cbPosOff, cbLenEnc, cbPos, cb = nop) {
         offset = cbPosOff;
         length = cbLenEnc;
         position = typeof cbPos === 'number' ? cbPos : null;
-        const _cb = (typeof cbPos === 'function' ? cbPos : cb);
+        const _cb = typeof cbPos === 'function' ? cbPos : cb;
         handle
             .write(buffer, offset, length, position)
             .then(({ bytesWritten }) => _cb(undefined, bytesWritten, buffer))

package/dist/emulation/index.d.ts

@@ -5,4 +5,4 @@ export * as constants from './constants.js';
 export * from './streams.js';
 export * from './dir.js';
 export { mountObject, mounts, mount, umount } from './shared.js';
-export { Stats, BigIntStats, StatsFs } from '../stats.js';
+export { Stats, StatsFs, BigIntStatsFs } from '../stats.js';

package/dist/emulation/index.js

@@ -5,4 +5,4 @@ export * as constants from './constants.js';
 export * from './streams.js';
 export * from './dir.js';
 export { mountObject, mounts, mount, umount } from './shared.js';
-export { Stats, BigIntStats, StatsFs } from '../stats.js';
+export { Stats, StatsFs, BigIntStatsFs } from '../stats.js';

package/dist/emulation/path.d.ts

@@ -1,5 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
 import type { ParsedPath } from 'node:path';
+/**
+ * An absolute path
+ */
 export type AbsolutePath = `/${string}`;
 export declare let cwd: string;
 export declare function cd(path: string): void;
@@ -8,7 +11,7 @@ export declare function normalizeString(path: string, allowAboveRoot: boolean):
 export declare function formatExt(ext: string): string;
 export declare function resolve(...parts: string[]): AbsolutePath;
 export declare function normalize(path: string): string;
-export declare function isAbsolute(path: string): boolean;
+export declare function isAbsolute(path: string): path is AbsolutePath;
 export declare function join(...parts: string[]): string;
 export declare function relative(from: string, to: string): string;
 export declare function dirname(path: string): string;

package/dist/emulation/promises.d.ts

@@ -14,7 +14,7 @@ import type { ReadableStream as TReadableStream } from 'node:stream/web';
 import type { Interface as ReadlineInterface } from 'readline';
 import { File } from '../file.js';
 import type { FileContents } from '../filesystem.js';
-import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
+import { BigIntStats, type Stats } from '../stats.js';
 import { Dir, Dirent } from './dir.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
@@ -437,8 +437,8 @@ export declare function cp(source: fs.PathLike, destination: fs.PathLike, opts?:
  */
 export declare function statfs(path: fs.PathLike, opts?: fs.StatFsOptions & {
     bigint?: false;
-}): Promise<StatsFs>;
+}): Promise<fs.StatsFs>;
 export declare function statfs(path: fs.PathLike, opts: fs.StatFsOptions & {
     bigint: true;
-}): Promise<BigIntStatsFs>;
-export declare function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<StatsFs | BigIntStatsFs>;
+}): Promise<fs.BigIntStatsFs>;
+export declare function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<fs.StatsFs | fs.BigIntStatsFs>;

package/dist/emulation/promises.js

@@ -1,12 +1,12 @@
 import { Buffer } from 'buffer';
-import { ErrnoError, Errno } from '../error.js';
+import { Errno, ErrnoError } from '../error.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 * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
+import { _statfs, cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
 export class FileHandle {
@@ -162,7 +162,7 @@ export class FileHandle {
         if (typeof data === 'string') {
             // Signature 1: (fd, string, [position?, [encoding?]])
             position = typeof posOrOff === 'number' ? posOrOff : null;
-            const encoding = (typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8');
+            const encoding = typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8';
             offset = 0;
             buffer = Buffer.from(data, encoding);
             length = buffer.length;
@@ -386,29 +386,7 @@ async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
     const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
     path = resolveSymlinks && (await exists(path)) ? await realpath(path) : path;
     const { fs, path: resolved } = resolveMount(path);
-    try {
-        switch (pathExistsAction(flag)) {
-            case ActionType.THROW:
-                throw ErrnoError.With('EEXIST', path, '_open');
-            case ActionType.TRUNCATE:
-                /*
-                    In a previous implementation, we deleted the file and
-                    re-created it. However, this created a race condition if another
-                    asynchronous request was trying to read the file, as the file
-                    would not exist for a small period of time.
-                */
-                const file = await fs.openFile(resolved, flag, cred);
-                await file.truncate(0);
-                await file.sync();
-                return new FileHandle(file);
-            case ActionType.NOP:
-                // Must await so thrown errors are caught by the catch below
-                return new FileHandle(await fs.openFile(resolved, flag, cred));
-            default:
-                throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
-        }
-    }
-    catch (e) {
+    if (!(await fs.exists(path, cred))) {
         switch (pathNotExistsAction(flag)) {
             case ActionType.CREATE:
                 // Ensure parent exists.
@@ -423,6 +401,26 @@ async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
                 throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
         }
     }
+    switch (pathExistsAction(flag)) {
+        case ActionType.THROW:
+            throw ErrnoError.With('EEXIST', path, '_open');
+        case ActionType.TRUNCATE:
+            /*
+                    In a previous implementation, we deleted the file and
+                    re-created it. However, this created a race condition if another
+                    asynchronous request was trying to read the file, as the file
+                    would not exist for a small period of time.
+                */
+            const file = await fs.openFile(resolved, flag, cred);
+            await file.truncate(0);
+            await file.sync();
+            return new FileHandle(file);
+        case ActionType.NOP:
+            // Must await so thrown errors are caught by the catch below
+            return new FileHandle(await fs.openFile(resolved, flag, cred));
+        default:
+            throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
+    }
 }
 /**
  * Asynchronous file open.
@@ -847,5 +845,7 @@ export async function cp(source, destination, opts) {
 }
 cp;
 export async function statfs(path, opts) {
-    throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
+    path = normalizePath(path);
+    const { fs } = resolveMount(path);
+    return _statfs(fs, opts?.bigint);
 }

package/dist/emulation/shared.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { BigIntStatsFs, StatsFs } from 'node:fs';
 import { Cred } from '../cred.js';
 import type { File } from '../file.js';
 import { FileSystem } from '../filesystem.js';
@@ -35,3 +37,7 @@ export declare function resolveMount(path: string): {
 export declare function fixPaths(text: string, paths: Record<string, string>): string;
 export declare function fixError<E extends Error>(e: E, paths: Record<string, string>): E;
 export declare function mountObject(mounts: MountObject): void;
+/**
+ * @hidden
+ */
+export declare function _statfs<const T extends boolean>(fs: FileSystem, bigint?: T): T extends true ? BigIntStatsFs : StatsFs;

package/dist/emulation/shared.js

@@ -1,7 +1,9 @@
 // Utilities and shared data
-import { ErrnoError, Errno } from '../error.js';
 import { InMemory } from '../backends/memory.js';
 import { rootCred } from '../cred.js';
+import { Errno, ErrnoError } from '../error.js';
+import { size_max } from '../inode.js';
+import { ZenFsType } from '../stats.js';
 import { normalizePath } from '../utils.js';
 import { resolve } from './path.js';
 // credentials
@@ -100,3 +102,19 @@ export function mountObject(mounts) {
         mount(point, fs);
     }
 }
+/**
+ * @hidden
+ */
+export function _statfs(fs, bigint) {
+    const md = fs.metadata();
+    const bs = md.blockSize || 4096;
+    return {
+        type: (bigint ? BigInt : Number)(md.type || ZenFsType),
+        bsize: (bigint ? BigInt : Number)(bs),
+        ffree: (bigint ? BigInt : Number)(md.freeNodes || size_max),
+        files: (bigint ? BigInt : Number)(md.totalNodes || size_max),
+        bavail: (bigint ? BigInt : Number)(md.freeSpace / bs),
+        bfree: (bigint ? BigInt : Number)(md.freeSpace / bs),
+        blocks: (bigint ? BigInt : Number)(md.totalSpace / bs),
+    };
+}

package/dist/emulation/sync.d.ts

@@ -4,7 +4,7 @@
 import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
 import { FileContents } from '../filesystem.js';
-import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
+import { BigIntStats, type Stats } from '../stats.js';
 import { Dir, Dirent } from './dir.js';
 /**
  * Synchronous rename.
@@ -368,8 +368,8 @@ export declare function cpSync(source: fs.PathLike, destination: fs.PathLike, op
  */
 export declare function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions & {
     bigint?: false;
-}): StatsFs;
+}): fs.StatsFs;
 export declare function statfsSync(path: fs.PathLike, options: fs.StatFsOptions & {
     bigint: true;
-}): BigIntStatsFs;
-export declare function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): StatsFs | BigIntStatsFs;
+}): fs.BigIntStatsFs;
+export declare function statfsSync(path: fs.PathLike, options?: fs.StatFsOptions): fs.StatsFs | fs.BigIntStatsFs;

package/dist/emulation/sync.js

@@ -1,23 +1,12 @@
 import { Buffer } from 'buffer';
-import { ErrnoError, Errno } from '../error.js';
+import { Errno, ErrnoError } from '../error.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, 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, file2fd, mounts, resolveMount } from './shared.js';
-function wrap(...[name, resolveSymlinks, path, ...args]) {
-    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);
-    }
-    catch (e) {
-        throw fixError(e, { [resolvedPath]: path });
-    }
-}
+import { _statfs, cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
 /**
  * Synchronous rename.
  * @param oldPath
@@ -60,13 +49,27 @@ export function existsSync(path) {
 }
 existsSync;
 export function statSync(path, options) {
-    const stats = wrap('statSync', true, path.toString(), cred);
-    return options?.bigint ? new BigIntStats(stats) : stats;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    try {
+        const stats = fs.statSync(resolved, cred);
+        return options?.bigint ? new BigIntStats(stats) : stats;
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 statSync;
 export function lstatSync(path, options) {
-    const stats = wrap('statSync', false, path.toString(), cred);
-    return options?.bigint ? new BigIntStats(stats) : stats;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path);
+    try {
+        const stats = fs.statSync(resolved, cred);
+        return options?.bigint ? new BigIntStats(stats) : stats;
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 lstatSync;
 /**
@@ -89,32 +92,37 @@ truncateSync;
  * @param path
  */
 export function unlinkSync(path) {
-    return wrap('unlinkSync', false, path.toString(), cred);
-}
-unlinkSync;
-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;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path);
     try {
-        stats = wrap('statSync', resolveSymlinks, path, cred);
+        return fs.unlinkSync(resolved, cred);
     }
     catch (e) {
-        // File does not exist.
+        throw fixError(e, { [resolved]: path });
+    }
+}
+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;
+    const { fs, path: resolved } = resolveMount(path);
+    if (!fs.existsSync(resolved, cred)) {
         switch (pathNotExistsAction(flag)) {
             case ActionType.CREATE:
                 // Ensure parent exists.
-                const parentStats = wrap('statSync', resolveSymlinks, dirname(path), cred);
+                const parentStats = fs.statSync(dirname(resolved), cred);
                 if (!parentStats.isDirectory()) {
                     throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
                 }
-                return wrap('createFileSync', resolveSymlinks, path, flag, mode, cred);
+                return fs.createFileSync(resolved, flag, mode, cred);
             case ActionType.THROW:
                 throw ErrnoError.With('ENOENT', path, '_open');
             default:
                 throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
         }
     }
+    const stats = fs.statSync(resolved, cred);
     if (!stats.hasAccess(mode, cred)) {
         throw ErrnoError.With('EACCES', path, '_open');
     }
@@ -124,16 +132,16 @@ function _openSync(_path, _flag, _mode, resolveSymlinks = true) {
             throw ErrnoError.With('EEXIST', path, '_open');
         case ActionType.TRUNCATE:
             // Delete file.
-            wrap('unlinkSync', resolveSymlinks, path, cred);
+            fs.unlinkSync(resolved, cred);
             /*
                 Create file. Use the same mode as the old file.
                 Node itself modifies the ctime when this occurs, so this action
                 will preserve that behavior if the underlying file system
                 supports those properties.
             */
-            return wrap('createFileSync', resolveSymlinks, path, flag, stats.mode, cred);
+            return fs.createFileSync(resolved, flag, stats.mode, cred);
         case ActionType.NOP:
-            return wrap('openFileSync', resolveSymlinks, path, flag, cred);
+            return fs.openFileSync(resolved, flag, cred);
         default:
             throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
     }
@@ -285,7 +293,7 @@ export function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
     if (typeof data === 'string') {
         // Signature 1: (fd, string, [position?, [encoding?]])
         position = typeof posOrOff === 'number' ? posOrOff : null;
-        const encoding = (typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8');
+        const encoding = typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8';
         offset = 0;
         buffer = Buffer.from(data, encoding);
         length = buffer.byteLength;
@@ -355,18 +363,39 @@ futimesSync;
  * @param path
  */
 export function rmdirSync(path) {
-    return wrap('rmdirSync', true, path.toString(), cred);
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    try {
+        fs.rmdirSync(resolved, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 rmdirSync;
 export function mkdirSync(path, options) {
-    const mode = typeof options == 'number' || typeof options == 'string' ? options : options?.mode;
+    const mode = normalizeMode(typeof options == 'number' || typeof options == 'string' ? options : options?.mode, 0o777);
     const recursive = typeof options == 'object' && options?.recursive;
-    wrap('mkdirSync', true, path.toString(), normalizeMode(mode, 0o777), cred);
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    try {
+        return fs.mkdirSync(resolved, mode, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
 }
 mkdirSync;
 export function readdirSync(path, options) {
     path = normalizePath(path);
-    const entries = wrap('readdirSync', true, path, cred);
+    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    let entries;
+    try {
+        entries = fs.readdirSync(resolved, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: path });
+    }
     for (const mount of mounts.keys()) {
         if (!mount.startsWith(path)) {
             continue;
@@ -396,8 +425,15 @@ readdirSync;
  * @param newpath
  */
 export function linkSync(existing, newpath) {
+    existing = normalizePath(existing);
     newpath = normalizePath(newpath);
-    return wrap('linkSync', false, existing.toString(), newpath.toString(), cred);
+    const { fs, path: resolved } = resolveMount(existing);
+    try {
+        return fs.linkSync(resolved, newpath, cred);
+    }
+    catch (e) {
+        throw fixError(e, { [resolved]: existing });
+    }
 }
 linkSync;
 /**
@@ -673,5 +709,7 @@ export function cpSync(source, destination, opts) {
 }
 cpSync;
 export function statfsSync(path, options) {
-    throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
+    path = normalizePath(path);
+    const { fs } = resolveMount(path);
+    return _statfs(fs, options?.bigint);
 }

package/dist/file.d.ts

@@ -204,7 +204,7 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     readonly stats: Stats;
     protected _buffer: Uint8Array;
     protected _position: number;
-    protected _dirty: boolean;
+    protected dirty: boolean;
     /**
      * Creates a file with the given path and, optionally, the given contents. Note
      * that, if contents is specified, it will be mutated by the file!
@@ -259,14 +259,14 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     statSync(): Stats;
     /**
      * Asynchronous truncate.
-     * @param len
+     * @param length
      */
-    truncate(len: number): Promise<void>;
+    truncate(length: number): Promise<void>;
     /**
      * Synchronous truncate.
-     * @param len
+     * @param length
      */
-    truncateSync(len: number): void;
+    truncateSync(length: number): void;
     /**
      * Write buffer to the file.
      * Note that it is unsafe to use fs.write multiple times on the same file
@@ -345,11 +345,6 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     chownSync(uid: number, gid: number): void;
     utimes(atime: Date, mtime: Date): Promise<void>;
     utimesSync(atime: Date, mtime: Date): void;
-    protected isDirty(): boolean;
-    /**
-     * Resets the dirty bit. Should only be called after a sync has completed successfully.
-     */
-    protected resetDirty(): void;
     _setType(type: FileType): Promise<void>;
     _setTypeSync(type: FileType): void;
 }