@zenfs/core 2.6.3 → 2.6.5

package/README.md

@@ -2,7 +2,7 @@
 
 ZenFS is a cross-platform library that emulates the [Node.js filesystem API](http://nodejs.org/api/fs.html).
 It works using a system of backends, which are used by ZenFS to store and retrieve data.
-ZenFS can also integrate with other tools.
+ZenFS should cover the full API surface of the latest Node.js version, though complex changes may lag a little bit.
 
 ## Backends
 

package/dist/backends/cow.js

@@ -116,11 +116,19 @@ export class CopyOnWriteFS extends FileSystem {
     _nextIno = 1;
     /** Moves the public inode numbers for a rename, including a directory's descendants */
     renameInos(oldPath, newPath) {
-        for (const [path, ino] of [...this.inos]) {
+        const changes = [];
+        for (const [path, ino] of this.inos) {
             if (path != oldPath && !path.startsWith(oldPath + '/'))
                 continue;
-            this.inos.delete(path);
-            this.inos.set(newPath + path.slice(oldPath.length), ino);
+            changes.push({
+                path,
+                add: newPath + path.slice(oldPath.length),
+                ino,
+            });
+        }
+        for (const change of changes) {
+            this.inos.delete(change.path);
+            this.inos.set(change.add, change.ino);
         }
     }
     /** Replaces the layer's inode number with the public one for `path` */

package/dist/internal/file_index.d.ts

@@ -17,6 +17,7 @@ export declare const version = 1;
  * @internal
  */
 export declare class Index extends Map<string, Inode> {
+    #private;
     maxSize: number;
     /**
      * Converts the index to JSON
@@ -26,6 +27,7 @@ export declare class Index extends Map<string, Inode> {
      * Converts the index to a string
      */
     toString(): string;
+    clear(): void;
     /**
      * Get the size in bytes of the index (including the size reported for each entry)
      */

package/dist/internal/file_index.js

@@ -21,7 +21,8 @@ export class Index extends Map {
         return {
             version,
             maxSize: this.maxSize,
-            entries: Object.fromEntries([...this].map(([k, v]) => [k, v.toJSON()])),
+            // @todo use `Iterator.map` #296
+            entries: Object.fromEntries(Array.from(this).map(([k, v]) => [k, v.toJSON()])),
         };
     }
     /**
@@ -30,6 +31,10 @@ export class Index extends Map {
     toString() {
         return JSON.stringify(this.toJSON());
     }
+    clear() {
+        super.clear();
+        this.#lastAlloc = 0;
+    }
     /**
      * Get the size in bytes of the index (including the size reported for each entry)
      */
@@ -74,12 +79,15 @@ export class Index extends Map {
         }
         return entries;
     }
+    #lastAlloc = 0;
     /**
      * Get the next available ID in the index
      * @internal
      */
     _alloc() {
-        return Math.max(...[...this.values()].flatMap(i => [i.ino, i.data])) + 1;
+        // @todo use `Iterator.flatMap` #296
+        this.#lastAlloc ||= Array.from(this.values()).reduce((max, inode) => Math.max(max, inode.ino, inode.data), 0);
+        return ++this.#lastAlloc;
     }
     /**
      * Gets a list of entries for each directory in the index.

package/dist/polyfills.js

@@ -43,7 +43,10 @@ Uint8Array.fromBase64 ??=
 Uint8Array.prototype.toHex ??=
     (warn('Using a polyfill of Uint8Array.prototype.toHex'),
         function toHex() {
-            return [...this].map(b => b.toString(16).padStart(2, '0')).join('');
+            // @todo use `Iterator.map` #296
+            return Array.from(this)
+                .map(b => b.toString(16).padStart(2, '0'))
+                .join('');
         });
 Uint8Array.fromHex ??=
     (warn('Using a polyfill of Uint8Array.fromHex'),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.6.3",
+	"version": "2.6.5",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -11,7 +11,9 @@
 	"keywords": [
 		"filesystem",
 		"node",
-		"storage"
+		"storage",
+		"fs",
+		"browser"
 	],
 	"bin": {
 		"make-index": "scripts/make-index.js",
@@ -44,14 +46,15 @@
 	},
 	"exports": {
 		".": "./dist/index.js",
-		"./*": "./dist/*",
+		"./*.js": "./dist/*.js",
+		"./*": "./dist/*.js",
 		"./emulation/*": "./dist/node/*",
 		"./promises": "./dist/node/promises.js",
 		"./readline": "./dist/node/readline.js",
-		"./constants": "./dist/constants.js",
-		"./path": "./dist/path.js",
 		"./eslint": "./eslint.shared.js",
-		"./tests/*": "./tests/*",
+		"./tests/*.ts": "./tests/*.ts",
+		"./tests/*.js": "./tests/*.js",
+		"./tests/*": "./tests/*.js",
 		"./types/*": "./types/*"
 	},
 	"publishConfig": {
@@ -64,7 +67,8 @@
 		"spdx:check": "npx lice -a src tests/*.ts tests/**/*.test.ts",
 		"spdx:fix": "npx lice -aw src tests/*.ts tests/**/*.test.ts",
 		"lint": "eslint src tests",
-		"test": "npx --silent zenfs-test --clean; npx --silent zenfs-test -abcp; tests/fetch/run.sh; npx --silent zenfs-test --report",
+		"test": "npx -s zenfs-test --clean; npx -s zenfs-test -abcpn; tests/fetch/run.sh; npx -s zenfs-test --report-only",
+		"test:native": "npx -s zenfs-test tests/native-setup.ts --verbose",
 		"build": "tsc -p tsconfig.json",
 		"build:docs": "typedoc",
 		"dev": "tsc -p tsconfig.json --watch",
@@ -86,12 +90,8 @@
 		"eslint": "^10.1.0",
 		"globals": "^17.3.0",
 		"prettier": "^3.2.5",
-		"tsx": "^4.19.1",
 		"typedoc": "^0.28.18",
 		"typescript": "^6.0.0",
 		"typescript-eslint": "^8.58.0"
-	},
-	"allowScripts": {
-		"esbuild": true
 	}
 }

package/scripts/test.js

@@ -26,11 +26,14 @@ const { values: options, positionals } = parseArgs({
 		skip: { short: 's', type: 'string', multiple: true, default: [] },
 		'exit-on-fail': { short: 'e', type: 'boolean' },
 		runs: { short: 'r', type: 'string', default: '1' },
+		// @todo [breaking] make using node the default and remove tsx completely
+		node: { short: 'n', type: 'boolean', default: false },
 
 		// Coverage and performance
 		coverage: { type: 'string', default: 'tests/.coverage' },
 		preserve: { short: 'p', type: 'boolean' },
 		report: { type: 'boolean', default: false },
+		'report-only': { type: 'boolean', default: false },
 		clean: { type: 'boolean', default: false },
 		profile: { type: 'boolean', default: false },
 	},
@@ -42,7 +45,8 @@ const { values: options, positionals } = parseArgs({
  * @param  {...any} args
  */
 function debug(...args) {
-	if (options.debug) console.debug(styleText('dim', '[debug]'), ...args.map(a => (typeof a === 'string' ? styleText('dim', a) : a)));
+	if (options.debug || process.env.DEBUG)
+		console.debug(styleText('dim', '[debug]'), ...args.map(a => (typeof a === 'string' ? styleText('dim', a) : a)));
 }
 
 if (options.help) {
@@ -61,6 +65,7 @@ Behavior:
     -I, --inspect         Use the inspector for debugging
     -s, --skip <pattern>  Skip tests with names matching the given pattern. Can be specified multiple times.
     -d, --debug           Output debug messages from the test runner
+    -n, --node            Use plain node instead of tsx. Requires use of erasable TS syntax only
 
 Output:
     -h, --help            Outputs this help message
@@ -74,9 +79,10 @@ Output:
 Coverage:
     --coverage <dir>      Override the default coverage data directory
     -p, --preserve        Do not delete or report coverage data
-    --report              ONLY report coverage
+    --report              Report coverage along with test results
+    --report-only         ONLY report coverage
     --clean               ONLY clean up coverage directory
-	--profile             Record performance profiles`);
+    --profile             Record performance profiles`);
 	process.exit();
 }
 
@@ -105,12 +111,13 @@ function report() {
 	}
 }
 
-if (options.report) {
+if (options['report-only']) {
 	report();
 	process.exit();
 }
 
-const nRuns = Number.isSafeInteger(parseInt(options.runs)) ? parseInt(options.runs) : 1;
+const nRuns = Number.isSafeInteger(parseInt(options.runs)) ? parseInt(options.runs) : 1,
+	nodeCommand = options.node ? 'node' : 'tsx';
 
 /** @type {typeof import('./ci.js')} */
 let ci;
@@ -175,7 +182,7 @@ function makeCommand(profileName, ...rest) {
 	]
 		.filter(v => v)
 		.filter(v => typeof v == 'string');
-	if (!options.quiet) debug('command: tsx', command.join(' '));
+	if (!options.quiet) debug('command: ' + nodeCommand, command.join(' '));
 
 	return command;
 }
@@ -235,7 +242,7 @@ async function runTests(config) {
 		}
 
 		try {
-			execFileSync('tsx', command, {
+			execFileSync(nodeCommand, command, {
 				stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
 			});
 			if (!options.quiet) console.log(`${styleText('green', 'passed')}${identText} ${time()}`);
@@ -283,4 +290,4 @@ for (const setupFile of positionals) {
 	});
 }
 
-if (!options.preserve) report();
+if (!options.preserve && options.report) report();

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

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-import assert from 'node:assert';
+import assert from 'node:assert/strict';
 import { randomBytes } from 'node:crypto';
 import { suite, test } from 'node:test';
 import { Worker } from 'worker_threads';
 import { sizeof } from 'memium';
 import { fs, mount, resolveMountConfig, SingleBuffer, vfs } from '@zenfs/core';
-import { MetadataBlock, SuperBlock } from '@zenfs/core/backends/single_buffer.js';
+import { MetadataBlock, SuperBlock } from '@zenfs/core/backends/single_buffer';
 import { setupLogs } from '../logs.js';
 
 setupLogs();

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

@@ -1,4 +1,4 @@
-import assert from 'node:assert';
+import assert from 'node:assert/strict';
 import { writeFileSync as _write } from 'node:fs';
 import { parentPort, workerData } from 'node:worker_threads';
 import { configureSingle, fs, SingleBuffer } from '../../dist/index.js';

package/tests/common/file_index.test.ts

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+import { Index, Inode } from '@zenfs/core';
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+
+/** Build an index with `n` file entries, using IDs 2..2n+1 */
+function buildIndex(n: number): Index {
+	const index = new Index();
+	index.set('/', new Inode({ ino: 0, data: 1, mode: 0o40755, nlink: 1 }));
+	for (let i = 0; i < n; i++) {
+		index.set(`/f${i}`, new Inode({ ino: 2 * i + 2, data: 2 * i + 3, mode: 0o100644, nlink: 1 }));
+	}
+	return index;
+}
+
+/** Calls `fn` with `depth` extra frames on the stack */
+function atDepth<T>(depth: number, fn: () => T): T {
+	return depth > 0 ? atDepth(depth - 1, fn) : fn();
+}
+
+suite('Index', () => {
+	test('_alloc returns an unused ID', () => {
+		const index = buildIndex(10);
+		assert.equal(index._alloc(), 22);
+	});
+
+	test('_alloc does not re-use IDs', () => {
+		const index = buildIndex(10);
+		const ids = new Set<number>();
+
+		for (let i = 0; i < 100; i++) {
+			const id = index._alloc();
+			assert.equal(index.getByID(id), undefined, `\`_alloc\` returned in-use ID ${id}`);
+			assert(!ids.has(id), `\`_alloc\` returned duplicate ID ${id}`);
+			ids.add(id);
+		}
+	});
+
+	test('_alloc works with a large index #312', () => {
+		const index = buildIndex(100_000);
+		assert.equal(index._alloc(), 200_002);
+	});
+
+	test('_alloc works with a large index and a deep stack #312', () => {
+		const index = buildIndex(60_000);
+		assert.equal(
+			atDepth(1000, () => index._alloc()),
+			120_002
+		);
+	});
+});

package/tests/common/glob.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { fs } from '../common.ts';
 
 // Set up a directory structure for glob tests
 fs.mkdirSync('/glob');

package/tests/common/inode.test.ts

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { Inode } from '@zenfs/core';
-import assert from 'node:assert';
+import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 
 suite('Inode manipulation', () => {

package/tests/common/utf8stream.test.ts

@@ -2,7 +2,7 @@
 import { Buffer } from 'buffer';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Utf8Stream', config('write'), () => {
 	test('writes synchronously', config('sync'), () => {

package/tests/common.ts

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { fs as defaultFS } from '@zenfs/core';
-import type { NodeFS } from '@zenfs/core/node/types.js';
+import type { NodeFS } from '@zenfs/core/node/types';
 import { join, resolve } from 'node:path';
 import { styleText } from 'node:util';
 import { setupLogs } from './logs.js';
@@ -41,7 +41,9 @@ export type TestFlag =
 	| 'xattr'
 	| 'times'
 	| 'tempdir'
-	| 'lchmod';
+	| 'lchmod'
+	| 'promises.exists'
+	| 'root';
 
 /**
  * Whether a backend supports a flag.

package/tests/fetch/fetch.ts

@@ -1,6 +1,6 @@
 import { configure, Fetch } from '@zenfs/core';
 import { log } from 'kerium';
-import type { TestFlag, TestFlagState } from '../common.js';
+import type { TestFlag, TestFlagState } from '../common.ts';
 import { baseUrl } from './config.js';
 
 await configure({

package/tests/fetch/run.sh

@@ -12,6 +12,6 @@ until nc -z localhost 26514; do
   sleep 0.25
 done
 
-npx --silent zenfs-test $SCRIPT_DIR/fetch.ts --preserve --force "$@"
+npx --silent zenfs-test $SCRIPT_DIR/fetch.ts --preserve --force --node "$@"
 
 kill $PID

package/tests/fs/append.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { fs, config } from '../common.js';
+import { fs, config } from '../common.ts';
 
 const content = 'Sample content',
 	original = 'ABCD';

package/tests/fs/concurrency.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Concurrency', config('write', 'async'), () => {
 	test('parallel writeFile in the same directory does not lose entries #256', async () => {

package/tests/fs/dir.test.ts

@@ -2,7 +2,7 @@
 import { sync, type Dirent } from '@zenfs/core';
 import assert, { rejects } from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const testFile = 'test-file.txt';
 fs.writeFileSync(testFile, 'Sample content');

package/tests/fs/directory.test.ts

@@ -2,7 +2,7 @@
 import assert from 'node:assert/strict';
 import { join } from 'node:path/posix';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const testDir = 'test-dir';
 const testFiles = ['file1.txt', 'file2.txt', 'file3.txt'];
@@ -22,7 +22,7 @@ for (const dir of testDirectories) {
 suite('Directories', config('directories'), () => {
 	test('mkdir', config('async'), async () => {
 		await fs.promises.mkdir('/one', 0o755);
-		assert(await fs.promises.exists('/one'));
+		assert(await fs.promises.stat('/one', { throwIfNoEntry: false }));
 		await assert.rejects(fs.promises.mkdir('/one', 0o755), { code: 'EEXIST' });
 	});
 
@@ -30,7 +30,7 @@ suite('Directories', config('directories'), () => {
 
 	test('mkdir, nested', config('async'), async () => {
 		await assert.rejects(fs.promises.mkdir('/nested/dir'), { code: 'ENOENT', path: '/nested/dir' });
-		assert(!(await fs.promises.exists('/nested/dir')));
+		assert(!(await fs.promises.stat('/nested/dir', { throwIfNoEntry: false })));
 	});
 
 	test('mkdir, recursive', config('async'), async () => {

package/tests/fs/errors.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import test, { suite } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const existingFile = '/exit.js';
 const path = '/non-existent';

package/tests/fs/exists.test.ts

@@ -1,17 +1,17 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('exists', () => {
 	const f = 'x.txt';
 
-	test('return true for an existing file', config('async'), async () => {
+	test('return true for an existing file', config('async', 'promises.exists'), async () => {
 		const exists = await fs.promises.exists(f);
 		assert(exists);
 	});
 
-	test('return false for a non-existent file', config('async'), async () => {
+	test('return false for a non-existent file', config('async', 'promises.exists'), async () => {
 		const exists = await fs.promises.exists(f + '-NO');
 		assert(!exists);
 	});

package/tests/fs/links.test.ts

@@ -2,7 +2,7 @@
 import { join } from '@zenfs/core/path';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Links', config('symlinks'), () => {
 	const target = '/a1.js',
@@ -64,8 +64,8 @@ suite('Links', config('symlinks'), () => {
 
 	test('unlink', async () => {
 		await fs.promises.unlink(symlink);
-		assert(!(await fs.promises.exists(symlink)));
-		assert(await fs.promises.exists(target));
+		assert(!(await fs.promises.stat(symlink, { throwIfNoEntry: false })));
+		assert(await fs.promises.stat(target, { throwIfNoEntry: false }));
 	});
 
 	test('link', config('links'), async () => {
@@ -99,7 +99,7 @@ suite('Links', config('symlinks'), () => {
 		// A link pointing at a directory satisfies a recursive mkdir and is left as a link
 		assert.equal(await fs.promises.mkdir('/mkdir-link', { recursive: true }), undefined);
 		assert((await fs.promises.lstat('/mkdir-link')).isSymbolicLink());
-		assert(!(await fs.promises.exists('/mkdir-missing')));
+		assert(!(await fs.promises.stat('/mkdir-missing', { throwIfNoEntry: false })));
 	});
 
 	test('mkdir follows symlinks for intermediate components', config('async'), async () => {
@@ -113,7 +113,7 @@ suite('Links', config('symlinks'), () => {
 
 		// Node reports the link itself here, unlike `mkdirSync` which reports the requested path with ENOENT
 		await assert.rejects(fs.promises.mkdir('/mkdir-dangling/x', { recursive: true }), { code: 'ENOTDIR', path: '/mkdir-dangling' });
-		assert(!(await fs.promises.exists('/mkdir-missing')));
+		assert(!(await fs.promises.stat('/mkdir-missing', { throwIfNoEntry: false })));
 	});
 
 	test('mkdirSync does not follow a symlink at the final component', config('sync'), () => {

package/tests/fs/open.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Opening files', () => {
 	const filename = 'a.js';
@@ -12,12 +12,12 @@ suite('Opening files', () => {
 	});
 
 	test('open file with mode "r"', config('async'), async () => {
-		const { fd } = await fs.promises.open(filename, 'r');
-		assert(fd >= -Infinity);
+		await using handle = await fs.promises.open(filename, 'r');
+		assert(handle.fd >= -Infinity);
 	});
 
 	test('open file with mode "rs"', config('async'), async () => {
-		const { fd } = await fs.promises.open(filename, 'rs');
-		assert(fd >= -Infinity);
+		await using handle = await fs.promises.open(filename, 'rs');
+		assert(handle.fd >= -Infinity);
 	});
 });

package/tests/fs/permissions.test.ts

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { R_OK, W_OK, X_OK } from '@zenfs/core/constants';
-import { defaultContext } from '@zenfs/core/internal/contexts.js';
-import { hasAccess } from '@zenfs/core/internal/inode.js';
+import { defaultContext } from '@zenfs/core/internal/contexts';
+import { hasAccess } from '@zenfs/core/internal/inode';
 import { join } from '@zenfs/core/path';
 import type { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { encodeUTF8 } from 'utilium';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const asyncMode = 0o777;
 const syncMode = 0o644;
@@ -25,7 +25,7 @@ suite('Permissions', config('permissions'), () => {
 	});
 
 	test('fchmod', config('sync', 'async'), async () => {
-		const handle = await fs.promises.open(file, 'a', 0o644);
+		await using handle = await fs.promises.open(file, 'a', 0o644);
 
 		await handle.chmod(asyncMode);
 		const stats = await handle.stat();
@@ -58,7 +58,7 @@ suite('Permissions', config('permissions'), () => {
 
 		function checkError(access: number) {
 			return function (error: Exception) {
-				assert(error instanceof Error);
+				assert(Error.isError(error));
 				assert(!hasAccess(defaultContext, stats!, access));
 			};
 		}

package/tests/fs/read.test.ts

@@ -5,7 +5,7 @@ import assert from 'node:assert/strict';
 import type { OpenMode, PathLike } from 'node:fs';
 import { suite, test } from 'node:test';
 import { promisify } from 'node:util';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const filepath = 'x.txt';
 const expected = 'xyz\n';
@@ -13,7 +13,7 @@ const ellipses = '…'.repeat(10_000);
 
 suite('read', () => {
 	test('read file asynchronously', config('async'), async () => {
-		const handle = await fs.promises.open(filepath, 'r');
+		await using handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead, buffer } = await handle.read(Buffer.alloc(expected.length), 0, expected.length, 0);
 		assert.equal(bytesRead, expected.length);
 		assert.equal(buffer.toString(), expected);
@@ -46,7 +46,7 @@ suite('read', () => {
 	const bufferSync = Buffer.alloc(expected.length);
 
 	test('read file from handle asynchronously', config('async'), async () => {
-		const handle = await fs.promises.open(filepath, 'r');
+		await using handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead } = await handle.read(bufferAsync, 0, expected.length, 0);
 
 		assert.equal(bytesRead, expected.length);

package/tests/fs/readFile.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Reading', () => {
 	test('Cannot read a file with an invalid encoding', config('sync'), () => {
@@ -9,7 +9,7 @@ suite('Reading', () => {
 	});
 
 	test('Reading past the end of a file should not be an error', config('async'), async () => {
-		const handle = await fs.promises.open('a.js', 'r');
+		await using handle = await fs.promises.open('a.js', 'r');
 		const { bytesRead } = await handle.read(new Uint8Array(10), 0, 10, 10000);
 		assert.equal(bytesRead, 0);
 	});

package/tests/fs/rename.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Rename', config('rename'), () => {
 	/**
@@ -26,8 +26,8 @@ suite('Rename', config('rename'), () => {
 		const subContents = await fs.promises.readdir(dir + '/_rename_me');
 		assert.equal(subContents.length, 1);
 
-		assert(await fs.promises.exists(dir + '/file.dat'));
-		assert(await fs.promises.exists(dir + '/_rename_me/lol.txt'));
+		assert(await fs.promises.stat(dir + '/file.dat', { throwIfNoEntry: false }));
+		assert(await fs.promises.stat(dir + '/_rename_me/lol.txt', { throwIfNoEntry: false }));
 	}
 
 	test('rename directory', config('async'), async () => {
@@ -46,7 +46,7 @@ suite('Rename', config('rename'), () => {
 
 		await check_directory(newDir);
 
-		assert(!(await fs.promises.exists(oldDir)));
+		assert(!(await fs.promises.stat(oldDir, { throwIfNoEntry: false })));
 
 		await fs.promises.mkdir(oldDir);
 		await populate(oldDir);
@@ -67,7 +67,7 @@ suite('Rename', config('rename'), () => {
 		await fs.promises.rename(one, two);
 
 		assert.equal(await fs.promises.readFile(two, 'utf8'), 'hey');
-		assert(!(await fs.promises.exists(one)));
+		assert(!(await fs.promises.stat(one, { throwIfNoEntry: false })));
 	});
 
 	test('File to Directory and Directory to File Rename', config('sync', 'async'), async () => {

package/tests/fs/scaling.test.ts

@@ -2,7 +2,7 @@
 import { sync } from '@zenfs/core';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const n_files = 130;
 const huge_size = 0x1000000;

package/tests/fs/stat.test.ts

@@ -2,7 +2,7 @@
 import { defaultContext, hasAccess, type Stats } from '@zenfs/core';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Stats', () => {
 	const existing_file = 'x.txt';
@@ -35,7 +35,7 @@ suite('Stats', () => {
 		fs.close(fd);
 	});
 
-	test('hasAccess for non-root access', config('sync', 'permissions'), () => {
+	test('hasAccess for non-root access', config('sync', 'permissions', 'root'), () => {
 		const newFile = 'new.txt';
 
 		fs.writeFileSync(newFile, 'hello', { mode: 0o640 });

package/tests/fs/streams.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 // Top-level initialization
 const testFilePath = 'test-file.txt';

package/tests/fs/tempdir.test.ts

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { test, suite } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 import assert from 'node:assert/strict';
 import { basename } from 'node:path/posix';
 

package/tests/fs/times.test.ts

@@ -4,7 +4,7 @@ import type { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { wait } from 'utilium';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const path = 'x.txt';
 
@@ -33,7 +33,7 @@ suite('Times', config('times'), () => {
 		assert.deepEqual(unixTimestamps(await fs.promises.stat(path)), times);
 
 		await fs.promises.utimes('foobarbaz', atime, mtime).catch((error: Exception) => {
-			assert(error instanceof Error);
+			assert(Error.isError(error));
 			assert.equal(error.code, 'ENOENT');
 		});
 

package/tests/fs/truncate.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const path: string = 'truncate-file.txt',
 	size = 1024 * 16,

package/tests/fs/watch.test.ts

@@ -2,7 +2,7 @@
 import type { Stats } from '@zenfs/core';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const testDir = '/test-watch-dir';
 const testFile = testDir + '/test.txt';

package/tests/fs/write.test.ts

@@ -3,8 +3,8 @@ import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path/posix';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
-import { data as dataPath } from '../setup.js';
+import { config, fs } from '../common.ts';
+import { data as dataPath } from '../setup.ts';
 
 const fileName = 'write.txt';
 const utf8example = readFileSync(join(dataPath, 'utf8.txt'), 'utf8');

package/tests/fs/xattr.test.ts

@@ -2,7 +2,7 @@
 import { Buffer } from 'buffer';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Extended Attributes', config('xattr'), () => {
 	const testFile = 'xattr-test.txt';

package/tests/{native/setup.ts → native-setup.ts}

@@ -2,11 +2,12 @@
 /* Run the FS test suite against native node:fs.
 Since the tests use absolute paths, everything is contained to a scratch directory using chroot-style path mapping. */
 import * as native from 'node:fs';
-import type { TestFlag, TestFlagState } from '../common.js';
+import type { TestFlag, TestFlagState } from './common.ts';
 import { isAbsolute, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { copySync, data, tmp } from '../setup.js';
+import { copySync, data, tmp } from './setup.ts';
 import { styleText } from 'node:util';
+import { isRoot } from 'utilium/node';
 
 // The tests assume modes are used as-is, but native fs applies the process umask
 process.umask(0);
@@ -205,9 +206,6 @@ for (const [key, value] of Object.entries(native.promises)) {
 promises.watch = (...args: Parameters<typeof native.promises.watch>) =>
 	native.promises.watch(...(mapArgs('watch', args) as Parameters<typeof native.promises.watch>));
 
-// ZenFS API extension
-promises.exists = (path: PathLike) => Promise.resolve(native.existsSync(toNative(path)));
-
 wrapped.promises = promises;
 
 export const fs = wrapped as unknown as typeof native;
@@ -220,6 +218,8 @@ export const flags: Partial<Record<TestFlag, TestFlagState>> = {
 	lchmod: process.platform == 'darwin',
 	// The suite uses ZenFS' own extended attribute API, which `node:fs` does not have
 	xattr: false,
+	'promises.exists': false,
+	root: isRoot || 'skip',
 };
 
 copySync(data, fs);

package/tests/setup/context.ts

@@ -1,5 +1,5 @@
 import { fs as _fs, bindContext } from '@zenfs/core';
-import { copySync, data } from '../setup.js';
+import { copySync, data } from '../setup.ts';
 
 _fs.mkdirSync('/new_root');
 

package/tests/setup/cow.ts

@@ -1,5 +1,5 @@
 import { configureSingle, CopyOnWrite, fs, InMemory, resolveMountConfig } from '@zenfs/core';
-import { copySync, data } from '../setup.js';
+import { copySync, data } from '../setup.ts';
 
 fs.umount('/');
 const readable = await resolveMountConfig({ backend: InMemory, label: 'ro' });

package/tests/setup/index.ts

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path/posix';
 import { configureSingle, CopyOnWrite, InMemory, InMemoryStore, mounts, Readonly, StoreFS } from '@zenfs/core';
 import { S_IFDIR } from '@zenfs/core/constants';
-import { copySync, data } from '../setup.js';
+import { copySync, data } from '../setup.ts';
 
 copySync(data);
 

package/tests/setup/memory.ts

@@ -1,3 +1,3 @@
-import { copySync, data } from '../setup.js';
+import { copySync, data } from '../setup.ts';
 
 copySync(data);

package/tests/setup/port.ts

@@ -1,7 +1,7 @@
 import { InMemory, Port, configureSingle, fs, resolveMountConfig, resolveRemoteMount, sync } from '@zenfs/core';
 import { after, afterEach } from 'node:test';
 import { MessageChannel } from 'node:worker_threads';
-import { copySync, data } from '../setup.js';
+import { copySync, data } from '../setup.ts';
 
 const { port1: localPort, port2: remotePort } = new MessageChannel();
 

package/tests/setup/single-buffer.ts

@@ -1,5 +1,5 @@
 import { SingleBuffer, configureSingle } from '@zenfs/core';
-import { copySync, data } from '../setup.js';
+import { copySync, data } from '../setup.ts';
 
 await configureSingle({
 	backend: SingleBuffer,

package/tests/setup.ts

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { fs as _fs } from '@zenfs/core';
+import type { NodeFS } from '@zenfs/core/node/types';
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join, relative } from 'node:path';
-import type { NodeFS } from '@zenfs/core/node/types.js';
 
 export const data = join(import.meta.dirname, 'data');
 

package/tests/tsconfig.json

@@ -7,7 +7,8 @@
 		"esModuleInterop": true,
 		"allowSyntheticDefaultImports": true,
 		"allowJs": true,
-		"rootDir": ".."
+		"rootDir": "..",
+		"allowImportingTsExtensions": true
 	},
 	"include": ["**/*.ts", "*.ts", "**/*.js", "../types/uint8array.d.ts"]
 }

package/tests/native/run.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-
-sudo npx zenfs-test -v tests/native/setup.ts