@zenfs/core 1.11.4 → 2.1.0

package/tests/fs/readFile.test.ts

@@ -4,7 +4,7 @@ import { fs } from '../common.js';
 
 suite('Reading', () => {
 	test('Cannot read a file with an invalid encoding', () => {
-		assert.throws(() => fs.readFileSync('a.js', 'wrongencoding' as BufferEncoding));
+		assert.throws(() => fs.readFileSync('a.js', 'wrong-encoding' as BufferEncoding));
 	});
 
 	test('Reading past the end of a file should not be an error', async () => {
@@ -12,9 +12,7 @@ suite('Reading', () => {
 		const { bytesRead } = await handle.read(new Uint8Array(10), 0, 10, 10000);
 		assert.equal(bytesRead, 0);
 	});
-});
 
-suite('Read and Unlink', () => {
 	const dir = 'test-readfile-unlink';
 	const file = 'test-readfile-unlink/test.bin';
 	const data = new Uint8Array(512).fill(42);
@@ -34,40 +32,26 @@ suite('Read and Unlink', () => {
 		await fs.promises.unlink(file);
 		await fs.promises.rmdir(dir);
 	});
-});
-
-suite('Read File Test', () => {
-	const fn = 'empty.txt';
 
-	test('read file asynchronously', async () => {
-		const data: Uint8Array = await fs.promises.readFile(fn);
-		assert(data != undefined);
-	});
+	const fileName = 'empty.txt';
 
-	test('read file with utf-8 encoding asynchronously', async () => {
-		const data: string = await fs.promises.readFile(fn, 'utf8');
-		assert.equal(data, '');
+	test('read file', async () => {
+		assert.equal((await fs.promises.readFile(fileName)).toString(), '');
+		assert.equal(fs.readFileSync(fileName).toString(), '');
 	});
 
-	test('read file synchronously', () => {
-		const data: Uint8Array = fs.readFileSync(fn);
-		assert(data != undefined);
+	test('read file with utf-8 encoding', async () => {
+		assert.equal(await fs.promises.readFile(fileName, 'utf8'), '');
+		assert.equal(fs.readFileSync(fileName, 'utf8'), '');
 	});
 
-	test('read file with utf-8 encoding synchronously', () => {
-		const data: string = fs.readFileSync(fn, 'utf8');
-		assert.equal(data, '');
-	});
-});
-
-suite('fs file reading', () => {
 	test('read file synchronously and verify the content', () => {
 		const content = fs.readFileSync('elipses.txt', 'utf8');
 
+		assert.equal(content.length, 10000);
+
 		for (let i = 0; i < content.length; i++) {
 			assert.equal(content[i], '…');
 		}
-
-		assert.equal(content.length, 10000);
 	});
 });

package/tests/fs/rename.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';
 
 suite('Rename', () => {
@@ -77,10 +76,8 @@ suite('Rename', () => {
 		await fs.promises.mkdir(dir);
 		await fs.promises.writeFile(file, 'file contents go here');
 
-		await fs.promises.rename(file, dir).catch((error: ErrnoError) => {
-			assert(error instanceof ErrnoError);
-			assert.match(error.code, /EISDIR|EPERM/);
-		});
+		await assert.rejects(fs.promises.rename(file, dir), { code: 'EISDIR' });
+		assert.throws(() => fs.renameSync(file, dir), { code: 'EISDIR' });
 	});
 
 	test('rename directory inside itself', async () => {
@@ -89,9 +86,7 @@ suite('Rename', () => {
 
 		await fs.promises.mkdir(renDir1);
 
-		await fs.promises.rename(renDir1, renDir2).catch((error: ErrnoError) => {
-			assert(error instanceof ErrnoError);
-			assert.equal(error.code, 'EBUSY');
-		});
+		await assert.rejects(fs.promises.rename(renDir1, renDir2), { code: 'EBUSY' });
+		assert.throws(() => fs.renameSync(renDir1, renDir2), { code: 'EBUSY' });
 	});
 });

package/tests/fs/stat.test.ts

@@ -1,14 +1,14 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { credentials } from '../../dist/index.js';
-import { Stats } from '../../dist/stats.js';
+import { defaultContext } from '../../dist/internal/contexts.js';
+import { Stats } from '../../dist/vfs/stats.js';
 import { fs } from '../common.js';
 
 suite('Stats', () => {
 	const existing_file = 'x.txt';
 
-	test('stat empty path', () => {
-		assert.rejects(fs.promises.stat(''));
+	test('stat empty path', async () => {
+		await assert.rejects(fs.promises.stat(''));
 	});
 
 	test('stat directory', async () => {
@@ -40,7 +40,7 @@ suite('Stats', () => {
 
 		fs.writeFileSync(newFile, 'hello', { mode: 0o640 });
 
-		const prevCredentials = { ...credentials };
+		const prevCredentials = { ...defaultContext.credentials };
 		const uid = 33;
 		const nonRootCredentials = {
 			uid,
@@ -53,7 +53,7 @@ suite('Stats', () => {
 
 		fs.chownSync(newFile, 0, nonRootCredentials.gid); // creating with root-user so that non-root user can access
 
-		Object.assign(credentials, nonRootCredentials);
+		Object.assign(defaultContext.credentials, nonRootCredentials);
 		const stat = fs.statSync(newFile);
 
 		assert.equal(stat.gid, nonRootCredentials.gid);
@@ -63,13 +63,13 @@ suite('Stats', () => {
 		assert.equal(stat.hasAccess(fs.constants.X_OK), false);
 		// changing group
 
-		Object.assign(credentials, { ...nonRootCredentials, gid: 44 });
+		Object.assign(defaultContext.credentials, { ...nonRootCredentials, gid: 44 });
 
 		assert.equal(stat.hasAccess(fs.constants.R_OK), false);
 		assert.equal(stat.hasAccess(fs.constants.W_OK), false);
 		assert.equal(stat.hasAccess(fs.constants.X_OK), false);
 
-		Object.assign(credentials, prevCredentials);
+		Object.assign(defaultContext.credentials, prevCredentials);
 	});
 
 	test('stat file', async () => {

package/tests/fs/streams.test.ts

@@ -129,21 +129,12 @@ suite('Streams', () => {
 	test('FileHandle.createReadStream after close should give an error', async () => {
 		const fileHandle = await fs.promises.open(testFilePath, 'r');
 		await fileHandle.close();
-		const stream = fileHandle.createReadStream();
-		const { promise, resolve, reject } = Promise.withResolvers();
-		setTimeout(resolve, 100);
-		stream.on('error', reject);
-		assert.rejects(promise);
+		assert.throws(() => fileHandle.createReadStream(), { code: 'EBADF' });
 	});
 
 	test('FileHandle.createWriteStream after close should give an error', async () => {
 		const fileHandle = await fs.promises.open(testFilePathWrite, 'w');
 		await fileHandle.close();
-		const stream = fileHandle.createWriteStream();
-		const { promise, resolve, reject } = Promise.withResolvers();
-		setTimeout(resolve, 100);
-		stream.on('error', reject);
-		assert.rejects(promise);
-		stream.write('Nuh-uh');
+		assert.throws(() => fileHandle.createWriteStream(), { code: 'EBADF' });
 	});
 });

package/tests/fs/times.test.ts

@@ -1,8 +1,8 @@
+import { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { wait } from 'utilium';
-import { ErrnoError } from '../../dist/index.js';
-import type { StatsLike } from '../../dist/stats.js';
+import type { StatsLike } from '../../dist/vfs/stats.js';
 import { fs } from '../common.js';
 
 const path = 'x.txt';
@@ -19,7 +19,7 @@ export function unixTimestamps(stats: StatsLike<number>): Record<'atime' | 'mtim
 	};
 }
 
-suite('times', () => {
+suite('Times', () => {
 	async function runTest(atime: Date | number, mtime: Date | number): Promise<void> {
 		const times = {
 			atime: typeof atime == 'number' ? Math.floor(atime) : atime.getTime(),
@@ -30,8 +30,8 @@ suite('times', () => {
 
 		assert.deepEqual(unixTimestamps(await fs.promises.stat(path)), times);
 
-		await fs.promises.utimes('foobarbaz', atime, mtime).catch((error: ErrnoError) => {
-			assert(error instanceof ErrnoError);
+		await fs.promises.utimes('foobarbaz', atime, mtime).catch((error: Exception) => {
+			assert(error instanceof Exception);
 			assert.equal(error.code, 'ENOENT');
 		});
 
@@ -46,14 +46,14 @@ suite('times', () => {
 		try {
 			fs.utimesSync('foobarbaz', atime, mtime);
 		} catch (error: any) {
-			assert(error instanceof ErrnoError);
+			assert(error instanceof Exception);
 			assert.equal(error.code, 'ENOENT');
 		}
 
 		try {
 			fs.futimesSync(-1, atime, mtime);
 		} catch (error: any) {
-			assert(error instanceof ErrnoError);
+			assert(error instanceof Exception);
 			assert.equal(error.code, 'EBADF');
 		}
 	}

package/tests/fs/truncate.test.ts

@@ -1,94 +1,66 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { fs } from '../common.js';
-import type { FileHandle } from '../../dist/vfs/promises.js';
 
 const path: string = 'truncate-file.txt',
 	size = 1024 * 16,
 	data = new Uint8Array(size).fill('x'.charCodeAt(0));
 
-suite('Truncate, sync', () => {
-	test('initial write', () => {
+suite('Truncating', () => {
+	test('Sync path functions', () => {
 		fs.writeFileSync(path, data);
 		assert.equal(fs.statSync(path).size, size);
-	});
 
-	test('truncate to 1024', () => {
 		fs.truncateSync(path, 1024);
 		assert.equal(fs.statSync(path).size, 1024);
-	});
 
-	test('truncate to 0', () => {
 		fs.truncateSync(path);
 		assert.equal(fs.statSync(path).size, 0);
-	});
 
-	test('write', () => {
 		fs.writeFileSync(path, data);
 		assert.equal(fs.statSync(path).size, size);
 	});
 
-	let fd: number;
-	test('open r+', () => {
-		fd = fs.openSync(path, 'r+');
-	});
+	test('FD functions', () => {
+		const fd = fs.openSync(path, 'r+');
 
-	test('ftruncate to 1024', () => {
 		fs.ftruncateSync(fd, 1024);
 		assert.equal(fs.fstatSync(fd).size, 1024);
-	});
 
-	test('ftruncate to 0', () => {
 		fs.ftruncateSync(fd);
 		assert.equal(fs.fstatSync(fd).size, 0);
-	});
 
-	test('close fd', () => {
 		fs.closeSync(fd);
 	});
-});
-suite('Truncate, async', () => {
+
 	const statSize = async (path: string) => (await fs.promises.stat(path)).size;
 
-	test('initial write', async () => {
+	test('Async path functions', async () => {
 		await fs.promises.writeFile(path, data);
 
 		assert.equal(await statSize(path), 1024 * 16);
-	});
 
-	test('truncate to 1024', async () => {
 		await fs.promises.truncate(path, 1024);
 		assert.equal(await statSize(path), 1024);
-	});
 
-	test('truncate to 0', async () => {
 		await fs.promises.truncate(path);
 		assert.equal(await statSize(path), 0);
-	});
 
-	test('write', async () => {
 		await fs.promises.writeFile(path, data);
 		assert.equal(await statSize(path), size);
 	});
 
-	let handle: FileHandle;
-	test('open w', async () => {
-		handle = await fs.promises.open(path, 'w');
-	});
+	test('FileHandle', async () => {
+		const handle = await fs.promises.open(path, 'w');
 
-	test('handle.truncate to 1024', async () => {
 		await handle.truncate(1024);
 		await handle.sync();
 		assert.equal(await statSize(path), 1024);
-	});
 
-	test('handle.truncate to 0', async () => {
 		await handle.truncate();
 		await handle.sync();
 		assert.equal(await statSize(path), 0);
-	});
 
-	test('close handle', async () => {
 		await handle.close();
 	});
 });

package/tests/fs/watch.test.ts

@@ -11,8 +11,8 @@ await fs.promises.writeFile(testFile, 'Initial content');
 /**
  * @todo convert using watcher to void discards pending ES proposal
  */
-await suite('Watch Features', () => {
-	test('fs.watch should emit events on file change', async () => {
+await suite('Watch', () => {
+	test('Events emitted on file change', async () => {
 		const { promise, resolve } = Promise.withResolvers<[string, string]>();
 
 		using watcher = fs.watch(testFile, (eventType, filename) => {
@@ -27,7 +27,7 @@ await suite('Watch Features', () => {
 		assert.equal(filename, 'test.txt');
 	});
 
-	test('fs.watch should emit events on file rename (delete)', async () => {
+	test('Events are emitted on delete', async () => {
 		using watcher = fs.watch(testFile, (eventType, filename) => {
 			assert.equal(eventType, 'rename');
 			assert.equal(filename, 'test.txt');
@@ -37,7 +37,7 @@ await suite('Watch Features', () => {
 		await fs.promises.unlink(testFile);
 	});
 
-	test('fs.watchFile should detect changes to a file', async () => {
+	test('Changes are detected with watchFile()', async () => {
 		const listener = (curr: Stats, prev: Stats) => {
 			assert(curr.mtimeMs != prev.mtimeMs);
 			fs.unwatchFile(testFile, listener);
@@ -49,7 +49,7 @@ await suite('Watch Features', () => {
 		await fs.promises.writeFile(testFile, 'Changed content');
 	});
 
-	test('fs.unwatchFile should stop watching the file', async () => {
+	test('unwatchFile() works', async () => {
 		let changeDetected = false;
 
 		const listener = () => {
@@ -66,7 +66,7 @@ await suite('Watch Features', () => {
 		assert(!changeDetected);
 	});
 
-	test('fs.watch should work with directories', async () => {
+	test('Directories can be watched', async () => {
 		using watcher = fs.watch(testDir, (eventType, filename) => {
 			assert.equal(eventType, 'change');
 			assert.equal(filename, 'newFile.txt');
@@ -75,7 +75,7 @@ await suite('Watch Features', () => {
 		await fs.promises.writeFile(testDir + '/newFile.txt', 'Content');
 	});
 
-	test('fs.watch should detect file renames', async () => {
+	test('File renames are detected', async () => {
 		const oldFileName = 'oldFile.txt';
 		const newFileName = 'newFile.txt';
 		const oldFile = testDir + '/' + oldFileName;
@@ -102,7 +102,7 @@ await suite('Watch Features', () => {
 		await Promise.all([newFileResolver.promise, oldFileResolver.promise]);
 	});
 
-	test('fs.watch should detect file deletions', async () => {
+	test('File deletions are detected', async () => {
 		const tempFile = `${testDir}/tempFile.txt`;
 
 		await fs.promises.writeFile(tempFile, 'Temporary content');
@@ -115,7 +115,7 @@ await suite('Watch Features', () => {
 		await fs.promises.unlink(tempFile);
 	});
 
-	test('fs.promises.watch should detect file deletions', async () => {
+	test('File deletions are detected by promises API', async () => {
 		const tempFile = `${testDir}/tempFile.txt`;
 
 		await fs.promises.writeFile(tempFile, 'Temporary content');
@@ -135,7 +135,7 @@ await suite('Watch Features', () => {
 		await promise;
 	});
 
-	test('fs.promises.watch should detect file creations recursively', async () => {
+	test('File creations are detected recursively', async () => {
 		const subDir = `${testDir}/sub-dir`;
 		const tempFile = `${subDir}/tempFile.txt`;
 		await fs.promises.mkdir(subDir);

package/tests/fs/write.test.ts

@@ -1,27 +1,33 @@
 import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path/posix';
 import { suite, test } from 'node:test';
 import { fs } from '../common.js';
-const fn = 'write.txt';
-suite('write', () => {
-	test('write file with specified content', async () => {
+import { data as dataPath } from '../setup.js';
+
+const fileName = 'write.txt';
+const utf8example = readFileSync(join(dataPath, 'utf8.txt'), 'utf8');
+
+suite('Writes', () => {
+	test('Using FileHandle and UTF-8', async () => {
 		const expected = 'ümlaut.';
 
-		const handle = await fs.promises.open(fn, 'w', 0o644);
+		const handle = await fs.promises.open(fileName, 'w', 0o644);
 		await handle.write('', 0, 'utf8');
 		const { bytesWritten } = await handle.write(expected, 0, 'utf8');
 		assert.equal(bytesWritten, Buffer.from(expected).length);
 		await handle.close();
 
-		const data = await fs.promises.readFile(fn, 'utf8');
+		const data = await fs.promises.readFile(fileName, 'utf8');
 		assert.equal(data, expected);
 
-		await fs.promises.unlink(fn);
+		await fs.promises.unlink(fileName);
 	});
 
-	test('write a buffer to a file', async () => {
+	test('Using FileHandle with buffer', async () => {
 		const expected = Buffer.from('hello');
 
-		const handle = await fs.promises.open(fn, 'w', 0o644);
+		const handle = await fs.promises.open(fileName, 'w', 0o644);
 
 		const written = await handle.write(expected, 0, expected.length, null);
 
@@ -29,13 +35,13 @@ suite('write', () => {
 
 		await handle.close();
 
-		assert.deepEqual(await fs.promises.readFile(fn), expected);
+		assert.deepEqual(await fs.promises.readFile(fileName), expected);
 
-		await fs.promises.unlink(fn);
+		await fs.promises.unlink(fileName);
 	});
 
-	test('writeSync file with specified content', () => {
-		const fd = fs.openSync(fn, 'w');
+	test('Using sync path functions', () => {
+		const fd = fs.openSync(fileName, 'w');
 
 		let written = fs.writeSync(fd, '');
 		assert.equal(written, 0);
@@ -48,6 +54,64 @@ suite('write', () => {
 
 		fs.closeSync(fd);
 
-		assert.equal(fs.readFileSync(fn, 'utf8'), 'foobár');
+		assert.equal(fs.readFileSync(fileName, 'utf8'), 'foobár');
+	});
+
+	test('Using promises API', async () => {
+		const filename = 'test.txt';
+		await fs.promises.writeFile(filename, utf8example);
+		const data = await fs.promises.readFile(filename);
+		assert.equal(data.length, Buffer.from(utf8example).length);
+		await fs.promises.unlink(filename);
+	});
+
+	test('Using promises API with buffer', async () => {
+		const filename = 'test2.txt';
+		const expected = Buffer.from(utf8example, 'utf8');
+
+		await fs.promises.writeFile(filename, expected);
+		const actual = await fs.promises.readFile(filename);
+		assert.equal(actual.length, expected.length);
+
+		await fs.promises.unlink(filename);
+	});
+
+	test('Promises API with base64 data', async () => {
+		const data = readFileSync(join(dataPath, 'image.jpg'), 'base64');
+
+		const buffer = Buffer.from(data, 'base64');
+		const filePath = 'test.jpg';
+
+		await fs.promises.writeFile(filePath, buffer);
+
+		const read = await fs.promises.readFile(filePath, 'base64');
+		assert.equal(read, data);
+	});
+
+	test('Using sync path functions with custom mode', () => {
+		const file = 'testWriteFileSync.txt';
+		const mode = 0o755;
+
+		fs.writeFileSync(file, '123', { mode });
+
+		const content = fs.readFileSync(file, 'utf8');
+		assert.equal(content, '123');
+		assert.equal(fs.statSync(file).mode & 0o777, mode);
+
+		fs.unlinkSync(file);
+	});
+
+	test('Appending to a file synchronously with custom mode', () => {
+		const file = 'testAppendFileSync.txt';
+		const mode = 0o755;
+
+		fs.appendFileSync(file, 'abc', { mode });
+
+		const content = fs.readFileSync(file, { encoding: 'utf8' });
+		assert.equal(content, 'abc');
+
+		assert.equal(fs.statSync(file).mode & 0o777, mode);
+
+		fs.unlinkSync(file);
 	});
 });

package/tests/fs/xattr.test.ts

@@ -0,0 +1,85 @@
+import { Buffer } from 'buffer';
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { fs } from '../common.js';
+
+suite('Extended Attributes', () => {
+	const testFile = 'xattr-test.txt';
+	const testValue = 'test value';
+	const testName = 'user.test';
+
+	test.before(() => fs.promises.writeFile(testFile, 'test content'));
+	test.after(() => fs.promises.unlink(testFile));
+
+	test('Non-user attribute set fails', async () => {
+		await assert.rejects(fs.xattr.set(testFile, 'system.test', 'value'), { code: 'ENOTSUP' });
+	});
+
+	test('set and get attributes', async () => {
+		await fs.xattr.set(testFile, testName, testValue);
+		const value = await fs.xattr.get(testFile, testName, { encoding: 'utf8' });
+		assert.equal(value, testValue);
+	});
+
+	test('get attributes with buffer encoding', async () => {
+		await fs.xattr.set(testFile, 'user.buffer', 'buffer value');
+		const buffer = await fs.xattr.get(testFile, 'user.buffer', { encoding: 'buffer' });
+		assert(buffer instanceof Uint8Array);
+		assert.equal(Buffer.from(buffer).toString(), 'buffer value');
+	});
+
+	test('remove attributes', async () => {
+		await fs.xattr.set(testFile, 'user.to-remove', testValue);
+		await fs.xattr.remove(testFile, 'user.to-remove');
+
+		await assert.rejects(fs.xattr.get(testFile, 'user.to-remove', { encoding: 'utf8' }), { code: 'ENODATA' });
+	});
+
+	test('list attributes', async () => {
+		await fs.xattr.set(testFile, 'user.list1', 'value1');
+		await fs.xattr.set(testFile, 'user.list2', 'value2');
+
+		const attrs = await fs.xattr.list(testFile);
+		assert(attrs.includes('user.list1'));
+		assert(attrs.includes('user.list2'));
+	});
+
+	test('handle create and replace options', async () => {
+		const flagTestName = 'user.flag-test';
+
+		await fs.xattr.set(testFile, flagTestName, 'original', { create: true });
+
+		await assert.rejects(fs.xattr.set(testFile, flagTestName, 'new value', { create: true }), { code: 'EEXIST' });
+
+		await fs.xattr.set(testFile, flagTestName, 'updated', { replace: true });
+		const value = await fs.xattr.get(testFile, flagTestName, { encoding: 'utf8' });
+		assert.equal(value, 'updated');
+
+		await assert.rejects(fs.xattr.set(testFile, 'user.nonexistent', 'value', { replace: true }), { code: 'ENODATA' });
+	});
+
+	test('file must exist', async () => {
+		await assert.rejects(fs.xattr.set('nonexistent-file.txt', testName, 'value'), { code: 'ENOENT' });
+	});
+
+	test('synchronous operations', () => {
+		const syncAttrName = 'user.sync-test';
+
+		fs.xattr.setSync(testFile, syncAttrName, testValue);
+		const value = fs.xattr.getSync(testFile, syncAttrName, { encoding: 'utf8' });
+		assert.equal(value, testValue);
+
+		fs.xattr.removeSync(testFile, syncAttrName);
+
+		assert.throws(() => fs.xattr.getSync(testFile, syncAttrName, { encoding: 'utf8' }), { code: 'ENODATA' });
+
+		const syncList1 = 'user.sync-list1';
+		const syncList2 = 'user.sync-list2';
+		fs.xattr.setSync(testFile, syncList1, 'value1');
+		fs.xattr.setSync(testFile, syncList2, 'value2');
+
+		const attrs = fs.xattr.listSync(testFile);
+		assert(attrs.includes(syncList1));
+		assert(attrs.includes(syncList2));
+	});
+});

package/tests/logs.js

@@ -0,0 +1,22 @@
+import { log } from 'kerium';
+
+export function setupLogs(prefix) {
+	const { ZENFS_LOG_LEVEL } = process.env;
+
+	let level = log.Level.ERR;
+
+	if (ZENFS_LOG_LEVEL) {
+		const tmp = parseInt(ZENFS_LOG_LEVEL);
+		if (Number.isSafeInteger(tmp)) level = tmp;
+		else level = ZENFS_LOG_LEVEL;
+	}
+
+	log.configure({
+		enabled: true,
+		format: log.fancy({ style: 'ansi', colorize: 'message' }),
+		dumpBacklog: true,
+		level,
+		stack: true,
+		output: (...msg) => (prefix ? console.error(prefix, ...msg) : console.error(...msg)),
+	});
+}

package/tests/setup/context.ts

@@ -4,6 +4,6 @@ import { copySync, data } from '../setup.js';
 
 _fs.mkdirSync('/new_root');
 
-export const { fs } = bindContext('/new_root');
+export const { fs } = bindContext({ root: '/new_root' });
 
 copySync(data, fs);

package/tests/setup/index.ts

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path/posix';
-import { configureSingle, InMemory, InMemoryStore, mounts, Overlay, Readonly, resolveMountConfig, StoreFS } from '../../dist/index.js';
+import { configureSingle, CopyOnWrite, InMemory, InMemoryStore, mounts, Readonly, StoreFS } from '../../dist/index.js';
 import { S_IFDIR } from '../../dist/vfs/constants.js';
 import { copySync, data } from '../setup.js';
 
@@ -32,7 +32,7 @@ const readable = new MockFS();
 await readable.ready();
 
 await configureSingle({
-	backend: Overlay,
+	backend: CopyOnWrite,
 	readable,
-	writable: await resolveMountConfig({ backend: InMemory, name: 'cow' }),
+	writable: { backend: InMemory, label: 'cow' },
 });