@zenfs/core 1.2.4 → 1.2.6

package/dist/config.d.ts

@@ -61,6 +61,15 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
      * @default false
      */
     disableUpdateOnRead: boolean;
+    /**
+     * If true, files will only sync to the file system when closed.
+     *
+     * This can increase performance.
+     * @experimental
+     * @overrides `disableUpdateOnRead`
+     * @default false
+     */
+    onlySyncOnClose: boolean;
 }
 /**
  * Configures ZenFS with single mount point /

package/dist/config.js

@@ -70,7 +70,8 @@ export async function configure(configuration) {
     Object.assign(credentials, { uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
     cache.setEnabled(configuration.cacheStats ?? false);
     config.checkAccess = !configuration.disableAccessChecks;
-    config.updateOnRead = !configuration.disableUpdateOnRead;
+    config.syncOnRead = !configuration.onlySyncOnClose || !configuration.disableUpdateOnRead;
+    config.syncOnWrite = !configuration.onlySyncOnClose;
     if (configuration.addDevices) {
         const devfs = new DeviceFS();
         devfs.createDevice('/null', nullDevice);

package/dist/emulation/config.d.ts

@@ -6,5 +6,13 @@ export declare const config: {
     /**
      * Whether to sync atime updates immediately when reading from a file
      */
-    updateOnRead: boolean;
+    syncOnRead: boolean;
+    /**
+     * Whether to immediately sync when files are written to
+     */
+    syncOnWrite: boolean;
+    /**
+     * If a file's buffer is not large enough to store content when writing and the buffer can't be resized, reuse the buffer passed to write()
+     */
+    unsafeBufferReplace: boolean;
 };

package/dist/emulation/config.js

@@ -6,5 +6,13 @@ export const config = {
     /**
      * Whether to sync atime updates immediately when reading from a file
      */
-    updateOnRead: true,
+    syncOnRead: true,
+    /**
+     * Whether to immediately sync when files are written to
+     */
+    syncOnWrite: true,
+    /**
+     * If a file's buffer is not large enough to store content when writing and the buffer can't be resized, reuse the buffer passed to write()
+     */
+    unsafeBufferReplace: false,
 };

package/dist/emulation/promises.js

@@ -485,7 +485,6 @@ async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
     */
     if (isTruncating(flag)) {
         await handle.truncate(0);
-        await handle.sync();
     }
     return handle;
 }
@@ -738,24 +737,17 @@ link;
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
 export async function symlink(target, path, type = 'file') {
-    if (!['file', 'dir', 'junction'].includes(type)) {
-        throw new ErrnoError(Errno.EINVAL, 'Invalid symlink type: ' + type);
-    }
-    if (await exists(path)) {
-        throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
-    }
-    await writeFile(path, target.toString());
-    const handle = await _open(path, 'r+', 0o644, false);
-    await handle.file._setType(constants.S_IFLNK);
-}
-symlink;
-export async function readlink(path, options) {
     const env_5 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_5, await _open(normalizePath(path), 'r', 0o644, false), true);
-        const value = await handle.readFile();
-        const encoding = typeof options == 'object' ? options?.encoding : options;
-        return encoding == 'buffer' ? value : value.toString(encoding);
+        if (!['file', 'dir', 'junction'].includes(type)) {
+            throw new ErrnoError(Errno.EINVAL, 'Invalid symlink type: ' + type);
+        }
+        if (await exists(path)) {
+            throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
+        }
+        const handle = __addDisposableResource(env_5, await _open(path, 'w+', 0o644, false), true);
+        await handle.writeFile(target.toString());
+        await handle.file._setType(constants.S_IFLNK);
     }
     catch (e_5) {
         env_5.error = e_5;
@@ -767,13 +759,14 @@ export async function readlink(path, options) {
             await result_5;
     }
 }
-readlink;
-// PROPERTY OPERATIONS
-export async function chown(path, uid, gid) {
+symlink;
+export async function readlink(path, options) {
     const env_6 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_6, await open(path, 'r+'), true);
-        await handle.chown(uid, gid);
+        const handle = __addDisposableResource(env_6, await _open(normalizePath(path), 'r', 0o644, false), true);
+        const value = await handle.readFile();
+        const encoding = typeof options == 'object' ? options?.encoding : options;
+        return encoding == 'buffer' ? value : value.toString(encoding);
     }
     catch (e_6) {
         env_6.error = e_6;
@@ -785,11 +778,12 @@ export async function chown(path, uid, gid) {
             await result_6;
     }
 }
