@zenfs/core 0.12.1 → 0.12.2

package/dist/file.js

@@ -191,7 +191,7 @@ export class PreloadFile extends File {
         this.stats = stats;
         this._buffer = _buffer;
         this._position = 0;
-        this._dirty = false;
+        this.dirty = false;
         /*
             Note:
             This invariant is *not* maintained once the file starts getting modified.
@@ -203,7 +203,7 @@ export class PreloadFile extends File {
         if (isReadable(this.flag)) {
             throw new Error(`Size mismatch: buffer length ${_buffer.byteLength}, stats size ${this.stats.size}`);
         }
-        this._dirty = true;
+        this.dirty = true;
     }
     /**
      * Get the underlying buffer for this file. Mutating not recommended and will mess up dirty tracking.
@@ -234,18 +234,18 @@ export class PreloadFile extends File {
         this._position = newPos;
     }
     async sync() {
-        if (!this.isDirty()) {
+        if (!this.dirty) {
             return;
         }
         await this.fs.sync(this.path, this._buffer, this.stats);
-        this._dirty = false;
+        this.dirty = false;
     }
     syncSync() {
-        if (!this.isDirty()) {
+        if (!this.dirty) {
             return;
         }
         this.fs.syncSync(this.path, this._buffer, this.stats);
-        this._dirty = false;
+        this.dirty = false;
     }
     async close() {
         await this.sync();
@@ -267,39 +267,32 @@ export class PreloadFile extends File {
     }
     /**
      * Asynchronous truncate.
-     * @param len
+     * @param length
      */
-    async truncate(len) {
-        this.truncateSync(len);
-        if (isSynchronous(this.flag)) {
-            return this.sync();
-        }
+    async truncate(length) {
+        this.truncateSync(length);
+        return this.sync();
     }
     /**
      * Synchronous truncate.
-     * @param len
+     * @param length
      */
-    truncateSync(len) {
-        this._dirty = true;
+    truncateSync(length) {
+        this.dirty = true;
         if (!isWriteable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
         }
         this.stats.mtimeMs = Date.now();
-        if (len > this._buffer.length) {
-            const buf = new Uint8Array(len - this._buffer.length);
-            // Write will set stats.size for us.
-            this.writeSync(buf, 0, buf.length, this._buffer.length);
-            if (isSynchronous(this.flag)) {
-                this.syncSync();
-            }
+        if (length > this._buffer.length) {
+            const data = new Uint8Array(length - this._buffer.length);
+            // Write will set stats.size and handle syncing.
+            this.writeSync(data, 0, data.length, this._buffer.length);
             return;
         }
-        this.stats.size = len;
-        // Truncate buffer to 'len'.
-        this._buffer = this._buffer.subarray(0, len);
-        if (isSynchronous(this.flag)) {
-            this.syncSync();
-        }
+        this.stats.size = length;
+        // Truncate.
+        this._buffer = this._buffer.slice(0, length);
+        this.syncSync();
     }
     /**
      * Write buffer to the file.
@@ -332,7 +325,7 @@ export class PreloadFile extends File {
      * @returns bytes written
      */
     writeSync(buffer, offset = 0, length = this.stats.size, position = 0) {
-        this._dirty = true;
+        this.dirty = true;
         position ?? (position = this.position);
         if (!isWriteable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
@@ -356,11 +349,8 @@ export class PreloadFile extends File {
         this._buffer.set(slice, position);
         const bytesWritten = slice.byteLength;
         this.stats.mtimeMs = Date.now();
-        if (isSynchronous(this.flag)) {
-            this.syncSync();
-            return bytesWritten;
-        }
         this.position = position + bytesWritten;
+        this.syncSync();
         return bytesWritten;
     }
     /**
@@ -392,6 +382,7 @@ export class PreloadFile extends File {
         if (!isReadable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
         }
+        this.dirty = true;
         position ?? (position = this.position);
         let end = position + length;
         if (end > this.stats.size) {
@@ -400,6 +391,7 @@ export class PreloadFile extends File {
         this.stats.atimeMs = Date.now();
         this._position = end;
         const bytesRead = end - position;
+        this.syncSync();
         if (bytesRead == 0) {
             // No copy/read. Return immediatly for better performance
             return bytesRead;
@@ -419,7 +411,7 @@ export class PreloadFile extends File {
      * @param mode
      */
     chmodSync(mode) {
-        this._dirty = true;
+        this.dirty = true;
         this.stats.chmod(mode);
         this.syncSync();
     }
@@ -437,7 +429,7 @@ export class PreloadFile extends File {
      * @param gid
      */
     chownSync(uid, gid) {
-        this._dirty = true;
+        this.dirty = true;
         this.stats.chown(uid, gid);
         this.syncSync();
     }
@@ -445,27 +437,18 @@ export class PreloadFile extends File {
         this.utimesSync(atime, mtime);
     }
     utimesSync(atime, mtime) {
-        this._dirty = true;
+        this.dirty = true;
         this.stats.atime = atime;
         this.stats.mtime = mtime;
         this.syncSync();
     }
-    isDirty() {
-        return this._dirty;
-    }
-    /**
-     * Resets the dirty bit. Should only be called after a sync has completed successfully.
-     */
-    resetDirty() {
-        this._dirty = false;
-    }
     _setType(type) {
-        this._dirty = true;
+        this.dirty = true;
         this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
         return this.sync();
     }
     _setTypeSync(type) {
-        this._dirty = true;
+        this.dirty = true;
         this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
         this.syncSync();
     }

package/dist/filesystem.d.ts

@@ -34,6 +34,23 @@ export interface FileSystemMetadata {
      * @default false
      */
     noAsyncCache: boolean;
+    /**
+     * The optimal block size to use with the file system
+     * @default 4096
+     */
+    blockSize?: number;
+    /**
+     * Total number of (file) nodes available
+     */
+    totalNodes?: number;
+    /**
+     * Number of free (file) nodes available
+     */
+    freeNodes?: number;
+    /**
+     * The type of the FS
+     */
+    type?: number;
 }
 /**
  * Structure for a filesystem. All ZenFS backends must extend this.
@@ -46,11 +63,16 @@ export interface FileSystemMetadata {
  * - All arguments are present. Any optional arguments at the Node API level have been passed in with their default values.
  */
 export declare abstract class FileSystem {
+    /**
+     * Numeric type, used for statfs
+     * @internal @protected
+     */
+    _type?: number;
     /**
      * Get metadata about the current file system
      */
     metadata(): FileSystemMetadata;
-    constructor(options?: object);
+    constructor();
     ready(): Promise<void>;
     /**
      * Asynchronous rename. No arguments other than a possible exception

package/dist/filesystem.js

@@ -24,10 +24,10 @@ export class FileSystem {
             freeSpace: 0,
             noResizableBuffers: false,
             noAsyncCache: false,
+            type: this._type,
         };
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    constructor(options) { }
+    constructor() { }
     async ready() { }
     /**
      * Test whether or not the given path exists by checking with the file system.

package/dist/stats.d.ts

@@ -57,11 +57,9 @@ export interface StatsLike<T extends number | bigint = number | bigint> {
  * Common code used by both Stats and BigIntStats.
  */
 export declare abstract class StatsCommon<T extends number | bigint> implements Node.StatsBase<T>, StatsLike {
-    protected abstract _isBigint: boolean;
-    protected get _typename(): string;
-    protected get _typename_inverse(): string;
+    protected abstract _isBigint: T extends bigint ? true : false;
     protected _convert(arg: number | bigint | string | boolean): T;
-    blocks: T;
+    get blocks(): T;
     /**
      * Unix-style file mode (e.g. 0o644) that includes the type of the item.
      * Type of the item can be FILE, DIRECTORY, SYMLINK, or SOCKET
@@ -184,27 +182,26 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
  * Attribute descriptions are from `man 2 stat'
  * @see http://nodejs.org/api/fs.html#fs_class_fs_stats
  * @see http://man7.org/linux/man-pages/man2/stat.2.html
+ * @internal
  */
 export declare class Stats extends StatsCommon<number> implements Node.Stats, StatsLike {
-    protected _isBigint: boolean;
-    /**
-     * Clones the stats object.
-     * @deprecated use `new Stats(stats)`
-     */
-    static clone(stats: Stats): Stats;
+    protected _isBigint: false;
 }
 /**
  * Stats with bigint
  * @todo Implement with bigint instead of wrapping Stats
+ * @internal
  */
 export declare class BigIntStats extends StatsCommon<bigint> implements Node.BigIntStats, StatsLike {
-    protected _isBigint: boolean;
-    /**
-     * Clone a stats object.
-     * @deprecated use `new BigIntStats(stats)`
-     */
-    static clone(stats: BigIntStats | Stats): BigIntStats;
+    protected _isBigint: true;
 }
+/**
+ * @internal
+ */
+export declare const ZenFsType = 525687744115;
+/**
+ * @hidden
+ */
 export declare class StatsFs implements Node.StatsFsBase<number> {
     /** Type of file system. */
     type: number;
@@ -221,6 +218,9 @@ export declare class StatsFs implements Node.StatsFsBase<number> {
     /** Free file nodes in file system. */
     ffree: number;
 }
+/**
+ * @hidden
+ */
 export declare class BigIntStatsFs implements Node.StatsFsBase<bigint> {
     /** Type of file system. */
     type: bigint;

package/dist/stats.js

@@ -1,4 +1,5 @@
-import { S_IFDIR, S_IFLNK, S_IFMT, S_IFREG, S_IRWXG, S_IRWXO, S_IRWXU } from './emulation/constants.js';
+import { S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK, S_IRWXG, S_IRWXO, S_IRWXU } from './emulation/constants.js';
+import { size_max } from './inode.js';
 /**
  * Indicates the type of the given file. Applied to 'mode'.
  */
@@ -13,15 +14,12 @@ export var FileType;
  * Common code used by both Stats and BigIntStats.
  */
 export class StatsCommon {
-    get _typename() {
-        return this._isBigint ? 'bigint' : 'number';
-    }
-    get _typename_inverse() {
-        return this._isBigint ? 'number' : 'bigint';
-    }
     _convert(arg) {
         return (this._isBigint ? BigInt(arg) : Number(arg));
     }
+    get blocks() {
+        return this._convert(Math.ceil(Number(this.size) / 512));
+    }
     get atime() {
         return new Date(Number(this.atimeMs));
     }
@@ -78,16 +76,15 @@ export class StatsCommon {
          * group ID of owner
          */
         this.gid = this._convert(0);
-        const currentTime = Date.now();
-        const resolveT = (val, _default) => typeof val == this._typename ? val : this._convert(typeof val == this._typename_inverse ? val : _default);
-        this.atimeMs = resolveT(atimeMs, currentTime);
-        this.mtimeMs = resolveT(mtimeMs, currentTime);
-        this.ctimeMs = resolveT(ctimeMs, currentTime);
-        this.birthtimeMs = resolveT(birthtimeMs, currentTime);
-        this.uid = resolveT(uid, 0);
-        this.gid = resolveT(gid, 0);
-        this.size = resolveT(size, 0);
-        this.ino = resolveT(ino, 0);
+        const now = Date.now();
+        this.atimeMs = this._convert(atimeMs ?? now);
+        this.mtimeMs = this._convert(mtimeMs ?? now);
+        this.ctimeMs = this._convert(ctimeMs ?? now);
+        this.birthtimeMs = this._convert(birthtimeMs ?? now);
+        this.uid = this._convert(uid ?? 0);
+        this.gid = this._convert(gid ?? 0);
+        this.size = this._convert(size ?? 0);
+        this.ino = this._convert(ino ?? 0);
         const itemType = Number(mode) & S_IFMT || FileType.FILE;
         if (mode) {
             this.mode = this._convert(mode);
@@ -102,8 +99,6 @@ export class StatsCommon {
                     this.mode = this._convert(0o777);
             }
         }
-        // number of 512B blocks allocated
-        this.blocks = this._convert(Math.ceil(Number(size) / 512));
         // Check if mode also includes top-most bits, which indicate the file's type.
         if ((this.mode & S_IFMT) == 0) {
             this.mode = (this.mode | this._convert(itemType));
@@ -129,16 +124,16 @@ export class StatsCommon {
     }
     // Currently unsupported
     isSocket() {
-        return false;
+        return (this.mode & S_IFMT) === S_IFSOCK;
     }
     isBlockDevice() {
-        return false;
+        return (this.mode & S_IFMT) === S_IFBLK;
     }
     isCharacterDevice() {
-        return false;
+        return (this.mode & S_IFMT) === S_IFCHR;
     }
     isFIFO() {
-        return false;
+        return (this.mode & S_IFMT) === S_IFIFO;
     }
     /**
      * Checks if a given user/group has access to this item
@@ -194,16 +189,16 @@ export class StatsCommon {
         }
     }
     get atimeNs() {
-        return BigInt(this.atimeMs);
+        return BigInt(this.atimeMs) * 1000n;
     }
     get mtimeNs() {
-        return BigInt(this.mtimeMs);
+        return BigInt(this.mtimeMs) * 1000n;
     }
     get ctimeNs() {
-        return BigInt(this.ctimeMs);
+        return BigInt(this.ctimeMs) * 1000n;
     }
     get birthtimeNs() {
-        return BigInt(this.birthtimeMs);
+        return BigInt(this.birthtimeMs) * 1000n;
     }
 }
 /**
@@ -212,44 +207,39 @@ export class StatsCommon {
  * Attribute descriptions are from `man 2 stat'
  * @see http://nodejs.org/api/fs.html#fs_class_fs_stats
  * @see http://man7.org/linux/man-pages/man2/stat.2.html
+ * @internal
  */
 export class Stats extends StatsCommon {
     constructor() {
         super(...arguments);
         this._isBigint = false;
     }
-    /**
-     * Clones the stats object.
-     * @deprecated use `new Stats(stats)`
-     */
-    static clone(stats) {
-        return new Stats(stats);
-    }
 }
 Stats;
 /**
  * Stats with bigint
  * @todo Implement with bigint instead of wrapping Stats
+ * @internal
  */
 export class BigIntStats extends StatsCommon {
     constructor() {
         super(...arguments);
         this._isBigint = true;
     }
-    /**
-     * Clone a stats object.
-     * @deprecated use `new BigIntStats(stats)`
-     */
-    static clone(stats) {
-        return new BigIntStats(stats);
-    }
 }
+/**
+ * @internal
+ */
+export const ZenFsType = 0x7a656e6673; // 'z' 'e' 'n' 'f' 's'
+/**
+ * @hidden
+ */
 export class StatsFs {
     constructor() {
         /** Type of file system. */
-        this.type = 0;
+        this.type = 0x7a656e6673;
         /**  Optimal transfer block size. */
-        this.bsize = 0;
+        this.bsize = 4096;
         /**  Total data blocks in file system. */
         this.blocks = 0;
         /** Free blocks in file system. */
@@ -257,17 +247,20 @@ export class StatsFs {
         /** Available blocks for unprivileged users */
         this.bavail = 0;
         /** Total file nodes in file system. */
-        this.files = 0;
+        this.files = size_max;
         /** Free file nodes in file system. */
-        this.ffree = 0;
+        this.ffree = size_max;
     }
 }
+/**
+ * @hidden
+ */
 export class BigIntStatsFs {
     constructor() {
         /** Type of file system. */
-        this.type = 0n;
+        this.type = 0x7a656e6673n;
         /**  Optimal transfer block size. */
-        this.bsize = 0n;
+        this.bsize = 4096n;
         /**  Total data blocks in file system. */
         this.blocks = 0n;
         /** Free blocks in file system. */
@@ -275,8 +268,8 @@ export class BigIntStatsFs {
         /** Available blocks for unprivileged users */
         this.bavail = 0n;
         /** Total file nodes in file system. */
-        this.files = 0n;
+        this.files = BigInt(size_max);
         /** Free file nodes in file system. */
-        this.ffree = 0n;
+        this.ffree = BigInt(size_max);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "0.12.1",
+	"version": "0.12.2",
 	"description": "A filesystem in your browser",
 	"main": "dist/index.js",
 	"types": "src/index.ts",

package/src/backends/overlay.ts

@@ -201,7 +201,7 @@ export class UnlockedOverlayFS extends FileSystem {
 		}
 		// Create an OverlayFile.
 		const file = this._readable.openFileSync(path, parseFlag('r'), cred);
-		const stats = Stats.clone(file.statSync());
+		const stats = new Stats(file.statSync());
 		const data = new Uint8Array(stats.size);
 		file.readSync(data);
 		return new PreloadFile(this, path, flag, stats, data);

package/src/emulation/async.ts

@@ -2,7 +2,7 @@ import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
 import { ErrnoError, Errno } from '../error.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 { nop, normalizeMode, type Callback } from '../utils.js';
 import { R_OK } from './constants.js';
 import { Dirent, type Dir } from './dir.js';
@@ -882,14 +882,14 @@ export function cp(source: fs.PathLike, destination: fs.PathLike, opts: fs.CopyO
 }
 cp satisfies Omit<typeof fs.cp, '__promisify__'>;
 
-export function statfs(path: fs.PathLike, callback: Callback<[StatsFs]>): void;
-export function statfs(path: fs.PathLike, options: fs.StatFsOptions & { bigint?: false }, callback: Callback<[StatsFs]>): void;
-export function statfs(path: fs.PathLike, options: fs.StatFsOptions & { bigint: true }, callback: Callback<[BigIntStatsFs]>): void;
-export function statfs(path: fs.PathLike, options?: fs.StatFsOptions | Callback<[StatsFs]>, callback: Callback<[StatsFs]> | Callback<[BigIntStatsFs]> = nop): void {
+export function statfs(path: fs.PathLike, callback: Callback<[fs.StatsFs]>): void;
+export function statfs(path: fs.PathLike, options: fs.StatFsOptions & { bigint?: false }, callback: Callback<[fs.StatsFs]>): void;
+export function statfs(path: fs.PathLike, options: fs.StatFsOptions & { bigint: true }, callback: Callback<[fs.BigIntStatsFs]>): void;
+export function statfs(path: fs.PathLike, options?: fs.StatFsOptions | Callback<[fs.StatsFs]>, callback: Callback<[fs.StatsFs]> | Callback<[fs.BigIntStatsFs]> = nop): void {
 	callback = typeof options === 'function' ? options : callback;
 	promises
 		.statfs(path, typeof options === 'function' ? undefined : options)
-		.then(result => (callback as Callback<[StatsFs | BigIntStatsFs]>)(undefined, result))
+		.then(result => (callback as Callback<[fs.StatsFs | fs.BigIntStatsFs]>)(undefined, result))
 		.catch(callback);
 }
 statfs satisfies Omit<typeof fs.statfs, '__promisify__'>;

package/src/emulation/index.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/src/emulation/promises.ts

@@ -6,15 +6,15 @@ import type { Stream } from 'node:stream';
 import type { ReadableStream as TReadableStream } from 'node:stream/web';
 import type { Interface as ReadlineInterface } from 'readline';
 import type { ReadableStreamController } from 'stream/web';
-import { ErrnoError, Errno } from '../error.js';
+import { Errno, ErrnoError } from '../error.js';
 import { ActionType, File, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
 import type { FileContents } from '../filesystem.js';
-import { BigIntStats, FileType, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
+import { BigIntStats, FileType, type Stats } 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';
 
@@ -491,52 +491,41 @@ async function _open(path: fs.PathLike, _flag: fs.OpenMode, _mode: fs.Mode = 0o6
 	path = resolveSymlinks && (await exists(path)) ? await realpath(path) : path;
 	const { fs, path: resolved } = resolveMount(path);
 
-	try {
-		switch (pathExistsAction(flag)) {
+	if (!(await fs.exists(path, cred))) {
+		switch (pathNotExistsAction(flag)) {
+			case ActionType.CREATE:
+				// Ensure parent exists.
+				const parentStats: Stats = await fs.stat(dirname(resolved), cred);
+				if (parentStats && !parentStats.isDirectory()) {
+					throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
+				}
+				return new FileHandle(await fs.createFile(resolved, flag, mode, cred));
 			case ActionType.THROW:
-				throw ErrnoError.With('EEXIST', path, '_open');
-			case ActionType.TRUNCATE:
-				/* 
+				throw ErrnoError.With('ENOENT', path, '_open');
+			default:
+				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: 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 (_) {
-		const original = _ as ErrnoError;
-		if (original.code != 'ENOENT') {
-			throw original;
-		}
-		try {
-			switch (pathNotExistsAction(flag)) {
-				case ActionType.CREATE:
-					// Ensure parent exists.
-					const parentStats: Stats = await fs.stat(dirname(resolved), cred);
-					if (parentStats && !parentStats.isDirectory()) {
-						throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
-					}
-					return new FileHandle(await fs.createFile(resolved, flag, mode, cred));
-				case ActionType.THROW:
-					throw ErrnoError.With('ENOENT', path, '_open');
-				default:
-					throw new ErrnoError(Errno.EINVAL, 'Invalid file flag');
-			}
-		} catch (_) {
-			const ex = _ as ErrnoError;
-			ex.stack += '\n<original>\n';
-			ex.stack += (original as Error).stack;
-			throw ex;
-		}
+			const file: 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');
 	}
 }
 
@@ -1072,9 +1061,11 @@ cp satisfies typeof promises.cp;
  * @since v18.15.0
  * @return Fulfills with an {fs.StatFs} for the file system.
  */
-export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions & { bigint?: false }): Promise<StatsFs>;
-export async function statfs(path: fs.PathLike, opts: fs.StatFsOptions & { bigint: true }): Promise<BigIntStatsFs>;
-export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<StatsFs | BigIntStatsFs>;
-export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<StatsFs | BigIntStatsFs> {
-	throw ErrnoError.With('ENOSYS', path.toString(), 'statfs');
+export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions & { bigint?: false }): Promise<fs.StatsFs>;
+export async function statfs(path: fs.PathLike, opts: fs.StatFsOptions & { bigint: true }): Promise<fs.BigIntStatsFs>;
+export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<fs.StatsFs | fs.BigIntStatsFs>;
+export async function statfs(path: fs.PathLike, opts?: fs.StatFsOptions): Promise<fs.StatsFs | fs.BigIntStatsFs> {
+	path = normalizePath(path);
+	const { fs } = resolveMount(path);
+	return _statfs(fs, opts?.bigint);
 }