@zenfs/core 2.0.0 → 2.1.0

package/dist/vfs/xattr.js

@@ -1,62 +1,55 @@
 import { Buffer } from 'buffer';
-import { pick } from 'utilium';
-import { Errno, ErrnoError } from '../internal/error.js';
+import { rethrow, setUVMessage, UV } from 'kerium';
 import { Attributes, hasAccess } from '../internal/inode.js';
 import { normalizePath } from '../utils.js';
 import { checkAccess } from './config.js';
 import { R_OK, W_OK } from './constants.js';
-import { fixError, resolveMount } from './shared.js';
+import { resolveMount } from './shared.js';
 const _allowedRestrictedNames = [];
 /**
  * Check permission for the attribute name.
  * For now, only attributes in the 'user' namespace are supported.
- * @throws EPERM for attributes in namespaces other than 'user'
+ * @throws ENOTSUP for attributes in namespaces other than 'user'
  */
 function checkName($, name, path, syscall) {
     if (!name.startsWith('user.') && !_allowedRestrictedNames.includes(name))
-        throw new ErrnoError(Errno.EPERM, 'Only attributes in the user namespace are supported', path, syscall);
+        throw UV('ENOTSUP', syscall, path);
 }
 export async function get(path, name, opt = {}) {
     var _a;
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     checkName(this, name, path, 'xattr.get');
-    try {
-        const inode = await fs.stat(resolved);
-        if (checkAccess && !hasAccess(this, inode, R_OK)) {
-            throw ErrnoError.With('EACCES', resolved, 'xattr.get');
-        }
-        (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
-        const attr = inode.attributes.get(name);
-        if (!attr)
-            throw ErrnoError.With('ENODATA', resolved, 'xattr.get');
-        const buffer = Buffer.from(attr.value);
-        return opt.encoding == 'buffer' || !opt.encoding ? buffer : buffer.toString(opt.encoding);
-    }
-    catch (e) {
-        throw fixError(e, { [resolved]: path });
-    }
+    const inode = await fs.stat(resolved).catch(rethrow('xattr.get', path));
+    if (checkAccess && !hasAccess(this, inode, R_OK))
+        throw UV('EACCES', 'xattr.get', path);
+    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    const value = inode.attributes.get(name);
+    if (!value)
+        throw UV('ENODATA', 'xattr.get', path);
+    const buffer = Buffer.from(value);
+    return opt.encoding == 'buffer' || !opt.encoding ? buffer : buffer.toString(opt.encoding);
 }
 export function getSync(path, name, opt = {}) {
     var _a;
     path = normalizePath(path);
     checkName(this, name, path, 'xattr.get');
     const { fs, path: resolved } = resolveMount(path, this);
+    let inode;
     try {
-        const inode = fs.statSync(resolved);
-        if (checkAccess && !hasAccess(this, inode, R_OK)) {
-            throw ErrnoError.With('EACCES', resolved, 'xattr.get');
-        }
-        (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
-        const attr = inode.attributes.get(name);
-        if (!attr)
-            throw ErrnoError.With('ENODATA', resolved, 'xattr.get');
-        const buffer = Buffer.from(attr.value);
-        return opt.encoding == 'buffer' || !opt.encoding ? buffer : buffer.toString(opt.encoding);
+        inode = fs.statSync(resolved);
     }
     catch (e) {
-        throw fixError(e, { [resolved]: path });
-    }
+        throw setUVMessage(Object.assign(e, { path }));
+    }
+    if (checkAccess && !hasAccess(this, inode, R_OK))
+        throw UV('EACCES', 'xattr.get', path);
+    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    const value = inode.attributes.get(name);
+    if (!value)
+        throw UV('ENODATA', 'xattr.get', path);
+    const buffer = Buffer.from(value);
+    return opt.encoding == 'buffer' || !opt.encoding ? buffer : buffer.toString(opt.encoding);
 }
 /**
  * Sets the value of an extended attribute.
@@ -71,25 +64,17 @@ export async function set(path, name, value, opt = {}) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     checkName(this, name, path, 'xattr.set');
-    try {
-        const inode = await fs.stat(resolved);
-        if (checkAccess && !hasAccess(this, inode, W_OK)) {
-            throw ErrnoError.With('EACCES', resolved, 'xattr.set');
-        }
-        (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
-        const attr = inode.attributes.get(name);
-        if (opt.create && attr) {
-            throw ErrnoError.With('EEXIST', resolved, 'xattr.set');
-        }
-        if (opt.replace && !attr) {
-            throw ErrnoError.With('ENODATA', resolved, 'xattr.set');
-        }
-        inode.attributes.set(name, Buffer.from(value));
-        await fs.touch(resolved, pick(inode, 'attributes'));
-    }
-    catch (e) {
-        throw fixError(e, { [resolved]: path });
-    }
+    const inode = await fs.stat(resolved).catch(rethrow('xattr.set', path));
+    if (checkAccess && !hasAccess(this, inode, W_OK))
+        throw UV('EACCES', 'xattr.set', path);
+    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    const attr = inode.attributes.get(name);
+    if (opt.create && attr)
+        throw UV('EEXIST', 'xattr.set', path);
+    if (opt.replace && !attr)
+        throw UV('ENODATA', 'xattr.set', path);
+    inode.attributes.set(name, Buffer.from(value));
+    await fs.touch(resolved, inode).catch(rethrow('xattr.set', path));
 }
 /**
  * Synchronously sets the value of an extended attribute.
@@ -104,24 +89,27 @@ export function setSync(path, name, value, opt = {}) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     checkName(this, name, path, 'xattr.set');
+    let inode;
+    try {
+        inode = fs.statSync(resolved);
+    }
+    catch (e) {
+        throw setUVMessage(Object.assign(e, { path }));
+    }
+    if (checkAccess && !hasAccess(this, inode, W_OK))
+        throw UV('EACCES', 'xattr.set', path);
+    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    const attr = inode.attributes.get(name);
+    if (opt.create && attr)
+        throw UV('EEXIST', 'xattr.set', path);
+    if (opt.replace && !attr)
+        throw UV('ENODATA', 'xattr.set', path);
+    inode.attributes.set(name, Buffer.from(value));
     try {
-        const inode = fs.statSync(resolved);
-        if (checkAccess && !hasAccess(this, inode, W_OK)) {
-            throw ErrnoError.With('EACCES', resolved, 'xattr.set');
-        }
-        (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
-        const attr = inode.attributes.get(name);
-        if (opt.create && attr) {
-            throw ErrnoError.With('EEXIST', resolved, 'xattr.set');
-        }
-        if (opt.replace && !attr) {
-            throw ErrnoError.With('ENODATA', resolved, 'xattr.set');
-        }
-        inode.attributes.set(name, Buffer.from(value));
-        fs.touchSync(resolved, pick(inode, 'attributes'));
+        fs.touchSync(resolved, inode);
     }
     catch (e) {
-        throw fixError(e, { [resolved]: path });
+        throw setUVMessage(Object.assign(e, { path }));
     }
 }
 /**
@@ -135,21 +123,15 @@ export async function remove(path, name) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     checkName(this, name, path, 'xattr.remove');
-    try {
-        const inode = await fs.stat(resolved);
-        if (checkAccess && !hasAccess(this, inode, W_OK)) {
-            throw ErrnoError.With('EACCES', resolved, 'xattr.remove');
-        }
-        (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
-        const attr = inode.attributes.get(name);
-        if (!attr)
-            throw ErrnoError.With('ENODATA', resolved, 'xattr.remove');
-        inode.attributes.remove(name);
-        await fs.touch(resolved, pick(inode, 'attributes'));
-    }
-    catch (e) {
-        throw fixError(e, { [resolved]: path });
-    }
+    const inode = await fs.stat(resolved).catch(rethrow('xattr.remove', path));
+    if (checkAccess && !hasAccess(this, inode, W_OK))
+        throw UV('EACCES', 'xattr.remove', path);
+    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    const attr = inode.attributes.get(name);
+    if (!attr)
+        throw UV('ENODATA', 'xattr.remove', path);
+    inode.attributes.remove(name);
+    await fs.touch(resolved, inode);
 }
 /**
  * Synchronously removes an extended attribute from a file.
@@ -162,20 +144,25 @@ export function removeSync(path, name) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     checkName(this, name, path, 'xattr.remove');
+    let inode;
     try {
-        const inode = fs.statSync(resolved);
-        if (checkAccess && !hasAccess(this, inode, W_OK)) {
-            throw ErrnoError.With('EACCES', resolved, 'xattr.remove');
-        }
-        (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
-        const attr = inode.attributes.get(name);
-        if (!attr)
-            throw ErrnoError.With('ENODATA', resolved, 'xattr.remove');
-        inode.attributes.remove(name);
-        fs.touchSync(resolved, pick(inode, 'attributes'));
+        inode = fs.statSync(resolved);
     }
     catch (e) {
-        throw fixError(e, { [resolved]: path });
+        throw setUVMessage(Object.assign(e, { path }));
+    }
+    if (checkAccess && !hasAccess(this, inode, W_OK))
+        throw UV('EACCES', 'xattr.remove', path);
+    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    const attr = inode.attributes.get(name);
+    if (!attr)
+        throw UV('ENODATA', 'xattr.remove', path);
+    inode.attributes.remove(name);
+    try {
+        fs.touchSync(resolved, inode);
+    }
+    catch (e) {
+        throw setUVMessage(Object.assign(e, { path }));
     }
 }
 /**
@@ -187,15 +174,10 @@ export function removeSync(path, name) {
 export async function list(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
-    try {
-        const inode = await fs.stat(resolved);
-        if (!inode.attributes)
-            return [];
-        return inode.attributes.keys();
-    }
-    catch (e) {
-        throw fixError(e, { [resolved]: path });
-    }
+    const inode = await fs.stat(resolved).catch(rethrow('xattr.list', path));
+    if (!inode.attributes)
+        return [];
+    return inode.attributes.keys().toArray();
 }
 /**
  * Synchronously lists all extended attributes of a file.
@@ -206,13 +188,14 @@ export async function list(path) {
 export function listSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
+    let inode;
     try {
-        const inode = fs.statSync(resolved);
-        if (!inode.attributes)
-            return [];
-        return inode.attributes.keys();
+        inode = fs.statSync(resolved);
     }
     catch (e) {
-        throw fixError(e, { [resolved]: path });
+        throw setUVMessage(Object.assign(e, { path }));
     }
+    if (!inode.attributes)
+        return [];
+    return inode.attributes.keys().toArray();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.0.0",
+	"version": "2.1.0",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -70,8 +70,10 @@
 		"@types/node": "^22.10.1 <22.13.7",
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
+		"kerium": "^1.3.4",
+		"memium": "^0.2.0",
 		"readable-stream": "^4.5.2",
-		"utilium": "^1.8.0"
+		"utilium": "^2.3.3"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.8.0",

package/scripts/test.js

@@ -9,7 +9,7 @@ const { values: options, positionals } = parseArgs({
 	options: {
 		// Output
 		help: { short: 'h', type: 'boolean', default: false },
-		verbose: { short: 'w', type: 'boolean', default: false },
+		verbose: { short: 'v', type: 'boolean', default: false },
 		quiet: { short: 'q', type: 'boolean', default: false },
 		log: { short: 'l', type: 'string', default: '' },
 		'file-names': { short: 'N', type: 'boolean', default: false },
@@ -49,7 +49,7 @@ Behavior:
 
 Output:
     -h, --help          Outputs this help message
-    -w, --verbose       Output verbose messages
+    -v, --verbose       Output verbose messages
     -q, --quiet         Don't output normal messages
     -l, --logs <level>  Change the default log level for test output. Level can be a number or string
     -N, --file-names    Use full file paths for tests from setup files instead of the base name

package/tests/assignment.ts

@@ -10,8 +10,8 @@
 	- ReadStream and WriteStream are excluded since they are polyfilled from another module
 */
 
-import { fs as zen } from '../src/index.js';
 import type * as node from 'node:fs';
+import { fs as zen } from '../src/index.js';
 
 type Mock = {
 	[K in Exclude<keyof typeof node, 'ReadStream' | 'WriteStream'>]: Omit<(typeof node)[K], '__promisify__' | 'native'>;

package/tests/backend/port.test.ts

@@ -13,7 +13,7 @@ const timeoutChannel = new MessageChannel();
 timeoutChannel.port2.unref();
 
 await suite('Timeout', { timeout: 1000 }, () => {
-	test('Misconfiguration', () => {
+	test('Misconfiguration', async () => {
 		const configured = configure({
 			mounts: {
 				'/tmp-timeout': { backend: InMemory, label: 'tmp' },
@@ -21,13 +21,13 @@ await suite('Timeout', { timeout: 1000 }, () => {
 			},
 		});
 
-		assert.rejects(configured, { code: 'EIO', message: /RPC Failed/ });
+		await assert.rejects(configured, { code: 'EIO', message: /RPC Failed/ });
 	});
 
-	test('Remote not attached', () => {
+	test('Remote not attached', async () => {
 		const configured = configureSingle({ backend: Port, port: timeoutChannel.port1, timeout: 100 });
 
-		assert.rejects(configured, { code: 'EIO', message: /RPC Failed/ });
+		await assert.rejects(configured, { code: 'EIO', message: /RPC Failed/ });
 	});
 });
 

package/tests/backend/single-buffer.test.ts

@@ -1,24 +1,53 @@
-import { test, suite } from 'node:test';
-import { fs, mount, resolveMountConfig, SingleBuffer, umount } from '../../dist/index.js';
 import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { Worker } from 'worker_threads';
+import { fs, mount, resolveMountConfig, SingleBuffer } from '../../dist/index.js';
+import { setupLogs } from '../logs.js';
+
+setupLogs();
 
 await suite('SingleBuffer', () => {
-	test('should be able to restore filesystem (with same metadata) from original buffer', async () => {
+	test('filesystem restoration from original buffer (with same metadata)', async () => {
 		const buffer = new ArrayBuffer(0x100000);
 
-		umount('/');
 		const writable = await resolveMountConfig({ backend: SingleBuffer, buffer });
-		mount('/', writable);
+		mount('/mnt', writable);
 
-		fs.writeFileSync('/example.ts', 'console.log("hello world")', 'utf-8');
-		const stats = fs.statSync('/example.ts');
+		fs.writeFileSync('/mnt/example.ts', 'console.log("hello world")', 'utf-8');
+		const stats = fs.statSync('/mnt/example.ts');
 
-		umount('/');
 		const snapshot = await resolveMountConfig({ backend: SingleBuffer, buffer });
-		mount('/', snapshot);
+		mount('/snapshot', snapshot);
 
-		const snapshotStats = fs.statSync('/example.ts');
+		const snapshotStats = fs.statSync('/snapshot/example.ts');
 
 		assert.deepEqual(snapshotStats, stats);
 	});
+
+	test('cross-thread SharedArrayBuffer', async () => {
+		const sharedBuffer = new SharedArrayBuffer(0x100000);
+
+		const writable = await resolveMountConfig({ backend: SingleBuffer, buffer: sharedBuffer });
+		fs.mkdirSync('/shared');
+		mount('/shared', writable);
+
+		const worker = new Worker(import.meta.dirname + '/single-buffer.worker.js', { workerData: sharedBuffer });
+
+		// Pause while we wait for the worker to emit the 'continue' message, which
+		// means it has mounted the filesystem and created /worker-file.ts
+		const { promise, resolve, reject } = Promise.withResolvers<void>();
+
+		setTimeout(reject, 1000);
+		worker.on('message', message => {
+			if (message === 'continue') resolve();
+			else reject(message ?? new Error('Failed'));
+		});
+
+		await promise;
+
+		await worker.terminate();
+		worker.unref();
+
+		assert(fs.existsSync('/shared/worker-file.ts'));
+	});
 });

package/tests/backend/single-buffer.worker.js

@@ -0,0 +1,30 @@
+import assert from 'node:assert';
+import { writeFileSync as _write } from 'node:fs';
+import { parentPort, workerData } from 'node:worker_threads';
+import { configureSingle, fs, SingleBuffer } from '../../dist/index.js';
+import { setupLogs } from '../logs.js';
+
+setupLogs('<worker>');
+
+const content = 'console.log("this file was created by the worker")';
+
+const view = new Uint8Array(workerData);
+
+if (process.env.DEBUG) _write('tmp/shared.bin', view);
+
+try {
+	await configureSingle({
+		backend: SingleBuffer,
+		buffer: workerData,
+	});
+
+	fs.writeFileSync('/worker-file.ts', content, 'utf-8');
+
+	assert.equal(fs.readFileSync('/worker-file.ts', 'utf-8'), content);
+} catch (e) {
+	if (process.env.DEBUG) _write('tmp/shared.bin', view);
+	console.error(e);
+	parentPort.postMessage(e);
+}
+
+parentPort.postMessage('continue');

package/tests/common/context.test.ts

@@ -1,8 +1,8 @@
-import { suite, test } from 'node:test';
 import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { canary } from 'utilium';
 import { bindContext } from '../../dist/context.js';
 import * as fs from '../../dist/vfs/index.js';
-import { canary } from 'utilium';
 
 fs.mkdirSync('/ctx');
 const { fs: ctx } = bindContext({ root: '/ctx' });

package/tests/common/mutex.test.ts

@@ -1,16 +1,16 @@
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
 import { wait } from 'utilium';
-import { Mutexed } from '../../dist/mixins/mutexed.js';
-import { StoreFS } from '../../dist/backends/store/fs.js';
 import { InMemoryStore } from '../../dist/backends/memory.js';
-import { suite, test } from 'node:test';
-import assert from 'node:assert/strict';
+import { StoreFS } from '../../dist/backends/store/fs.js';
+import { Mutexed } from '../../dist/mixins/mutexed.js';
 
-suite('LockFS mutex', () => {
+suite('Mutexed FS', () => {
 	const fs = new (Mutexed(StoreFS))(new InMemoryStore(0x10000, 'test'));
 	fs._fs.checkRootSync();
 
 	test('lock/unlock', () => {
-		const lock = fs.lockSync('/test', 'lock');
+		const lock = fs.lockSync();
 		assert(fs.isLocked);
 		lock.unlock();
 		assert(!fs.isLocked);
@@ -20,11 +20,11 @@ suite('LockFS mutex', () => {
 		let lock1Resolved = false;
 		let lock2Resolved = false;
 
-		const lock1 = fs.lock('/queued', 'test').then(lock => {
+		const lock1 = fs.lock().then(lock => {
 			lock1Resolved = true;
 			lock.unlock();
 		});
-		const lock2 = fs.lock('/queued', 'test').then(lock => {
+		const lock2 = fs.lock().then(lock => {
 			lock2Resolved = true;
 			lock.unlock();
 		});
@@ -50,7 +50,7 @@ suite('LockFS mutex', () => {
 		let x = 1;
 
 		async function foo() {
-			const lock = await fs.lock('raceConditions', 'test');
+			const lock = await fs.lock();
 			await wait(25);
 			x++;
 			lock.unlock();

package/tests/fetch/fetch.ts

@@ -1,6 +1,6 @@
+import { log } from 'kerium';
 import { configure, Fetch } from '../../dist/index.js';
 import { baseUrl } from './config.js';
-import * as log from '../../dist/internal/log.js';
 
 await configure({
 	mounts: {

package/tests/fs/append.test.ts

@@ -5,15 +5,15 @@ import { fs } from '../common.js';
 const content = 'Sample content',
 	original = 'ABCD';
 
-suite('appendFile', () => {
-	test('create an empty file and add content', async () => {
+suite('Appends', () => {
+	test('Create an empty file and add content', async () => {
 		const filename = 'append.txt';
 		await fs.promises.appendFile(filename, content);
 		const data = await fs.promises.readFile(filename, 'utf8');
 		assert.equal(data, content);
 	});
 
-	test('append data to a non-empty file', async () => {
+	test('Append data to a non-empty file', async () => {
 		const filename = 'append2.txt';
 
 		await fs.promises.writeFile(filename, original);
@@ -22,7 +22,7 @@ suite('appendFile', () => {
 		assert.equal(data, original + content);
 	});
 
-	test('append a buffer to the file', async () => {
+	test('Append a buffer to the file', async () => {
 		const filename = 'append3.txt';
 
 		await fs.promises.writeFile(filename, original);

package/tests/fs/directory.test.ts

@@ -27,7 +27,7 @@ suite('Directories', () => {
 	test('mkdirSync', async () => await fs.promises.mkdir('/two', 0o000));
 
 	test('mkdir, nested', async () => {
-		assert.rejects(fs.promises.mkdir('/nested/dir'), { code: 'ENOENT', path: '/nested' });
+		await assert.rejects(fs.promises.mkdir('/nested/dir'), { code: 'ENOENT', path: '/nested' });
 		assert(!(await fs.promises.exists('/nested/dir')));
 	});
 
@@ -59,39 +59,39 @@ suite('Directories', () => {
 		await fs.promises.mkdir('/rmdirTest');
 		await fs.promises.mkdir('/rmdirTest/rmdirTest2');
 
-		assert.rejects(fs.promises.rmdir('/rmdirTest'), { code: 'ENOTEMPTY' });
+		await assert.rejects(fs.promises.rmdir('/rmdirTest'), { code: 'ENOTEMPTY' });
 	});
 
 	test('readdirSync on file', () => {
 		assert.throws(() => fs.readdirSync('a.js'), { code: 'ENOTDIR' });
 	});
 
-	test('readdir on file', () => {
-		assert.rejects(fs.promises.readdir('a.js'), { code: 'ENOTDIR' });
+	test('readdir on file', async () => {
+		await assert.rejects(fs.promises.readdir('a.js'), { code: 'ENOTDIR' });
 	});
 
-	test('readdirSync on non-existant directory', () => {
+	test('readdirSync on non-existent directory', () => {
 		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('readdir on non-existent directory', async () => {
+		await assert.rejects(fs.promises.readdir('/does/not/exist'), { code: 'ENOENT' });
 	});
 
-	test('rm recursively asynchronously', async () => {
-		await fs.promises.mkdir('/rmDirRecusrively');
-		await fs.promises.mkdir('/rmDirRecusrively/rmDirNested');
-		await fs.promises.writeFile('/rmDirRecusrively/rmDirNested/test.txt', 'hello world!');
+	test('rm recursively', async () => {
+		await fs.promises.mkdir('/rmDirRecursively');
+		await fs.promises.mkdir('/rmDirRecursively/rmDirNested');
+		await fs.promises.writeFile('/rmDirRecursively/rmDirNested/test.txt', 'hello world!');
 
-		await fs.promises.rm('/rmDirRecusrively', { recursive: true });
+		await fs.promises.rm('/rmDirRecursively', { recursive: true });
 	});
 
-	test('rm recursively synchronously', () => {
-		fs.mkdirSync('/rmDirRecusrively');
-		fs.mkdirSync('/rmDirRecusrively/rmDirNested');
-		fs.writeFileSync('/rmDirRecusrively/rmDirNested/test.txt', 'hello world!');
+	test('rmSync recursively', () => {
+		fs.mkdirSync('/rmDirRecursively');
+		fs.mkdirSync('/rmDirRecursively/rmDirNested');
+		fs.writeFileSync('/rmDirRecursively/rmDirNested/test.txt', 'hello world!');
 
-		fs.rmSync('/rmDirRecusrively', { recursive: true });
+		fs.rmSync('/rmDirRecursively', { recursive: true });
 	});
 
 	test('readdir returns files and directories', async () => {
@@ -143,17 +143,17 @@ suite('Directories', () => {
 
 	test('readdir returns Dirent recursively', async () => {
 		const entries = await fs.promises.readdir(testDir, { recursive: true, withFileTypes: true });
-		assert(entries.find(entry => entry.path === 'file1.txt'));
-		assert(entries.find(entry => entry.path === 'subdir1/file4.txt'));
-		assert(entries.find(entry => entry.path === 'subdir2/file5.txt'));
+		const paths = entries.map(entry => entry.path).sort();
+		assert.equal(paths[0], 'file1.txt');
+		assert.equal(paths[4], 'subdir1/file4.txt');
+		assert.equal(paths[8], 'subdir2/file5.txt');
 	});
 
-	// New test for readdirSync with recursive: true
 	test('readdirSync returns files recursively', () => {
-		const entries = fs.readdirSync(testDir, { recursive: true });
-		assert(entries.includes('file1.txt'));
-		assert(entries.includes('subdir1/file4.txt'));
-		assert(entries.includes('subdir2/file5.txt'));
+		const entries = fs.readdirSync(testDir, { recursive: true }).sort();
+		assert.equal(entries[0], 'file1.txt');
+		assert.equal(entries[4], 'subdir1/file4.txt');
+		assert.equal(entries[8], 'subdir2/file5.txt');
 	});
 
 	test('Cyrillic file names', () => {