@zenfs/core 1.8.8 → 1.9.1

package/dist/vfs/watchers.d.ts

@@ -41,6 +41,7 @@ export declare class FSWatcher<T extends string | Buffer = string | Buffer> exte
     error: [error: Error];
 }> implements fs.FSWatcher {
     readonly options: fs.WatchOptions;
+    protected readonly realpath: string;
     constructor(context: V_Context, path: string, options: fs.WatchOptions);
     close(): void;
     [Symbol.dispose](): void;
@@ -71,5 +72,8 @@ export declare class StatWatcher extends Watcher<{
 }
 export declare function addWatcher(path: string, watcher: FSWatcher): void;
 export declare function removeWatcher(path: string, watcher: FSWatcher): void;
-export declare function emitChange(eventType: fs.WatchEventType, filename: string): void;
+/**
+ * @internal @hidden
+ */
+export declare function emitChange(context: V_Context, eventType: fs.WatchEventType, filename: string): void;
 export {};

package/dist/vfs/watchers.js

@@ -1,8 +1,8 @@
 import { EventEmitter } from 'eventemitter3';
-import { ErrnoError } from '../error.js';
+import { ErrnoError } from '../internal/error.js';
 import { isStatsEqual } from '../stats.js';
 import { normalizePath } from '../utils.js';
-import { basename, dirname } from './path.js';
+import { dirname, join, relative } from './path.js';
 import { statSync } from './sync.js';
 /**
  * Base class for file system watchers.
@@ -59,11 +59,12 @@ export class FSWatcher extends Watcher {
     constructor(context, path, options) {
         super(context, path);
         this.options = options;
-        addWatcher(path.toString(), this);
+        this.realpath = (context === null || context === void 0 ? void 0 : context.root) ? join(context.root, path) : path;
+        addWatcher(this.realpath, this);
     }
     close() {
         super.emit('close');
-        removeWatcher(this.path.toString(), this);
+        removeWatcher(this.realpath, this);
     }
     [Symbol.dispose]() {
         this.close();
@@ -134,28 +135,24 @@ export function removeWatcher(path, watcher) {
         }
     }
 }
-export function emitChange(eventType, filename) {
+/**
+ * @internal @hidden
+ */
+export function emitChange(context, eventType, filename) {
     var _a;
+    if (context)
+        filename = join((_a = context.root) !== null && _a !== void 0 ? _a : '/', filename);
     filename = normalizePath(filename);
-    // Notify watchers on the specific file
-    if (watchers.has(filename)) {
-        for (const watcher of watchers.get(filename)) {
-            watcher.emit('change', eventType, basename(filename));
-        }
-    }
     // Notify watchers on parent directories if they are watching recursively
     let parent = filename, normalizedFilename;
-    while (parent !== normalizedFilename) {
+    while (normalizedFilename != '/') {
         normalizedFilename = parent;
         parent = dirname(parent);
-        if (!watchers.has(parent))
+        const parentWatchers = watchers.get(parent);
+        if (!parentWatchers)
             continue;
-        for (const watcher of watchers.get(parent)) {
-            // Strip the context root from the path if the watcher has a context
-            const root = (_a = watcher._context) === null || _a === void 0 ? void 0 : _a.root;
-            const contextPath = root && filename.startsWith(root) ? filename.slice(root.length) : filename;
-            const relativePath = contextPath.slice(parent.length + (parent == '/' ? 0 : 1));
-            watcher.emit('change', eventType, relativePath);
+        for (const watcher of parentWatchers) {
+            watcher.emit('change', eventType, relative(parent, filename));
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.8.8",
+	"version": "1.9.1",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -58,7 +58,7 @@
 		"format": "prettier --write .",
 		"format:check": "prettier --check .",
 		"lint": "eslint src tests",
-		"test": "npx zenfs-test --clean && npx zenfs-test -abcfp && tests/fetch/run.sh && npx zenfs-test --report",
+		"test": "npx zenfs-test --clean; npx zenfs-test -abcfp; tests/fetch/run.sh; npx zenfs-test --report",
 		"build": "tsc -p tsconfig.json",
 		"build:docs": "typedoc",
 		"dev": "npm run build -- --watch",
@@ -70,7 +70,7 @@
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
 		"readable-stream": "^4.5.2",
-		"utilium": "^1.1.1"
+		"utilium": "^1.2.10"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.8.0",

package/readme.md

@@ -6,11 +6,11 @@ ZenFS is a cross-platform library that emulates the [NodeJS filesystem API](http
 
 ZenFS is modular and extensible. The core includes some built-in backends:
 
--   `InMemory`: Stores files in-memory. This is cleared when the runtime ends (e.g. a user navigating away from a web page or a Node process exiting)
--   `Overlay`: Use a read-only file system as read-write by overlaying a writable file system on top of it. ([copy-on-write](https://en.wikipedia.org/wiki/Copy-on-write))
--   `Fetch`: Downloads files over HTTP with the `fetch` API
--   `Port`: Interacts with a remote over a `MessagePort`-like interface (e.g. a worker)
--   `Passthrough`: Use an existing `node:fs` interface with ZenFS
+- `InMemory`: Stores files in-memory. This is cleared when the runtime ends (e.g. a user navigating away from a web page or a Node process exiting)
+- `Overlay`: Use a read-only file system as read-write by overlaying a writable file system on top of it. ([copy-on-write](https://en.wikipedia.org/wiki/Copy-on-write))
+- `Fetch`: Downloads files over HTTP with the `fetch` API
+- `Port`: Interacts with a remote over a `MessagePort`-like interface (e.g. a worker)
+- `Passthrough`: Use an existing `node:fs` interface with ZenFS
 
 ZenFS supports a number of other backends. Many are provided as separate packages under `@zenfs`. More backends can be defined by separate libraries by extending the `FileSystem` class and providing a `Backend` object.
 
@@ -207,18 +207,18 @@ A huge thank you to [![Deco.cx logo](https://avatars.githubusercontent.com/deco-
 
 ## Building
 
--   Make sure you have Node and NPM installed. You must have Node v18 or newer.
--   Install dependencies with `npm install`
--   Build using `npm run build`
--   You can find the built code in `dist`.
+- Make sure you have Node and NPM installed. You must have Node v18 or newer.
+- Install dependencies with `npm install`
+- Build using `npm run build`
+- You can find the built code in `dist`.
 
 ### Testing
 
 Run unit tests with:
 
--   `npm test` to run all tests using the default configuration
--   `npx zenfs-test -abc` to run the common tests and run the full FS suite against all included backends
-    -   You can also run this command to test your own backends, the `--auto` (`-a`) flag will automatically detect any setup scripts matching `tests/setup/*` or `tests/setup-*.ts`. If you do, you'll need to include the `c8` dependency for coverage.
+- `npm test` to run all tests using the default configuration
+- `npx zenfs-test -abc` to run the common tests and run the full FS suite against all included backends
+    - You can also run this command to test your own backends, the `--auto` (`-a`) flag will automatically detect any setup scripts matching `tests/setup/*` or `tests/setup-*.ts`. If you do, you'll need to include the `c8` dependency for coverage.
 
 ### BrowserFS Fork
 

package/scripts/test.js

@@ -2,7 +2,7 @@
 
 import { execSync } from 'node:child_process';
 import { existsSync, globSync, mkdirSync, rmSync } from 'node:fs';
-import { join, parse } from 'node:path';
+import { join, parse, basename } from 'node:path';
 import { parseArgs } from 'node:util';
 
 const { values: options, positionals } = parseArgs({
@@ -11,6 +11,7 @@ const { values: options, positionals } = parseArgs({
 		help: { short: 'h', type: 'boolean', default: false },
 		verbose: { short: 'w', 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 },
 		ci: { short: 'C', type: 'boolean', default: false },
 
@@ -50,6 +51,7 @@ Output:
     -h, --help          Outputs this help message
     -w, --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
     -C, --ci            Continuous integration (CI) mode. This interacts with the Github
                         Checks API for better test status. Requires @octokit/action
@@ -68,6 +70,7 @@ if (options.quiet && options.verbose) {
 }
 
 process.env.NODE_V8_COVERAGE = options.coverage;
+process.env.ZENFS_LOG_LEVEL = options.log;
 
 if (options.clean) {
 	rmSync(options.coverage, { recursive: true, force: true });
@@ -143,6 +146,10 @@ async function status(name) {
 			if (!options.quiet) console.log(`${color('passed', 32)}: ${name} ${time()}`);
 			if (options.ci) await ci.completeCheck(name, 'success');
 		},
+		async skip() {
+			if (!options.quiet) console.log(`${color('skipped', 33)}: ${name} ${time()}`);
+			if (options.ci) await ci.completeCheck(name, 'skipped');
+		},
 		async fail() {
 			console.error(`${color('failed', '1;31')}: ${name} ${time()}`);
 			if (options.ci) await ci.completeCheck(name, 'failure');
@@ -182,12 +189,17 @@ for (const setupFile of positionals) {
 
 	!options.quiet && console.log('Running tests:', name);
 
-	const { pass, fail } = await status(name);
+	const { pass, fail, skip } = await status(name);
+
+	if (basename(setupFile).startsWith('_')) {
+		await skip();
+		continue;
+	}
 
 	try {
 		execSync(
 			[
-				'tsx',
+				'tsx --trace-deprecation',
 				options.inspect ? 'inspect' : '',
 				'--test --experimental-test-coverage',
 				options.force ? '--test-force-exit' : '',

package/tests/backend/fetch.test.ts

@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict';
+import { join } from 'node:path';
+import { suite, test } from 'node:test';
+import { Worker } from 'node:worker_threads';
+import { Fetch, configureSingle, fs } from '../../dist/index.js';
+import { baseUrl, defaultEntries, indexPath, whenServerReady } from '../fetch/config.js';
+
+const server = new Worker(join(import.meta.dirname, '../fetch/server.js'));
+
+await whenServerReady();
+
+await suite('Fetch with `disableAsyncCache`', () => {
+	test('Configuration', async () => {
+		await configureSingle({
+			backend: Fetch,
+			disableAsyncCache: true,
+			remoteWrite: true,
+			baseUrl,
+			index: baseUrl + indexPath,
+		});
+	});
+
+	test('Read and write file', async () => {
+		await fs.promises.writeFile('/example', 'test');
+
+		const contents = await fs.promises.readFile('/example', 'utf8');
+
+		assert.equal(contents, 'test');
+	});
+
+	test('Make new directory', async () => {
+		await fs.promises.mkdir('/duck');
+		const stats = await fs.promises.stat('/duck');
+		assert(stats.isDirectory());
+	});
+
+	test('Read directory', async () => {
+		const entries = await fs.promises.readdir('/');
+
+		assert.deepEqual(entries, [...defaultEntries, 'example', 'duck']);
+	});
+
+	test('Uncached synchronous operations throw', () => {
+		assert.throws(() => fs.readFileSync('/x.txt', 'utf8'), { code: 'EAGAIN' });
+	});
+});
+
+await server.terminate();
+server.unref();

package/tests/backend/port.test.ts

@@ -0,0 +1,130 @@
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { MessageChannel, Worker } from 'node:worker_threads';
+import { Port, attachFS } from '../../dist/backends/port/fs.js';
+import type { InMemoryStore, StoreFS } from '../../dist/index.js';
+import { ErrnoError, InMemory, configure, configureSingle, fs, resolveMountConfig } from '../../dist/index.js';
+
+// Tests a mis-configured `Port` using a MessageChannel
+
+const timeoutChannel = new MessageChannel();
+timeoutChannel.port2.unref();
+
+await suite('Timeout', { timeout: 1000 }, () => {
+	test('Misconfiguration', async () => {
+		let error: ErrnoError;
+		try {
+			await configure({
+				mounts: {
+					'/tmp-timeout': { backend: InMemory, name: 'tmp' },
+					'/port': { backend: Port, port: timeoutChannel.port1, timeout: 100 },
+				},
+			});
+		} catch (e) {
+			assert(e instanceof ErrnoError);
+			error = e;
+		}
+		assert(error! instanceof ErrnoError);
+		assert.equal(error.code, 'EIO');
+		assert(error.message.includes('RPC Failed'));
+	});
+
+	test('Remote not attached', async () => {
+		let error: ErrnoError;
+		try {
+			await configureSingle({ backend: Port, port: timeoutChannel.port1, timeout: 100 });
+			await fs.promises.writeFile('/test', 'anything');
+		} catch (e) {
+			assert(e instanceof ErrnoError);
+			error = e;
+		}
+		assert(error! instanceof ErrnoError);
+		assert.equal(error.code, 'EIO');
+		assert(error.message.includes('RPC Failed'));
+	});
+});
+
+timeoutChannel.port1.unref();
+
+// Test configuration
+
+const configPort = new Worker(import.meta.dirname + '/config.worker.js');
+
+await suite('Remote FS with resolveRemoteMount', () => {
+	const content = 'FS is in a port';
+
+	test('Configuration', async () => {
+		await configureSingle({ backend: Port, port: configPort, timeout: 500 });
+	});
+
+	test('Write', async () => {
+		await fs.promises.writeFile('/test', content);
+	});
+
+	test('Read', async () => {
+		assert((await fs.promises.readFile('/test', 'utf8')) === content);
+	});
+});
+
+await configPort?.terminate();
+configPort.unref();
+
+// Test using a message channel
+
+const channel = new MessageChannel(),
+	content = 'FS is in a port';
+let tmpfs: StoreFS<InMemoryStore>;
+
+await suite('FS with MessageChannel', () => {
+	test('configuration', async () => {
+		tmpfs = await resolveMountConfig({ backend: InMemory, name: 'tmp' });
+		attachFS(channel.port2, tmpfs);
+		await configureSingle({ backend: Port, port: channel.port1, disableAsyncCache: true, timeout: 250 });
+	});
+
+	test('write', async () => {
+		await fs.promises.writeFile('/test', content);
+	});
+
+	test('remote content', () => {
+		fs.mount('/tmp', tmpfs);
+		assert(fs.readFileSync('/tmp/test', 'utf8') == content);
+		fs.umount('/tmp');
+	});
+
+	test('read', async () => {
+		assert((await fs.promises.readFile('/test', 'utf8')) === content);
+	});
+
+	test('readFileSync should throw', () => {
+		assert.throws(() => fs.readFileSync('/test', 'utf8'), { code: 'ENOTSUP' });
+	});
+});
+
+channel.port1.unref();
+channel.port2.unref();
+
+// Test using a worker
+
+const remotePort = new Worker(import.meta.dirname + '/remote.worker.js');
+
+await suite('Remote FS', () => {
+	const content = 'FS is in a port';
+
+	test('Configuration', async () => {
+		await configureSingle({ backend: Port, port: remotePort, timeout: 500 });
+	});
+
+	test('Write', async () => {
+		await fs.promises.writeFile('/test', content);
+	});
+
+	test('Read', async () => {
+		assert.equal(await fs.promises.readFile('/test', 'utf8'), content);
+	});
+
+	test('Cleanup', async () => {});
+});
+
+await remotePort.terminate();
+remotePort.unref();

package/tests/common/context.test.ts

@@ -2,6 +2,7 @@ import { suite, test } from 'node:test';
 import assert from 'node:assert/strict';
 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('/ctx');
@@ -38,19 +39,23 @@ suite('Context', () => {
 	});
 
 	test('watch should consider context', async () => {
-		let lastFile: string,
+		let lastFile: string | null = null,
 			events = 0;
 		const watcher = ctx.promises.watch('/', { recursive: true });
 
-		(async () => {
+		const silence = canary();
+		const promise = (async () => {
 			for await (const event of watcher) {
-				lastFile = event.filename!;
+				lastFile = event.filename;
 				if (++events == 2) return;
 			}
 		})();
+		silence();
 		await ctx.promises.writeFile('/xpto.txt', 'in real root');
-		assert.equal(lastFile!, 'xpto.txt');
+		assert.equal(lastFile, 'xpto.txt');
 		await ctx.promises.unlink('/xpto.txt');
 		assert.equal(lastFile, 'xpto.txt');
+		await watcher.return!();
+		await promise;
 	});
 });

package/tests/common.ts

@@ -1,8 +1,26 @@
 import { join, resolve } from 'node:path';
-import { fs as defaultFS } from '../dist/index.js';
-export type * from '../dist/vfs/index.js';
+import { fs as defaultFS, log } from '../dist/index.js';
+export type * from '../dist/index.js';
 
-const setupPath = resolve(process.env.SETUP || join(import.meta.dirname, 'setup/memory.ts'));
+const { ZENFS_LOG_LEVEL, SETUP } = process.env;
+
+let level: log.Level | (typeof log.levels)[log.Level] = log.Level.CRIT;
+
+if (ZENFS_LOG_LEVEL) {
+	const tmp = parseInt(ZENFS_LOG_LEVEL);
+	if (Number.isSafeInteger(tmp)) level = tmp;
+	else level = ZENFS_LOG_LEVEL as (typeof log.levels)[log.Level];
+}
+
+log.configure({
+	enabled: true,
+	format: log.formats.ansi_message,
+	dumpBacklog: true,
+	level,
+	output: console.error,
+});
+
+const setupPath = resolve(SETUP || join(import.meta.dirname, 'setup/memory.ts'));
 
 const setup = await import(setupPath).catch(error => {
 	console.log('Failed to import test setup:');

package/tests/data/utf8.txt

@@ -0,0 +1 @@
+南越国是前203年至前111年存在于岭南地区的一个国家，国都位于番禺，疆域包括今天中国的广东、广西两省区的大部份地区，福建省、湖南、贵州、云南的一小部份地区和越南的北部。南越国是秦朝灭亡后，由南海郡尉赵佗于前203年起兵兼并桂林郡和象郡后建立。前196年和前179年，南越国曾先后两次名义上臣属于西汉，成为西汉的“外臣”。前112年，南越国末代君主赵建德与西汉发生战争，被汉武帝于前111年所灭。南越国共存在93年，历经五代君主。南越国是岭南地区的第一个有记载的政权国家，采用封建制和郡县制并存的制度，它的建立保证了秦末乱世岭南地区社会秩序的稳定，有效的改善了岭南地区落后的政治、经济现状。

package/tests/fetch/config.js

@@ -0,0 +1,40 @@
+import { existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { createConnection } from 'node:net';
+import { join } from 'node:path';
+
+// Copied from setup.ts
+
+export const data = join(import.meta.dirname, '../data');
+
+export const defaultEntries = readdirSync(data);
+
+export const tmp = join(import.meta.dirname, '../tmp');
+
+if (!existsSync(tmp)) mkdirSync(tmp);
+
+export const port = 26514;
+
+export const baseUrl = 'http://localhost:' + port;
+
+export const indexPath = '/.index.json';
+
+export function whenServerReady() {
+	const { promise, resolve, reject } = Promise.withResolvers();
+
+	const timeout = setTimeout(reject, 10_000);
+
+	const interval = setInterval(() => {
+		const socket = createConnection(port)
+			.on('connect', () => {
+				socket.end();
+				clearTimeout(timeout);
+				clearInterval(interval);
+				resolve();
+			})
+			.on('error', () => {
+				// ignore
+			});
+	}, 250);
+
+	return promise;
+}

package/tests/fetch/fetch.ts

@@ -0,0 +1,20 @@
+import { configure, Fetch } from '../../dist/index.js';
+import { baseUrl } from './config.js';
+import * as log from '../../dist/internal/log.js';
+
+await configure({
+	mounts: {
+		'/': {
+			backend: Fetch,
+			baseUrl,
+			index: baseUrl + '/.index.json',
+		},
+	},
+	log: {
+		enabled: true,
+		output: console.error,
+		format: log.formats.ansi_message,
+		level: log.Level.INFO,
+		dumpBacklog: true,
+	},
+});

package/tests/fetch/run.sh

@@ -3,14 +3,14 @@
 # Credit: Dave Dopson, https://stackoverflow.com/a/246128/17637456
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 
-npx tsx $SCRIPT_DIR/server.ts &
+node $SCRIPT_DIR/server.js &
 PID=$!
 
 echo "Waiting for server to start..."
 until nc -z localhost 26514; do
-  sleep 0.5
+  sleep 0.25
 done
 
-npx zenfs-test $SCRIPT_DIR/cow+fetch.ts --preserve --force "$@"
+npx zenfs-test $SCRIPT_DIR/fetch.ts --preserve --force "$@"
 
 kill $PID

package/tests/fetch/{server.ts → server.js}

@@ -2,10 +2,7 @@ import { execSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { createServer } from 'node:http';
 import { join } from 'node:path';
-import { data, tmp } from '../setup.js';
-
-// If you change the port please update the setup file as well
-const port = 26514;
+import { data, port, tmp, indexPath } from './config.js';
 
 const statusCodes = {
 	ENOENT: 404,
@@ -13,7 +10,7 @@ const statusCodes = {
 
 try {
 	execSync(`npm exec make-index -- ${data} --output ${tmp}/index.json --quiet`, { stdio: 'inherit' });
-} catch (e: any) {
+} catch (e) {
 	if (e.signal == 'SIGINT') {
 		console.log('Aborted whilst creating index.');
 		process.exit(0);
@@ -24,20 +21,27 @@ try {
 }
 
 const server = createServer((request, response) => {
-	const { url = '' } = request;
+	response.statusCode = 200;
+	const { url = '', method } = request;
+
+	/**
+	 * @todo Test POST/DELETE
+	 */
+	if (method != 'GET') {
+		response.end();
+		return;
+	}
 
 	if (url == '/.ping') {
-		response.statusCode = 200;
 		response.end('pong');
 		return;
 	}
 
-	const path = url == '/.index.json' ? join(tmp, 'index.json') : join(data, url.slice(1) || '');
+	const path = url == indexPath ? join(tmp, 'index.json') : join(data, url.slice(1) || '');
 	try {
-		response.statusCode = 200;
 		response.end(readFileSync(path));
-	} catch (e: any) {
-		response.statusCode = statusCodes[e.code as keyof typeof statusCodes] || 400;
+	} catch (e) {
+		response.statusCode = statusCodes[e.code] || 400;
 		response.end();
 	}
 });

package/tests/fs/directory.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { ErrnoError } from '../../dist/error.js';
+import { ErrnoError } from '../../dist/index.js';
 import { fs } from '../common.js';
 
 const testDir = 'test-dir';

package/tests/fs/errors.test.ts

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

package/tests/fs/links.test.ts

@@ -2,7 +2,7 @@ import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { join } from '../../dist/vfs/path.js';
 import { fs } from '../common.js';
-import type { ErrnoError } from '../../dist/error.js';
+import type { ErrnoError } from '../../dist/index.js';
 
 suite('Links', () => {
 	const target = '/a1.js',

package/tests/fs/open.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { ErrnoError } from '../../dist/error.js';
+import { ErrnoError } from '../../dist/index.js';
 import { fs } from '../common.js';
 
 suite('fs file opening', () => {

package/tests/fs/permissions.test.ts

@@ -1,10 +1,9 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { credentials } from '../../dist/credentials.js';
+import { credentials, ErrnoError } from '../../dist/index.js';
+import { encodeUTF8 } from '../../dist/utils.js';
 import { R_OK, W_OK, X_OK } from '../../dist/vfs/constants.js';
 import { join } from '../../dist/vfs/path.js';
-import { ErrnoError } from '../../dist/error.js';
-import { encodeUTF8 } from '../../dist/utils.js';
 import { fs } from '../common.js';
 
 const asyncMode = 0o777;

package/tests/fs/rename.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { ErrnoError } from '../../dist/error.js';
+import { ErrnoError } from '../../dist/index.js';
 import { fs } from '../common.js';
 
 suite('Rename', () => {