@zenfs/core 1.2.0 → 1.2.2

package/src/emulation/sync.ts

@@ -9,7 +9,8 @@ import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTi
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { _statfs, config, fd2file, fdMap, file2fd, fixError, mounts, resolveMount, type InternalOptions, type ReaddirOptions } from './shared.js';
+import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount, type InternalOptions, type ReaddirOptions } from './shared.js';
+import { config } from './config.js';
 import { emitChange } from './watchers.js';
 import * as cache from './cache.js';
 
@@ -105,7 +106,7 @@ export function unlinkSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		if (config.checkAccess && !(cache.getStats(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
+		if (config.checkAccess && !(cache.getStatsSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'unlink');
 		}
 		fs.unlinkSync(resolved);
@@ -386,7 +387,7 @@ export function rmdirSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	try {
-		const stats = cache.getStats(path) || fs.statSync(resolved);
+		const stats = cache.getStatsSync(path) || fs.statSync(resolved);
 		if (!stats.isDirectory()) {
 			throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
 		}
@@ -459,8 +460,8 @@ export function readdirSync(
 	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	let entries: string[];
 	try {
-		const stats = cache.getStats(path) || fs.statSync(resolved);
-		cache.setStats(path, stats);
+		const stats = cache.getStatsSync(path) || fs.statSync(resolved);
+		cache.setStatsSync(path, stats);
 		if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'readdir');
 		}
@@ -487,8 +488,8 @@ export function readdirSync(
 	// Iterate over entries and handle recursive case if needed
 	const values: (string | Dirent | Buffer)[] = [];
 	for (const entry of entries) {
-		const entryStat = cache.getStats(join(path, entry)) || fs.statSync(join(resolved, entry));
-		cache.setStats(join(path, entry), entryStat);
+		const entryStat = cache.getStatsSync(join(path, entry)) || fs.statSync(join(resolved, entry));
+		cache.setStatsSync(join(path, entry), entryStat);
 
 		if (options?.withFileTypes) {
 			values.push(new Dirent(entry, entryStat));
@@ -512,7 +513,7 @@ export function readdirSync(
 	}
 
 	if (!options?._isIndirect) {
-		cache.clearStats();
+		cache.clearStatsSync();
 	}
 	return values as string[] | Dirent[] | Buffer[];
 }
@@ -670,7 +671,7 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 
 	let stats: Stats | undefined;
 	try {
-		stats = cache.getStats(path) || statSync(path);
+		stats = cache.getStatsSync(path) || statSync(path);
 	} catch (error) {
 		if ((error as ErrnoError).code != 'ENOENT' || !options?.force) throw error;
 	}
@@ -679,7 +680,7 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 		return;
 	}
 
-	cache.setStats(path, stats);
+	cache.setStatsSync(path, stats);
 
 	switch (stats.mode & constants.S_IFMT) {
 		case constants.S_IFDIR:
@@ -700,12 +701,12 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 		case constants.S_IFIFO:
 		case constants.S_IFSOCK:
 		default:
-			cache.clearStats();
+			cache.clearStatsSync();
 			throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
 	}
 
 	if (!options?._isIndirect) {
-		cache.clearStats();
+		cache.clearStatsSync();
 	}
 }
 rmSync satisfies typeof fs.rmSync;

package/src/file.ts

@@ -1,9 +1,10 @@
 import type { FileReadResult } from 'node:fs/promises';
 import { O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_SYNC, O_TRUNC, O_WRONLY, S_IFMT, size_max } from './emulation/constants.js';
+import { config } from './emulation/config.js';
 import { Errno, ErrnoError } from './error.js';
 import type { FileSystem } from './filesystem.js';
-import { Stats, type FileType } from './stats.js';
 import './polyfills.js';
+import { Stats, type FileType } from './stats.js';
 
 /**
 	Typescript does not include a type declaration for resizable array buffers. 
@@ -541,7 +542,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 };
 	}
 
@@ -556,7 +557,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.statSync();
+		if (config.syncOnRead) this.syncSync();
 		return bytesRead;
 	}
 

package/tests/common.ts

@@ -1,15 +1,5 @@
 import { join, resolve } from 'node:path';
-import { Worker } from 'node:worker_threads';
-import { fs } from '../src/index.js';
-
-/**
- * Creates a Typescript Worker
- * @see https://github.com/privatenumber/tsx/issues/354
- * @see https://github.com/nodejs/node/issues/47747#issuecomment-2287745567
- */
-export function createTSWorker(source: string): Worker {
-	return new Worker(`import('tsx/esm/api').then(tsx => {tsx.register();import('${source}');});`, { eval: true });
-}
+import { fs } from '../dist/index.js';
 
 const setupPath = resolve(process.env.SETUP || join(import.meta.dirname, 'setup/memory.ts'));
 

package/tests/fs/appendFile.test.ts

@@ -10,7 +10,7 @@ suite('appendFile', () => {
 		const filename = 'append.txt';
 		await fs.promises.appendFile(filename, content);
 		const data = await fs.promises.readFile(filename, 'utf8');
-		assert(data == content);
+		assert.equal(data, content);
 	});
 
 	test('append data to a non-empty file', async () => {
@@ -19,7 +19,7 @@ suite('appendFile', () => {
 		await fs.promises.writeFile(filename, original);
 		await fs.promises.appendFile(filename, content);
 		const data = await fs.promises.readFile(filename, 'utf8');
-		assert(data == original + content);
+		assert.equal(data, original + content);
 	});
 
 	test('append a buffer to the file', async () => {
@@ -28,6 +28,6 @@ suite('appendFile', () => {
 		await fs.promises.writeFile(filename, original);
 		await fs.promises.appendFile(filename, content);
 		const data = await fs.promises.readFile(filename, 'utf8');
-		assert(data == original + content);
+		assert.equal(data, original + content);
 	});
 });

package/tests/fs/dir.test.ts

@@ -18,8 +18,8 @@ suite('Dirent', () => {
 		const stats = await fs.promises.lstat(testFile);
 		const dirent = new fs.Dirent(testFile, stats);
 
-		assert(dirent.name === testFile);
-		assert(dirent.parentPath === testFile);
+		assert.equal(dirent.name, testFile);
+		assert.equal(dirent.parentPath, testFile);
 	});
 
 	test('Dirent.isFile', async () => {
@@ -68,7 +68,7 @@ suite('Dir', () => {
 		assert(testFiles.includes(dirent2?.name));
 
 		const dirent3 = await dir.read();
-		assert(dirent3 === null);
+		assert.strictEqual(dirent3, null);
 
 		await dir.close();
 	});
@@ -76,8 +76,8 @@ suite('Dir', () => {
 	test('Dir read() method (Callback varient)', (_, done) => {
 		const dir = new fs.Dir(testDirPath);
 		dir.read((err, dirent) => {
-			assert(err === undefined);
-			assert(dirent != undefined);
+			assert.strictEqual(err, undefined);
+			assert.notEqual(dirent, undefined);
 			assert(dirent instanceof fs.Dirent);
 			assert(testFiles.includes(dirent?.name));
 			dir.closeSync();
@@ -97,7 +97,7 @@ suite('Dir', () => {
 		assert(testFiles.includes(dirent2?.name));
 
 		const dirent3 = dir.readSync();
-		assert(dirent3 === null);
+		assert.strictEqual(dirent3, null);
 
 		dir.closeSync();
 	});
@@ -122,7 +122,7 @@ suite('Dir', () => {
 			dirents.push(dirent);
 		}
 
-		assert(dirents.length === 2);
+		assert.strictEqual(dirents.length, 2);
 		assert(dirents[0] instanceof fs.Dirent);
 		assert(testFiles.includes(dirents[0].name));
 		assert(testFiles.includes(dirents[1].name));

package/tests/fs/directory.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
-import { ErrnoError } from '../../src/error.js';
+import { ErrnoError } from '../../dist/error.js';
 import { fs } from '../common.js';
 
 suite('Directory', () => {
@@ -17,7 +17,7 @@ suite('Directory', () => {
 			await fs.promises.mkdir('/nested/dir');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		}
 		assert(!(await fs.promises.exists('/nested/dir')));
 	});
@@ -51,7 +51,7 @@ suite('Directory', () => {
 			fs.readdirSync('/two');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'EACCES');
+			assert.strictEqual(error.code, 'EACCES');
 		}
 	});
 
@@ -63,7 +63,7 @@ suite('Directory', () => {
 			await fs.promises.rmdir('/rmdirTest');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOTEMPTY');
+			assert.strictEqual(error.code, 'ENOTEMPTY');
 		}
 	});
 
@@ -75,7 +75,7 @@ suite('Directory', () => {
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
 			wasThrown = true;
-			assert(error.code === 'ENOTDIR');
+			assert.strictEqual(error.code, 'ENOTDIR');
 		}
 		assert(wasThrown);
 	});
@@ -85,7 +85,7 @@ suite('Directory', () => {
 			await fs.promises.readdir('a.js');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOTDIR');
+			assert.strictEqual(error.code, 'ENOTDIR');
 		}
 	});
 
@@ -97,7 +97,7 @@ suite('Directory', () => {
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
 			wasThrown = true;
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		}
 		assert(wasThrown);
 	});
@@ -107,7 +107,7 @@ suite('Directory', () => {
 			await fs.promises.readdir('/does/not/exist');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		}
 	});
 

package/tests/fs/errors.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
-import { ErrnoError } from '../../src/error.js';
+import { ErrnoError } from '../../dist/error.js';
 import { fs } from '../common.js';
 
 const existingFile = '/exit.js';

package/tests/fs/links.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
-import { join } from '../../src/emulation/path.js';
+import { join } from '../../dist/emulation/path.js';
 import { fs } from '../common.js';
 
 suite('Links', () => {
@@ -19,7 +19,7 @@ suite('Links', () => {
 
 	test('readlink', async () => {
 		const destination = await fs.promises.readlink(symlink);
-		assert(destination === target);
+		assert.strictEqual(destination, target);
 	});
 
 	test('unlink', async () => {
@@ -32,7 +32,7 @@ suite('Links', () => {
 		await fs.promises.link(target, hardlink);
 		const targetContent = await fs.promises.readFile(target, 'utf8');
 		const linkContent = await fs.promises.readFile(hardlink, 'utf8');
-		assert(targetContent === linkContent);
+		assert.strictEqual(targetContent, linkContent);
 	});
 
 	test('file inside symlinked directory', async () => {
@@ -41,6 +41,6 @@ suite('Links', () => {
 		const link = join('link', target);
 		assert((await fs.promises.realpath(link)) === target);
 		const linkContent = await fs.promises.readFile(link, 'utf8');
-		assert(targetContent === linkContent);
+		assert.strictEqual(targetContent, linkContent);
 	});
 });

package/tests/fs/open.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
-import { ErrnoError } from '../../src/error.js';
+import { ErrnoError } from '../../dist/error.js';
 import { fs } from '../common.js';
 
 suite('fs file opening', () => {
@@ -12,7 +12,7 @@ suite('fs file opening', () => {
 			fs.openSync('/path/to/file/that/does/not/exist', 'r');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error?.code === 'ENOENT');
+			assert.strictEqual(error?.code, 'ENOENT');
 			caughtException = true;
 		}
 		assert(caughtException);
@@ -23,7 +23,7 @@ suite('fs file opening', () => {
 			await fs.promises.open('/path/to/file/that/does/not/exist', 'r');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error?.code === 'ENOENT');
+			assert.strictEqual(error?.code, 'ENOENT');
 		}
 	});
 

package/tests/fs/permissions.test.ts

@@ -1,16 +1,16 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
-import { R_OK, W_OK, X_OK } from '../../src/emulation/constants.js';
-import { join } from '../../src/emulation/path.js';
-import { ErrnoError } from '../../src/error.js';
-import { encodeUTF8 } from '../../src/utils.js';
+import { R_OK, W_OK, X_OK } from '../../dist/emulation/constants.js';
+import { join } from '../../dist/emulation/path.js';
+import { ErrnoError } from '../../dist/error.js';
+import { encodeUTF8 } from '../../dist/utils.js';
 import { fs } from '../common.js';
 
 suite('Permissions', () => {
 	async function test_item(path: string): Promise<void> {
 		const stats = await fs.promises.stat(path).catch((error: ErrnoError) => {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'EACCES');
+			assert.strictEqual(error.code, 'EACCES');
 		});
 		if (!stats) {
 			return;

package/tests/fs/read.test.ts

@@ -10,7 +10,7 @@ suite('read', () => {
 		const handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead, buffer } = await handle.read(Buffer.alloc(expected.length), 0, expected.length, 0);
 
-		assert(bytesRead == expected.length);
+		assert.equal(bytesRead, expected.length);
 		assert(buffer.toString() == expected);
 	});
 
@@ -19,7 +19,7 @@ suite('read', () => {
 		const buffer = Buffer.alloc(expected.length);
 		const bytesRead = fs.readSync(fd, buffer, 0, expected.length, 0);
 
-		assert(bytesRead == expected.length);
+		assert.equal(bytesRead, expected.length);
 		assert(buffer.toString() == expected);
 	});
 });
@@ -44,7 +44,7 @@ suite('read buffer', () => {
 		const handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead } = await handle.read(bufferAsync, 0, expected.length, 0);
 
-		assert(bytesRead === expected.length);
+		assert.strictEqual(bytesRead, expected.length);
 		assert(bufferAsync.toString() === expected);
 	});
 
@@ -53,7 +53,7 @@ suite('read buffer', () => {
 		const bytesRead = fs.readSync(fd, bufferSync, 0, expected.length, 0);
 
 		assert(bufferSync.toString() === expected);
-		assert(bytesRead === expected.length);
+		assert.strictEqual(bytesRead, expected.length);
 	});
 
 	test('read file synchronously to non-zero offset', () => {
@@ -62,6 +62,6 @@ suite('read buffer', () => {
 		const bytesRead = fs.readSync(fd, buffer, 10, expected.length, 0);
 
 		assert(buffer.subarray(10, buffer.length).toString() === expected);
-		assert(bytesRead === expected.length);
+		assert.strictEqual(bytesRead, expected.length);
 	});
 });

package/tests/fs/readFile.test.ts

@@ -65,9 +65,9 @@ suite('fs file reading', () => {
 		const content = fs.readFileSync('elipses.txt', 'utf8');
 
 		for (let i = 0; i < content.length; i++) {
-			assert(content[i] === '…');
+			assert.strictEqual(content[i], '…');
 		}
 
-		assert(content.length === 10000);
+		assert.strictEqual(content.length, 10000);
 	});
 });

package/tests/fs/rename.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
-import { ErrnoError } from '../../src/error.js';
+import { ErrnoError } from '../../dist/error.js';
 import { fs } from '../common.js';
 
 suite('Rename', () => {
@@ -21,10 +21,10 @@ suite('Rename', () => {
 	 */
 	async function check_directory(dir: string) {
 		const contents = await fs.promises.readdir(dir);
-		assert(contents.length === 2);
+		assert.strictEqual(contents.length, 2);
 
 		const subContents = await fs.promises.readdir(dir + '/_rename_me');
-		assert(subContents.length === 1);
+		assert.strictEqual(subContents.length, 1);
 
 		assert(await fs.promises.exists(dir + '/file.dat'));
 		assert(await fs.promises.exists(dir + '/_rename_me/lol.txt'));
@@ -88,7 +88,7 @@ suite('Rename', () => {
 		  if (e == null) {
 			throw new Error("Failed invariant: Cannot rename a directory over a file.");
 		  } else {
-			assert(e.code === 'ENOTDIR');
+			assert.strictEqual(e.code, 'ENOTDIR');
 		  }
 		});*/
 	});
@@ -101,7 +101,7 @@ suite('Rename', () => {
 
 		await fs.promises.rename(renDir1, renDir2).catch((error: ErrnoError) => {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'EBUSY');
+			assert.strictEqual(error.code, 'EBUSY');
 		});
 	});
 });

package/tests/fs/stat.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
-import { Stats } from '../../src/stats.js';
+import { Stats } from '../../dist/stats.js';
 import { fs } from '../common.js';
 
 suite('Stats', () => {

package/tests/fs/streams.test.ts

@@ -18,7 +18,7 @@ suite('ReadStream', () => {
 			data += chunk;
 		});
 		readStream.on('end', () => {
-			assert(data == testData);
+			assert.equal(data, testData);
 			done();
 		});
 		readStream.on('error', err => {
@@ -33,7 +33,7 @@ suite('ReadStream', () => {
 			closed = true;
 		});
 		readStream.close(err => {
-			assert(err === undefined);
+			assert.strictEqual(err, undefined);
 			assert(closed);
 			done();
 		});
@@ -41,27 +41,27 @@ suite('ReadStream', () => {
 
 	test('ReadStream declared properties', () => {
 		const readStream = new fs.ReadStream();
-		assert(readStream.bytesRead === undefined);
-		assert(readStream.path === undefined);
-		assert(readStream.pending === undefined);
+		assert.strictEqual(readStream.bytesRead, undefined);
+		assert.strictEqual(readStream.path, undefined);
+		assert.strictEqual(readStream.pending, undefined);
 
 		// Assign values
 		readStream.bytesRead = 10;
 		readStream.path = testFilePath;
 		readStream.pending = false;
 
-		assert(readStream.bytesRead === 10);
-		assert(readStream.path === testFilePath);
+		assert.strictEqual(readStream.bytesRead, 10);
+		assert.strictEqual(readStream.path, testFilePath);
 		assert(!readStream.pending);
 	});
 
 	test('ReadStream close method can be called multiple times', (_, done) => {
 		const readStream = new fs.ReadStream();
 		readStream.close(err => {
-			assert(err === undefined);
+			assert.strictEqual(err, undefined);
 			// Call close again
 			readStream.close(err2 => {
-				assert(err2 === undefined);
+				assert.strictEqual(err2, undefined);
 				done();
 			});
 		});
@@ -94,7 +94,7 @@ suite('WriteStream', () => {
 			closed = true;
 		});
 		writeStream.close(err => {
-			assert(err === undefined);
+			assert.strictEqual(err, undefined);
 			assert(closed);
 			done();
 		});
@@ -102,27 +102,27 @@ suite('WriteStream', () => {
 
 	test('WriteStream declared properties', () => {
 		const writeStream = new fs.WriteStream();
-		assert(writeStream.bytesWritten === undefined);
-		assert(writeStream.path === undefined);
-		assert(writeStream.pending === undefined);
+		assert.strictEqual(writeStream.bytesWritten, undefined);
+		assert.strictEqual(writeStream.path, undefined);
+		assert.strictEqual(writeStream.pending, undefined);
 
 		// Assign values
 		writeStream.bytesWritten = 20;
 		writeStream.path = testFilePathWrite;
 		writeStream.pending = true;
 
-		assert(writeStream.bytesWritten === 20);
-		assert(writeStream.path === testFilePathWrite);
+		assert.strictEqual(writeStream.bytesWritten, 20);
+		assert.strictEqual(writeStream.path, testFilePathWrite);
 		assert(writeStream.pending);
 	});
 
 	test('WriteStream close method can be called multiple times', (_, done) => {
 		const writeStream = new fs.WriteStream();
 		writeStream.close(err => {
-			assert(err === undefined);
+			assert.strictEqual(err, undefined);
 			// Call close again
 			writeStream.close(err2 => {
-				assert(err2 === undefined);
+				assert.strictEqual(err2, undefined);
 				done();
 			});
 		});
@@ -139,7 +139,7 @@ suite('FileHandle', () => {
 				data += chunk;
 			});
 			readStream.on('end', () => {
-				assert(data == testData);
+				assert.equal(data, testData);
 				resolve();
 			});
 			readStream.on('error', reject);
@@ -159,7 +159,7 @@ suite('FileHandle', () => {
 			writeStream.on('error', reject);
 		});
 		const data = await fs.promises.readFile(testFilePathWrite, 'utf8');
-		assert(data == testData);
+		assert.equal(data, testData);
 		await fileHandle.close();
 	});
 

package/tests/fs/times.test.ts

@@ -1,8 +1,8 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
 import { wait } from 'utilium';
-import { ErrnoError } from '../../src/error.js';
-import { _toUnixTimestamp } from '../../src/utils.js';
+import { ErrnoError } from '../../dist/error.js';
+import { _toUnixTimestamp } from '../../dist/utils.js';
 import { fs } from '../common.js';
 
 suite('times', () => {
@@ -21,7 +21,7 @@ suite('times', () => {
 
 		await fs.promises.utimes('foobarbaz', atime, mtime).catch((error: ErrnoError) => {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		});
 
 		// don't close this fd
@@ -40,21 +40,21 @@ suite('times', () => {
 			expect_assert(handle.fd, atime, mtime);
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOSYS');
+			assert.strictEqual(error.code, 'ENOSYS');
 		}
 
 		try {
 			fs.utimesSync('foobarbaz', atime, mtime);
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		}
 
 		try {
 			fs.futimesSync(-1, atime, mtime);
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code == 'EBADF');
+			assert.equal(error.code, 'EBADF');
 		}
 	}
 

package/tests/fs/truncate.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
-import type { FileHandle } from '../../src/emulation/promises.js';
 import { fs } from '../common.js';
+import type { FileHandle } from '../../dist/emulation/promises.js';
 
 const path: string = 'truncate-file.txt',
 	size = 1024 * 16,