-chown;
-export async function lchown(path, uid, gid) {
+readlink;
+// PROPERTY OPERATIONS
+export async function chown(path, uid, gid) {
     const env_7 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_7, await _open(path, 'r+', 0o644, false), true);
+        const handle = __addDisposableResource(env_7, await open(path, 'r+'), true);
         await handle.chown(uid, gid);
     }
     catch (e_7) {
@@ -802,12 +796,12 @@ export async function lchown(path, uid, gid) {
             await result_7;
     }
 }
-lchown;
-export async function chmod(path, mode) {
+chown;
+export async function lchown(path, uid, gid) {
     const env_8 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_8, await open(path, 'r+'), true);
-        await handle.chmod(mode);
+        const handle = __addDisposableResource(env_8, await _open(path, 'r+', 0o644, false), true);
+        await handle.chown(uid, gid);
     }
     catch (e_8) {
         env_8.error = e_8;
@@ -819,11 +813,11 @@ export async function chmod(path, mode) {
             await result_8;
     }
 }
-chmod;
-export async function lchmod(path, mode) {
+lchown;
+export async function chmod(path, mode) {
     const env_9 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_9, await _open(path, 'r+', 0o644, false), true);
+        const handle = __addDisposableResource(env_9, await open(path, 'r+'), true);
         await handle.chmod(mode);
     }
     catch (e_9) {
@@ -836,15 +830,12 @@ export async function lchmod(path, mode) {
             await result_9;
     }
 }
-lchmod;
-/**
- * Change file timestamps of the file referenced by the supplied path.
- */
-export async function utimes(path, atime, mtime) {
+chmod;
+export async function lchmod(path, mode) {
     const env_10 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_10, await open(path, 'r+'), true);
-        await handle.utimes(atime, mtime);
+        const handle = __addDisposableResource(env_10, await _open(path, 'r+', 0o644, false), true);
+        await handle.chmod(mode);
     }
     catch (e_10) {
         env_10.error = e_10;
@@ -856,15 +847,15 @@ export async function utimes(path, atime, mtime) {
             await result_10;
     }
 }
-utimes;
+lchmod;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  */
-export async function lutimes(path, atime, mtime) {
+export async function utimes(path, atime, mtime) {
     const env_11 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_11, await _open(path, 'r+', 0o644, false), true);
-        await handle.utimes(new Date(atime), new Date(mtime));
+        const handle = __addDisposableResource(env_11, await open(path, 'r+'), true);
+        await handle.utimes(atime, mtime);
     }
     catch (e_11) {
         env_11.error = e_11;
@@ -876,6 +867,26 @@ export async function lutimes(path, atime, mtime) {
             await result_11;
     }
 }
