@zenfs/core 1.10.0 → 1.10.2

package/dist/vfs/promises.js

@@ -90,7 +90,7 @@ export class FileHandle {
     async chmod(mode) {
         const numMode = normalizeMode(mode, -1);
         if (numMode < 0)
-            throw new ErrnoError(Errno.EINVAL, 'Invalid mode.');
+            throw new ErrnoError(Errno.EINVAL, 'Invalid mode');
         await this.file.chmod(numMode);
         this._emitChange();
     }
@@ -140,7 +140,7 @@ export class FileHandle {
         const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
         const flag = parseFlag(options.flag);
         if (!isAppendable(flag)) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending.');
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending');
         }
         if (typeof data != 'string' && !options.encoding) {
             throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
@@ -161,7 +161,7 @@ export class FileHandle {
             offset = buffer.offset;
             buffer = buffer.buffer;
         }
-        if (isNaN(+position)) {
+        if (!Number.isSafeInteger(position)) {
             position = this.file.position;
         }
         buffer || (buffer = new Uint8Array((await this.file.stat()).size));
@@ -171,7 +171,7 @@ export class FileHandle {
         const options = normalizeOptions(_options, null, 'r', 0o444);
         const flag = parseFlag(options.flag);
         if (!isReadable(flag)) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for reading.');
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for reading');
         }
         const { size } = await this.stat();
         const { buffer: data } = await this.file.read(new Uint8Array(size), 0, size, 0);
@@ -179,44 +179,25 @@ export class FileHandle {
         return options.encoding ? buffer.toString(options.encoding) : buffer;
     }
     /**
-     * Returns a `ReadableStream` that may be used to read the files data.
-     *
-     * An error will be thrown if this method is called more than once or is called after the `FileHandle` is closed or closing.
-     *
-     * While the `ReadableStream` will read the file to completion,
-     * it will not close the `FileHandle` automatically.
-     * User code must still call the `fileHandle.close()` method.
+     * Read file data using a `ReadableStream`.
+     * The handle will not be closed automatically.
      */
     readableWebStream(options = {}) {
-        // Note: using an arrow function to preserve `this`
-        const start = async (controller) => {
-            try {
-                const chunkSize = 64 * 1024, maxChunks = 1e7;
-                let i = 0, position = 0, bytesRead = NaN;
-                while (bytesRead > 0) {
-                    const result = await this.read(new Uint8Array(chunkSize), 0, chunkSize, position);
+        return new ReadableStream({
+            start: async (controller) => {
+                const chunkSize = 0x1000;
+                for (let i = 0; i < 1e7; i++) {
+                    const result = await this.read(new Uint8Array(chunkSize), 0, chunkSize).catch(controller.error);
+                    if (!result)
+                        return;
                     if (!result.bytesRead) {
                         controller.close();
                         return;
                     }
                     controller.enqueue(result.buffer.subarray(0, result.bytesRead));
-                    position += result.bytesRead;
-                    if (++i >= maxChunks) {
-                        throw new ErrnoError(Errno.EFBIG, 'Too many iterations on readable stream', this.file.path, 'FileHandle.readableWebStream');
-                    }
-                    bytesRead = result.bytesRead;
                 }
-            }
-            catch (e) {
-                controller.error(e);
-            }
-        };
-        const _gt = globalThis;
-        if (!('ReadableStream' in _gt)) {
-            throw new ErrnoError(Errno.ENOSYS, 'ReadableStream is missing on globalThis');
-        }
-        return new _gt.ReadableStream({
-            start,
+                controller.error(new ErrnoError(Errno.EFBIG, 'Too many iterations on readable stream', this.file.path, 'readableWebStream'));
+            },
             type: options.type,
         });
     }
@@ -240,26 +221,25 @@ export class FileHandle {
      * Asynchronously writes `string` to the file.
      * The `FileHandle` must have been opened for writing.
      * It is unsafe to call `write()` multiple times on the same file without waiting for the `Promise`
-     * to be resolved (or rejected). For this scenario, `fs.createWriteStream` is strongly recommended.
+     * to be resolved (or rejected). For this scenario, `createWriteStream` is strongly recommended.
      */
     async write(data, options, lenOrEnc, position) {
         let buffer, offset, length;
-        if (typeof options == 'object') {
-            lenOrEnc = options === null || options === void 0 ? void 0 : options.length;
-            position = options === null || options === void 0 ? void 0 : options.position;
-            options = options === null || options === void 0 ? void 0 : options.offset;
+        if (typeof options == 'object' && options != null) {
+            lenOrEnc = options.length;
+            position = options.position;
+            options = options.offset;
         }
         if (typeof data === 'string') {
             position = typeof options === 'number' ? options : null;
-            const encoding = typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8';
             offset = 0;
-            buffer = Buffer.from(data, encoding);
+            buffer = Buffer.from(data, typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8');
             length = buffer.length;
         }
         else {
             buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-            offset = options;
-            length = lenOrEnc;
+            offset = options !== null && options !== void 0 ? options : 0;
+            length = typeof lenOrEnc == 'number' ? lenOrEnc : buffer.byteLength;
             position = typeof position === 'number' ? position : null;
         }
         position !== null && position !== void 0 ? position : (position = this.file.position);
@@ -281,7 +261,7 @@ export class FileHandle {
         const options = normalizeOptions(_options, 'utf8', 'w', 0o644);
         const flag = parseFlag(options.flag);
         if (!isWriteable(flag)) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for writing.');
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for writing');
         }
         if (typeof data != 'string' && !options.encoding) {
             throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
@@ -304,9 +284,11 @@ export class FileHandle {
      * @returns The number of bytes written.
      */
     async writev(buffers, position) {
+        if (typeof position == 'number')
+            this.file.position = position;
         let bytesWritten = 0;
         for (const buffer of buffers) {
-            bytesWritten += (await this.write(buffer, 0, buffer.length, position + bytesWritten)).bytesWritten;
+            bytesWritten += (await this.write(buffer)).bytesWritten;
         }
         return { bytesWritten, buffers };
     }
@@ -317,9 +299,11 @@ export class FileHandle {
      * @returns The number of bytes read.
      */
     async readv(buffers, position) {
+        if (typeof position == 'number')
+            this.file.position = position;
         let bytesRead = 0;
         for (const buffer of buffers) {
-            bytesRead += (await this.read(buffer, 0, buffer.byteLength, position + bytesRead)).bytesRead;
+            bytesRead += (await this.read(buffer)).bytesRead;
         }
         return { bytesRead, buffers };
     }
@@ -328,15 +312,23 @@ export class FileHandle {
      * @param options Options for the readable stream
      */
     createReadStream(options) {
+        var _a, _b;
+        const start = (_a = options === null || options === void 0 ? void 0 : options.start) !== null && _a !== void 0 ? _a : this.file.position;
         const stream = new ReadStream({
             highWaterMark: (options === null || options === void 0 ? void 0 : options.highWaterMark) || 64 * 1024,
-            encoding: options.encoding,
+            encoding: (_b = options === null || options === void 0 ? void 0 : options.encoding) !== null && _b !== void 0 ? _b : undefined,
             // eslint-disable-next-line @typescript-eslint/no-misused-promises
             read: async (size) => {
                 try {
-                    const result = await this.read(new Uint8Array(size), 0, size, this.file.position);
-                    stream.push(!result.bytesRead ? null : result.buffer.subarray(0, result.bytesRead)); // Push data or null for EOF
-                    this.file.position += result.bytesRead;
+                    if (typeof (options === null || options === void 0 ? void 0 : options.end) === 'number' && start >= options.end) {
+                        stream.push(null);
+                        return;
+                    }
+                    if (typeof (options === null || options === void 0 ? void 0 : options.end) === 'number') {
+                        size = Math.min(size, options.end - start);
+                    }
+                    const result = await this.read(new Uint8Array(size), 0, size, options === null || options === void 0 ? void 0 : options.start);
+                    stream.push(!result.bytesRead ? null : result.buffer.subarray(0, result.bytesRead));
                 }
                 catch (error) {
                     stream.destroy(error);
@@ -351,20 +343,25 @@ export class FileHandle {
      * @param options Options for the writeable stream.
      */
     createWriteStream(options) {
-        const streamOptions = {
+        if (typeof (options === null || options === void 0 ? void 0 : options.start) == 'number')
+            this.file.position = options.start;
+        const { stack } = new Error();
+        const stream = new WriteStream({
             highWaterMark: options === null || options === void 0 ? void 0 : options.highWaterMark,
-            encoding: options === null || options === void 0 ? void 0 : options.encoding,
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
             write: async (chunk, encoding, callback) => {
                 try {
                     const { bytesWritten } = await this.write(chunk, null, encoding);
-                    callback(bytesWritten == chunk.length ? null : new Error('Failed to write full chunk'));
+                    if (bytesWritten == chunk.length)
+                        return callback();
+                    throw new ErrnoError(Errno.EIO, `Failed to write full chunk of write stream (wrote ${bytesWritten}/${chunk.length} bytes)`);
                 }
                 catch (error) {
+                    error.stack += stack === null || stack === void 0 ? void 0 : stack.slice(5);
                     callback(error);
                 }
             },
-        };
-        const stream = new WriteStream(streamOptions);
+        });
         stream.path = this.file.path;
         return stream;
     }
@@ -596,7 +593,7 @@ export async function appendFile(path, data, _options) {
         const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
         const flag = parseFlag(options.flag);
         if (!isAppendable(flag)) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending.');
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending');
         }
         if (typeof data != 'string' && !options.encoding) {
             throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
@@ -1086,7 +1083,7 @@ export async function copyFile(src, dest, mode) {
     src = normalizePath(src);
     dest = normalizePath(dest);
     if (mode && mode & constants.COPYFILE_EXCL && (await exists.call(this, dest))) {
-        throw new ErrnoError(Errno.EEXIST, 'Destination file already exists.', dest, 'copyFile');
+        throw new ErrnoError(Errno.EEXIST, 'Destination file already exists', dest, 'copyFile');
     }
     await writeFile.call(this, dest, await readFile.call(this, src));
     emitChange(this, 'rename', dest.toString());
@@ -1121,7 +1118,7 @@ export async function cp(source, destination, opts) {
     destination = normalizePath(destination);
     const srcStats = await lstat.call(this, source); // Use lstat to follow symlinks if not dereferencing
     if ((opts === null || opts === void 0 ? void 0 : opts.errorOnExist) && (await exists.call(this, destination))) {
-        throw new ErrnoError(Errno.EEXIST, 'Destination file or directory already exists.', destination, 'cp');
+        throw new ErrnoError(Errno.EEXIST, 'Destination file or directory already exists', destination, 'cp');
     }
     switch (srcStats.mode & constants.S_IFMT) {
         case constants.S_IFDIR: {

package/dist/vfs/shared.js

@@ -47,7 +47,7 @@ export function mount(mountPoint, fs) {
         mountPoint = '/' + mountPoint;
     mountPoint = resolve(mountPoint);
     if (mounts.has(mountPoint)) {
-        throw err(new ErrnoError(Errno.EINVAL, 'Mount point ' + mountPoint + ' is already in use.'));
+        throw err(new ErrnoError(Errno.EINVAL, 'Mount point ' + mountPoint + ' is already in use'));
     }
     fs._mountPoint = mountPoint;
     mounts.set(mountPoint, fs);
@@ -63,7 +63,7 @@ export function umount(mountPoint) {
         mountPoint = '/' + mountPoint;
     mountPoint = resolve(mountPoint);
     if (!mounts.has(mountPoint)) {
-        warn(mountPoint + ' is already unmounted.');
+        warn(mountPoint + ' is already unmounted');
         return;
     }
     mounts.delete(mountPoint);

package/dist/vfs/streams.d.ts

@@ -2,14 +2,14 @@ import type * as fs from 'node:fs';
 import type { Callback } from '../utils.js';
 import { Readable, Writable } from 'readable-stream';
 export declare class ReadStream extends Readable implements fs.ReadStream {
-    close(callback?: Callback<[void], null>): void;
+    close: (callback?: Callback<[void], null>) => void;
     wrap(oldStream: NodeJS.ReadableStream): this;
     bytesRead: number;
     path: string | Buffer;
     pending: boolean;
 }
 export declare class WriteStream extends Writable implements fs.WriteStream {
-    close(callback?: Callback<[void], null>): void;
+    close: (callback?: Callback<[void], null>) => void;
     bytesWritten: number;
     path: string | Buffer;
     pending: boolean;

package/dist/vfs/streams.js

@@ -1,15 +1,18 @@
 import { Readable, Writable } from 'readable-stream';
 import { Errno, ErrnoError } from '../internal/error.js';
 export class ReadStream extends Readable {
-    close(callback = () => null) {
-        try {
-            super.destroy();
-            super.emit('close');
-            callback(null);
-        }
-        catch (err) {
-            callback(new ErrnoError(Errno.EIO, err.toString()));
-        }
+    constructor() {
+        super(...arguments);
+        this.close = (callback = () => null) => {
+            try {
+                super.destroy();
+                super.emit('close');
+                callback(null);
+            }
+            catch (err) {
+                callback(new ErrnoError(Errno.EIO, err.toString()));
+            }
+        };
     }
     wrap(oldStream) {
         super.wrap(oldStream);
@@ -17,14 +20,17 @@ export class ReadStream extends Readable {
     }
 }
 export class WriteStream extends Writable {
-    close(callback = () => null) {
-        try {
-            super.destroy();
-            super.emit('close');
-            callback(null);
-        }
-        catch (err) {
-            callback(new ErrnoError(Errno.EIO, err.toString()));
-        }
+    constructor() {
+        super(...arguments);
+        this.close = (callback = () => null) => {
+            try {
+                super.destroy();
+                super.emit('close');
+                callback(null);
+            }
+            catch (err) {
+                callback(new ErrnoError(Errno.EIO, err.toString()));
+            }
+        };
     }
 }

package/dist/vfs/sync.js

@@ -259,7 +259,7 @@ export function readFileSync(path, _options = {}) {
     const options = normalizeOptions(_options, null, 'r', 0o644);
     const flag = parseFlag(options.flag);
     if (!isReadable(flag)) {
-        throw new ErrnoError(Errno.EINVAL, 'Flag passed to readFile must allow for reading.');
+        throw new ErrnoError(Errno.EINVAL, 'Flag passed to readFile must allow for reading');
     }
     const data = Buffer.from(_readFileSync.call(this, typeof path == 'number' ? fd2file(path).path : path, options.flag, false));
     return options.encoding ? data.toString(options.encoding) : data;
@@ -271,7 +271,7 @@ export function writeFileSync(path, data, _options = {}) {
         const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
         const flag = parseFlag(options.flag);
         if (!isWriteable(flag)) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed to writeFile must allow for writing.');
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed to writeFile must allow for writing');
         }
         if (typeof data != 'string' && !options.encoding) {
             throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
@@ -309,7 +309,7 @@ export function appendFileSync(filename, data, _options = {}) {
         const options = normalizeOptions(_options, 'utf8', 'a+', 0o644);
         const flag = parseFlag(options.flag);
         if (!isAppendable(flag)) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending.');
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending');
         }
         if (typeof data != 'string' && !options.encoding) {
             throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
@@ -743,7 +743,7 @@ export function copyFileSync(source, destination, flags) {
     source = normalizePath(source);
     destination = normalizePath(destination);
     if (flags && flags & constants.COPYFILE_EXCL && existsSync(destination)) {
-        throw new ErrnoError(Errno.EEXIST, 'Destination file already exists.', destination, 'copyFile');
+        throw new ErrnoError(Errno.EEXIST, 'Destination file already exists', destination, 'copyFile');
     }
     writeFileSync.call(this, destination, readFileSync(source));
     emitChange(this, 'rename', destination.toString());
@@ -810,7 +810,7 @@ export function cpSync(source, destination, opts) {
     destination = normalizePath(destination);
     const srcStats = lstatSync.call(this, source); // Use lstat to follow symlinks if not dereferencing
     if ((opts === null || opts === void 0 ? void 0 : opts.errorOnExist) && existsSync.call(this, destination)) {
-        throw new ErrnoError(Errno.EEXIST, 'Destination file or directory already exists.', destination, 'cp');
+        throw new ErrnoError(Errno.EEXIST, 'Destination file or directory already exists', destination, 'cp');
     }
     switch (srcStats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.10.0",
+	"version": "1.10.2",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -21,6 +21,7 @@
 	"files": [
 		"dist",
 		"tests",
+		"types",
 		"license.md",
 		"eslint.shared.js"
 	],
@@ -66,11 +67,10 @@
 	},
 	"dependencies": {
 		"@types/node": "^22.10.1",
-		"@types/readable-stream": "^4.0.10",
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
 		"readable-stream": "^4.5.2",
-		"utilium": "^1.3.1"
+		"utilium": "^1.3.3"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.8.0",

package/readme.md

@@ -1,7 +1,3 @@
----
-title: Overview
----
-
 # ZenFS
 
 ZenFS is a cross-platform library that emulates the [NodeJS filesystem API](http://nodejs.org/api/fs.html). It works using a system of backends, which are used by ZenFS to store and retrieve data. ZenFS can also integrate with other tools.
@@ -15,6 +11,7 @@ ZenFS is modular and extensible. The core includes some built-in backends:
 - `Fetch`: Downloads files over HTTP with the `fetch` API
 - `Port`: Interacts with a remote over a `MessagePort`-like interface (e.g. a worker)
 - `Passthrough`: Use an existing `node:fs` interface with ZenFS
+- `SingleBuffer`: A backend contained within a single buffer. Can be used for synchronous multi-threaded operations using `SharedArrayBuffer`
 
 ZenFS supports a number of other backends. Many are provided as separate packages under `@zenfs`. More backends can be defined by separate libraries by extending the `FileSystem` class and providing a `Backend` object.
 

package/tests/common/mutex.test.ts

@@ -6,7 +6,7 @@ import { suite, test } from 'node:test';
 import assert from 'node:assert/strict';
 
 suite('LockFS mutex', () => {
-	const fs = new (Mutexed(StoreFS))(new InMemoryStore('test'));
+	const fs = new (Mutexed(StoreFS))(new InMemoryStore(0x10000, 'test'));
 	fs._fs.checkRootSync();
 
 	test('lock/unlock', () => {

package/tests/fetch/server.js

@@ -12,7 +12,7 @@ try {
 	execSync(`npm exec make-index -- ${data} --output ${tmp}/index.json --quiet`, { stdio: 'inherit' });
 } catch (e) {
 	if (e.signal == 'SIGINT') {
-		console.log('Aborted whilst creating index.');
+		console.log('Aborted whilst creating index');
 		process.exit(0);
 	} else {
 		console.error('Index creation failed: ' + e.message);

package/tests/fs/directory.test.ts

@@ -1,6 +1,5 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { ErrnoError } from '../../dist/index.js';
 import { fs } from '../common.js';
 
 const testDir = 'test-dir';
@@ -25,15 +24,10 @@ suite('Directories', () => {
 		await assert.rejects(fs.promises.mkdir('/one', 0o755), /EEXIST/);
 	});
 
-	test('mkdirSync', () => fs.mkdirSync('/two', 0o000));
+	test('mkdirSync', async () => await fs.promises.mkdir('/two', 0o000));
 
 	test('mkdir, nested', async () => {
-		try {
-			await fs.promises.mkdir('/nested/dir');
-		} catch (error: any) {
-			assert(error instanceof ErrnoError);
-			assert.equal(error.code, 'ENOENT');
-		}
+		assert.rejects(fs.promises.mkdir('/nested/dir'), { code: 'ENOENT', path: '/nested' });
 		assert(!(await fs.promises.exists('/nested/dir')));
 	});
 
@@ -61,69 +55,27 @@ suite('Directories', () => {
 		assert.equal(fs.statSync('/recursiveS/A/B/C/D').mode, fs.constants.S_IFDIR | 0o777);
 	});
 
-	test('readdirSync without permission', () => {
-		try {
-			fs.readdirSync('/two');
-		} catch (error: any) {
-			assert(error instanceof ErrnoError);
-			assert.equal(error.code, 'EACCES');
-		}
-	});
-
 	test('rmdir (non-empty)', async () => {
 		await fs.promises.mkdir('/rmdirTest');
 		await fs.promises.mkdir('/rmdirTest/rmdirTest2');
 
-		try {
-			await fs.promises.rmdir('/rmdirTest');
-		} catch (error: any) {
-			assert(error instanceof ErrnoError);
-			assert.equal(error.code, 'ENOTEMPTY');
-		}
+		assert.rejects(fs.promises.rmdir('/rmdirTest'), { code: 'ENOTEMPTY' });
 	});
 
 	test('readdirSync on file', () => {
-		let wasThrown = false;
-
-		try {
-			fs.readdirSync('a.js');
-		} catch (error: any) {
-			assert(error instanceof ErrnoError);
-			wasThrown = true;
-			assert.equal(error.code, 'ENOTDIR');
-		}
-		assert(wasThrown);
+		assert.throws(() => fs.readdirSync('a.js'), { code: 'ENOTDIR' });
 	});
 
-	test('readdir on file', async () => {
-		try {
-			await fs.promises.readdir('a.js');
-		} catch (error: any) {
-			assert(error instanceof ErrnoError);
-			assert.equal(error.code, 'ENOTDIR');
-		}
+	test('readdir on file', () => {
+		assert.rejects(fs.promises.readdir('a.js'), { code: 'ENOTDIR' });
 	});
 
 	test('readdirSync on non-existant directory', () => {
-		let wasThrown = false;
-
-		try {
-			fs.readdirSync('/does/not/exist');
-		} catch (error: any) {
-			assert(error instanceof ErrnoError);
-			wasThrown = true;
-			assert.equal(error.code, 'ENOENT');
-		}
-		assert(wasThrown);
-	});
-
-	test('readdir on non-existant directory', async () => {
-		try {
-			await fs.promises.readdir('/does/not/exist');
-		} catch (error: any) {
-			assert(error instanceof ErrnoError);
-			assert.equal(error.code, 'ENOENT');
-		}
+		assert.throws(() => fs.readdirSync('/does/not/exist'), { code: 'ENOENT' });
+	});
+
+	test('readdir on non-existant directory', () => {
+		assert.rejects(fs.promises.readdir('/does/not/exist'), { code: 'ENOENT' });
 	});
 
 	test('rm recursively asynchronously', async () => {

package/tests/fs/errors.test.ts

@@ -12,7 +12,7 @@ suite('Error messages', () => {
 		assert.equal(error.bufferSize(), 4 + JSON.stringify(error.toJSON()).length);
 	});
 
-	const missing = { path };
+	const missing = { path, code: 'ENOENT' };
 	const existing = { path: existingFile };
 
 	test('stat', () => assert.rejects(() => fs.promises.stat(path), missing));

package/tests/fs/stat.test.ts

@@ -38,13 +38,9 @@ suite('Stats', () => {
 	test('hasAccess for non-root access', () => {
 		const newFile = 'new.txt';
 
-		fs.writeFileSync(newFile, 'hello', {
-			mode: 0o640, // allow group access
-		});
+		fs.writeFileSync(newFile, 'hello', { mode: 0o640 });
 
-		const prevCredentials = {
-			...credentials,
-		};
+		const prevCredentials = { ...credentials };
 		const uid = 33;
 		const nonRootCredentials = {
 			uid,