+utimes;
+/**
+ * Change file timestamps of the file referenced by the supplied path.
+ */
+export async function lutimes(path, atime, mtime) {
+    const env_12 = { stack: [], error: void 0, hasError: false };
+    try {
+        const handle = __addDisposableResource(env_12, await _open(path, 'r+', 0o644, false), true);
+        await handle.utimes(new Date(atime), new Date(mtime));
+    }
+    catch (e_12) {
+        env_12.error = e_12;
+        env_12.hasError = true;
+    }
+    finally {
+        const result_12 = __disposeResources(env_12);
+        if (result_12)
+            await result_12;
+    }
+}
 lutimes;
 export async function realpath(path, options) {
     path = normalizePath(path);

package/dist/emulation/sync.js

@@ -193,7 +193,6 @@ function _openSync(path, _flag, _mode, resolveSymlinks = true) {
     const file = fs.openFileSync(resolved, flag);
     if (isTruncating(flag)) {
         file.truncateSync(0);
-        file.syncSync();
     }
     return file;
 }

package/dist/file.js

@@ -289,27 +289,33 @@ export class PreloadFile extends File {
     }
     async truncate(length) {
         this._truncate(length);
-        await this.sync();
+        if (config.syncOnWrite)
+            await this.sync();
     }
     truncateSync(length) {
         this._truncate(length);
-        this.syncSync();
+        if (config.syncOnWrite)
+            this.syncSync();
     }
     _write(buffer, offset = 0, length = this.stats.size, position = this.position) {
         if (this.closed) {
             throw ErrnoError.With('EBADF', this.path, 'File.write');
         }
-        this.dirty = true;
         if (!isWriteable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
         }
+        this.dirty = true;
         const end = position + length;
+        const slice = buffer.slice(offset, offset + length);
         if (end > this.stats.size) {
             this.stats.size = end;
             if (end > this._buffer.byteLength) {
                 if (this._buffer.buffer.resizable && this._buffer.buffer.maxByteLength <= end) {
                     this._buffer.buffer.resize(end);
                 }
+                else if (config.unsafeBufferReplace) {
+                    this._buffer = slice;
+                }
                 else {
                     // Extend the buffer!
                     const newBuffer = new Uint8Array(new ArrayBuffer(end, this.fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }));
@@ -318,7 +324,6 @@ export class PreloadFile extends File {
                 }
             }
         }
-        const slice = buffer.slice(offset, offset + length);
         this._buffer.set(slice, position);
         this.stats.mtimeMs = Date.now();
         this.position = position + slice.byteLength;
@@ -334,7 +339,8 @@ export class PreloadFile extends File {
      */
     async write(buffer, offset, length, position) {
         const bytesWritten = this._write(buffer, offset, length, position);
-        await this.sync();
+        if (config.syncOnWrite)
+            await this.sync();
         return bytesWritten;
     }
     /**
@@ -348,7 +354,8 @@ export class PreloadFile extends File {
      */
     writeSync(buffer, offset = 0, length = this.stats.size, position = this.position) {
         const bytesWritten = this._write(buffer, offset, length, position);
-        this.syncSync();
+        if (config.syncOnWrite)
+            this.syncSync();
         return bytesWritten;
     }
     _read(buffer, offset = 0, length = this.stats.size, position) {
@@ -358,10 +365,8 @@ export class PreloadFile extends File {
         if (!isReadable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
         }
-        if (config.updateOnRead) {
-            this.dirty = true;
-            this.stats.atimeMs = Date.now();
-        }
+        this.dirty = true;
+        this.stats.atimeMs = Date.now();
         position ?? (position = this.position);
         let end = position + length;
         if (end > this.stats.size) {
@@ -370,7 +375,7 @@ export class PreloadFile extends File {
         this._position = end;
         const bytesRead = end - position;
         if (bytesRead == 0) {
-            // No copy/read. Return immediatly for better performance
+            // No copy/read. Return immediately for better performance
             return bytesRead;
         }
         new Uint8Array(buffer.buffer, offset, length).set(this._buffer.slice(position, end));
@@ -386,7 +391,8 @@ export class PreloadFile extends File {
      */
     async read(buffer, offset, length, position) {
         const bytesRead = this._read(buffer, offset, length, position);
-        await this.sync();
+        if (config.syncOnRead)
+            await this.sync();
         return { bytesRead, buffer };
     }
     /**
@@ -400,7 +406,8 @@ export class PreloadFile extends File {
      */
     readSync(buffer, offset, length, position) {
         const bytesRead = this._read(buffer, offset, length, position);
-        this.syncSync();
+        if (config.syncOnRead)
+            this.syncSync();
         return bytesRead;
     }
     async chmod(mode) {
@@ -409,7 +416,8 @@ export class PreloadFile extends File {
         }
         this.dirty = true;
         this.stats.chmod(mode);
-        await this.sync();
+        if (config.syncOnWrite)
+            await this.sync();
     }
     chmodSync(mode) {
         if (this.closed) {
@@ -417,7 +425,8 @@ export class PreloadFile extends File {
         }
         this.dirty = true;
         this.stats.chmod(mode);
-        this.syncSync();
+        if (config.syncOnWrite)
+            this.syncSync();
     }
     async chown(uid, gid) {
         if (this.closed) {
@@ -425,7 +434,8 @@ export class PreloadFile extends File {
         }
         this.dirty = true;
         this.stats.chown(uid, gid);
-        await this.sync();
+        if (config.syncOnWrite)
+            await this.sync();
     }
     chownSync(uid, gid) {
         if (this.closed) {
@@ -433,7 +443,8 @@ export class PreloadFile extends File {
         }
         this.dirty = true;
         this.stats.chown(uid, gid);
-        this.syncSync();
+        if (config.syncOnWrite)
+            this.syncSync();
     }
     async utimes(atime, mtime) {
         if (this.closed) {
@@ -442,7 +453,8 @@ export class PreloadFile extends File {
         this.dirty = true;
         this.stats.atime = atime;
         this.stats.mtime = mtime;
-        await this.sync();
+        if (config.syncOnWrite)
+            await this.sync();
     }
     utimesSync(atime, mtime) {
         if (this.closed) {
@@ -451,7 +463,8 @@ export class PreloadFile extends File {
         this.dirty = true;
         this.stats.atime = atime;
         this.stats.mtime = mtime;
-        this.syncSync();
+        if (config.syncOnWrite)
+            this.syncSync();
     }
     async _setType(type) {
         if (this.closed) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.2.4",
+	"version": "1.2.6",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/src/config.ts

@@ -126,6 +126,16 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
 	 * @default false
 	 */
 	disableUpdateOnRead: boolean;
+
+	/**
+	 * If true, files will only sync to the file system when closed.
+	 *
+	 * This can increase performance.
+	 * @experimental
+	 * @overrides `disableUpdateOnRead`
+	 * @default false
+	 */
+	onlySyncOnClose: boolean;
 }
 
 /**
@@ -153,7 +163,8 @@ export async function configure<T extends ConfigMounts>(configuration: Partial<C
 
 	cache.setEnabled(configuration.cacheStats ?? false);
 	config.checkAccess = !configuration.disableAccessChecks;
-	config.updateOnRead = !configuration.disableUpdateOnRead;
+	config.syncOnRead = !configuration.onlySyncOnClose || !configuration.disableUpdateOnRead;
+	config.syncOnWrite = !configuration.onlySyncOnClose;
 
 	if (configuration.addDevices) {
 		const devfs = new DeviceFS();

package/src/emulation/config.ts

@@ -7,5 +7,15 @@ export const config = {
 	/**
 	 * Whether to sync atime updates immediately when reading from a file
 	 */
-	updateOnRead: true,
+	syncOnRead: true,
+
+	/**
+	 * Whether to immediately sync when files are written to
+	 */
+	syncOnWrite: true,
+
+	/**
+	 * If a file's buffer is not large enough to store content when writing and the buffer can't be resized, reuse the buffer passed to write()
+	 */
+	unsafeBufferReplace: false,
 };

package/src/emulation/promises.ts

@@ -529,7 +529,6 @@ async function _open(path: fs.PathLike, _flag: fs.OpenMode, _mode: fs.Mode = 0o6
 	*/
 	if (isTruncating(flag)) {
 		await handle.truncate(0);
-		await handle.sync();
 	}
 
 	return handle;
@@ -832,8 +831,8 @@ export async function symlink(target: fs.PathLike, path: fs.PathLike, type: fs.s
 		throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
 	}
 
-	await writeFile(path, target.toString());
-	const handle = await _open(path, 'r+', 0o644, false);
+	await using handle = await _open(path, 'w+', 0o644, false);
+	await handle.writeFile(target.toString());
 	await handle.file._setType(constants.S_IFLNK);
 }
 symlink satisfies typeof promises.symlink;

package/src/emulation/sync.ts

@@ -159,7 +159,6 @@ function _openSync(path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | null
 
 	if (isTruncating(flag)) {
 		file.truncateSync(0);
-		file.syncSync();
 	}
 
 	return file;

package/src/file.ts

@@ -441,29 +441,34 @@ export class PreloadFile<FS extends FileSystem> extends File {
 
 	public async truncate(length: number): Promise<void> {
 		this._truncate(length);
-		await this.sync();
+		if (config.syncOnWrite) await this.sync();
 	}
 
 	public truncateSync(length: number): void {
 		this._truncate(length);
-		this.syncSync();
+		if (config.syncOnWrite) this.syncSync();
 	}
 
 	protected _write(buffer: Uint8Array, offset: number = 0, length: number = this.stats.size, position: number = this.position): number {
 		if (this.closed) {
 			throw ErrnoError.With('EBADF', this.path, 'File.write');
 		}
-		this.dirty = true;
+
 		if (!isWriteable(this.flag)) {
 			throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
 		}
+
+		this.dirty = true;
 		const end = position + length;
+		const slice = buffer.slice(offset, offset + length);
 
 		if (end > this.stats.size) {
 			this.stats.size = end;
 			if (end > this._buffer.byteLength) {
 				if (this._buffer.buffer.resizable && this._buffer.buffer.maxByteLength! <= end) {
 					this._buffer.buffer.resize(end);
+				} else if (config.unsafeBufferReplace) {
+					this._buffer = slice;
 				} else {
 					// Extend the buffer!
 					const newBuffer = new Uint8Array(new ArrayBuffer(end, this.fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }));
@@ -472,7 +477,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 				}
 			}
 		}
-		const slice = buffer.slice(offset, offset + length);
+
 		this._buffer.set(slice, position);
 		this.stats.mtimeMs = Date.now();
 		this.position = position + slice.byteLength;
@@ -489,7 +494,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 */
 	public async write(buffer: Uint8Array, offset?: number, length?: number, position?: number): Promise<number> {
 		const bytesWritten = this._write(buffer, offset, length, position);
-		await this.sync();
+		if (config.syncOnWrite) await this.sync();
 		return bytesWritten;
 	}
 
@@ -504,7 +509,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 */
 	public writeSync(buffer: Uint8Array, offset: number = 0, length: number = this.stats.size, position: number = this.position): number {
 		const bytesWritten = this._write(buffer, offset, length, position);
-		this.syncSync();
+		if (config.syncOnWrite) this.syncSync();
 		return bytesWritten;
 	}
 
@@ -515,10 +520,8 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		if (!isReadable(this.flag)) {
 			throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
 		}
-		if (config.updateOnRead) {
-			this.dirty = true;
-			this.stats.atimeMs = Date.now();
-		}
+		this.dirty = true;
+		this.stats.atimeMs = Date.now();
 		position ??= this.position;
 		let end = position + length;
 		if (end > this.stats.size) {
@@ -527,7 +530,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		this._position = end;
 		const bytesRead = end - position;
 		if (bytesRead == 0) {
-			// No copy/read. Return immediatly for better performance
+			// No copy/read. Return immediately for better performance
 			return bytesRead;
 		}
 		new Uint8Array(buffer.buffer, offset, length).set(this._buffer.slice(position, end));
@@ -544,7 +547,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 */
 	public async read<TBuffer extends ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{ bytesRead: number; buffer: TBuffer }> {
 		const bytesRead = this._read(buffer, offset, length, position);
-		await this.sync();
+		if (config.syncOnRead) await this.sync();
 		return { bytesRead, buffer };
 	}
 
@@ -559,7 +562,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 */
 	public readSync(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number {
 		const bytesRead = this._read(buffer, offset, length, position);
-		this.syncSync();
+		if (config.syncOnRead) this.syncSync();
 		return bytesRead;
 	}
 
@@ -569,7 +572,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		}
 		this.dirty = true;
 		this.stats.chmod(mode);
-		await this.sync();
+		if (config.syncOnWrite) await this.sync();
 	}
 
 	public chmodSync(mode: number): void {
@@ -578,7 +581,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		}
 		this.dirty = true;
 		this.stats.chmod(mode);
-		this.syncSync();
+		if (config.syncOnWrite) this.syncSync();
 	}
 
 	public async chown(uid: number, gid: number): Promise<void> {
@@ -587,7 +590,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		}
 		this.dirty = true;
 		this.stats.chown(uid, gid);
-		await this.sync();
+		if (config.syncOnWrite) await this.sync();
 	}
 
 	public chownSync(uid: number, gid: number): void {
@@ -596,7 +599,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		}
 		this.dirty = true;
 		this.stats.chown(uid, gid);
-		this.syncSync();
+		if (config.syncOnWrite) this.syncSync();
 	}
 
 	public async utimes(atime: Date, mtime: Date): Promise<void> {
@@ -606,7 +609,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		this.dirty = true;
 		this.stats.atime = atime;
 		this.stats.mtime = mtime;
-		await this.sync();
+		if (config.syncOnWrite) await this.sync();
 	}
 
 	public utimesSync(atime: Date, mtime: Date): void {
@@ -616,7 +619,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		this.dirty = true;
 		this.stats.atime = atime;
 		this.stats.mtime = mtime;
-		this.syncSync();
+		if (config.syncOnWrite) this.syncSync();
 	}
 
 	public async _setType(type: FileType): Promise<void> {

package/tests/fs/chmod.test.ts

@@ -4,45 +4,41 @@ import { fs } from '../common.js';
 
 const asyncMode = 0o777;
 const syncMode = 0o644;
+const file = 'a.js';
 
 suite('chmod tests', () => {
 	test('chmod', async () => {
-		const file1 = 'a.js';
+		await fs.promises.chmod(file, asyncMode.toString(8));
 
-		await fs.promises.chmod(file1, asyncMode.toString(8));
+		const stats = await fs.promises.stat(file);
+		assert.equal(stats.mode & 0o777, asyncMode);
 
-		const stats = await fs.promises.stat(file1);
-		assert((stats.mode & 0o777) === asyncMode);
-
-		fs.chmodSync(file1, syncMode);
-		assert((fs.statSync(file1).mode & 0o777) === syncMode);
+		fs.chmodSync(file, syncMode);
+		assert.equal(fs.statSync(file).mode & 0o777, syncMode);
 	});
 
 	test('fchmod', async () => {
-		const file2 = 'a1.js';
-
-		const handle = await fs.promises.open(file2, 'a', 0o644);
+		const handle = await fs.promises.open(file, 'a', 0o644);
 
 		await handle.chmod(asyncMode);
 		const stats = await handle.stat();
 
-		assert((stats.mode & 0o777) === asyncMode);
+		assert.equal(stats.mode & 0o777, asyncMode);
 
 		fs.fchmodSync(handle.fd, syncMode);
-		assert((fs.statSync(file2).mode & 0o777) === syncMode);
+		assert.equal(fs.statSync(file).mode & 0o777, syncMode);
 	});
 
 	test('lchmod', async () => {
 		const link = 'symbolic-link';
-		const target = 'a1.js';
 
-		await fs.promises.symlink(target, link);
+		await fs.promises.symlink(file, link);
 		await fs.promises.lchmod(link, asyncMode);
 
 		const stats = await fs.promises.lstat(link);
-		assert((stats.mode & 0o777) === asyncMode);
+		assert.equal(stats.mode & 0o777, asyncMode);
 
 		fs.lchmodSync(link, syncMode);
-		assert((fs.lstatSync(link).mode & 0o777) === syncMode);
+		assert.equal(fs.lstatSync(link).mode & 0o777, syncMode);
 	});
 });

package/tests/fs/truncate.test.ts

@@ -10,22 +10,22 @@ const path: string = 'truncate-file.txt',
 suite('Truncate, sync', () => {
 	test('initial write', () => {
 		fs.writeFileSync(path, data);
-		assert(fs.statSync(path).size === size);
+		assert.equal(fs.statSync(path).size, size);
 	});
 
 	test('truncate to 1024', () => {
 		fs.truncateSync(path, 1024);
-		assert(fs.statSync(path).size === 1024);
+		assert.equal(fs.statSync(path).size, 1024);
 	});
 
 	test('truncate to 0', () => {
 		fs.truncateSync(path);
-		assert(fs.statSync(path).size === 0);
+		assert.equal(fs.statSync(path).size, 0);
 	});
 
 	test('write', () => {
 		fs.writeFileSync(path, data);
-		assert(fs.statSync(path).size === size);
+		assert.equal(fs.statSync(path).size, size);
 	});
 
 	let fd: number;
@@ -35,12 +35,12 @@ suite('Truncate, sync', () => {
 
 	test('ftruncate to 1024', () => {
 		fs.ftruncateSync(fd, 1024);
-		assert(fs.fstatSync(fd).size === 1024);
+		assert.equal(fs.fstatSync(fd).size, 1024);
 	});
 
 	test('ftruncate to 0', () => {
 		fs.ftruncateSync(fd);
-		assert(fs.fstatSync(fd).size === 0);
+		assert.equal(fs.fstatSync(fd).size, 0);
 	});
 
 	test('close fd', () => {
@@ -53,22 +53,22 @@ suite('Truncate, async', () => {
 	test('initial write', async () => {
 		await fs.promises.writeFile(path, data);
 
-		assert((await statSize(path)) === 1024 * 16);
+		assert.equal(await statSize(path), 1024 * 16);
 	});
 
 	test('truncate to 1024', async () => {
 		await fs.promises.truncate(path, 1024);
-		assert((await statSize(path)) === 1024);
+		assert.equal(await statSize(path), 1024);
 	});
 
 	test('truncate to 0', async () => {
 		await fs.promises.truncate(path);
-		assert((await statSize(path)) === 0);
+		assert.equal(await statSize(path), 0);
 	});
 
 	test('write', async () => {
 		await fs.promises.writeFile(path, data);
-		assert((await statSize(path)) === size);
+		assert.equal(await statSize(path), size);
 	});
 
 	let handle: FileHandle;
@@ -79,13 +79,13 @@ suite('Truncate, async', () => {
 	test('handle.truncate to 1024', async () => {
 		await handle.truncate(1024);
 		await handle.sync();
-		assert((await statSize(path)) === 1024);
+		assert.equal(await statSize(path), 1024);
 	});
 
 	test('handle.truncate to 0', async () => {
 		await handle.truncate();
 		await handle.sync();
-		assert((await statSize(path)) === 0);
+		assert.equal(await statSize(path), 0);
 	});
 
 	test('close handle', async () => {