@zenfs/core 2.2.3 → 2.3.0

package/dist/vfs/sync.js

@@ -134,7 +134,7 @@ export function statSync(path, options) {
     }
     if (checkAccess && !hasAccess(this, stats, constants.R_OK))
         throw UV('EACCES', { syscall: 'stat', path });
-    return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new Stats(stats);
+    return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 statSync;
 export function lstatSync(path, options) {
@@ -143,14 +143,14 @@ export function lstatSync(path, options) {
     const stats = wrap(fs, 'statSync', path)(resolved);
     if (checkAccess && !hasAccess(this, stats, constants.R_OK))
         throw UV('EACCES', { syscall: 'lstat', path });
-    return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new Stats(stats);
+    return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 lstatSync;
 export function truncateSync(path, len = 0) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
         const file = __addDisposableResource(env_1, _openSync.call(this, path, { flag: 'r+' }), false);
-        len || (len = 0);
+        len ||= 0;
         if (len < 0)
             throw UV('EINVAL', 'truncate', path.toString());
         file.truncate(len);
@@ -180,7 +180,6 @@ export function unlinkSync(path) {
 }
 unlinkSync;
 function _openSync(path, opt) {
-    var _a;
     path = normalizePath(path);
     const mode = normalizeMode(opt.mode, 0o644), flag = flags.parse(opt.flag);
     path = opt.preserveSymlinks ? path : realpathSync.call(this, path);
@@ -209,7 +208,7 @@ function _openSync(path, opt) {
         if (checkAccess && !hasAccess(this, parentStats, constants.W_OK)) {
             throw UV('EACCES', 'open', path);
         }
-        const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : defaultContext.credentials;
+        const { euid: uid, egid: gid } = this?.credentials ?? defaultContext.credentials;
         const inode = fs.createFileSync(resolved, {
             mode,
             uid: parentStats.mode & constants.S_ISUID ? parentStats.uid : uid,
@@ -339,7 +338,7 @@ export function appendFileSync(filename, data, _options = {}) {
 appendFileSync;
 export function fstatSync(fd, options) {
     const stats = fromFD(this, fd).stat();
-    return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new Stats(stats);
+    return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 fstatSync;
 export function closeSync(fd) {
@@ -348,7 +347,7 @@ export function closeSync(fd) {
 }
 closeSync;
 export function ftruncateSync(fd, len = 0) {
-    len || (len = 0);
+    len ||= 0;
     if (len < 0) {
         throw new Exception(Errno.EINVAL);
     }
@@ -381,7 +380,7 @@ export function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
         position = typeof pos === 'number' ? pos : null;
     }
     const file = fromFD(this, fd);
-    position !== null && position !== void 0 ? position : (position = file.position);
+    position ??= file.position;
     const bytesWritten = file.write(buffer, offset, length, position);
     emitChange(this, 'change', file.path);
     return bytesWritten;
@@ -441,10 +440,9 @@ export function rmdirSync(path) {
 }
 rmdirSync;
 export function mkdirSync(path, options) {
-    var _a;
-    const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : defaultContext.credentials;
+    const { euid: uid, egid: gid } = this?.credentials ?? defaultContext.credentials;
     options = typeof options === 'object' ? options : { mode: options };
-    const mode = normalizeMode(options === null || options === void 0 ? void 0 : options.mode, 0o777);
+    const mode = normalizeMode(options?.mode, 0o777);
     path = realpathSync.call(this, path);
     const { fs, path: resolved } = resolveMount(path, this);
     const __create = (path, resolved, parent) => {
@@ -458,7 +456,7 @@ export function mkdirSync(path, options) {
         emitChange(this, 'rename', path);
         return inode;
     };
-    if (!(options === null || options === void 0 ? void 0 : options.recursive)) {
+    if (!options?.recursive) {
         __create(path, resolved, wrap(fs, 'statSync', dirname(path))(dirname(resolved)));
         return;
     }
@@ -495,16 +493,16 @@ export function readdirSync(path, options) {
         catch {
             continue;
         }
-        if (options === null || options === void 0 ? void 0 : options.withFileTypes) {
+        if (options?.withFileTypes) {
             values.push(new Dirent(entry, entryStat, options.encoding));
         }
-        else if ((options === null || options === void 0 ? void 0 : options.encoding) == 'buffer') {
+        else if (options?.encoding == 'buffer') {
             values.push(Buffer.from(entry));
         }
         else {
             values.push(entry);
         }
-        if (!isDirectory(entryStat) || !(options === null || options === void 0 ? void 0 : options.recursive))
+        if (!isDirectory(entryStat) || !options?.recursive)
             continue;
         for (const subEntry of readdirSync.call(this, join(path, entry), options)) {
             if (subEntry instanceof Dirent) {
@@ -576,12 +574,12 @@ export function readlinkSync(path, options) {
         const size = handle.inode.size;
         const data = Buffer.alloc(size);
         handle.read(data, 0, size, 0);
-        const encoding = typeof options == 'object' ? options === null || options === void 0 ? void 0 : options.encoding : options;
+        const encoding = typeof options == 'object' ? options?.encoding : options;
         if (encoding == 'buffer') {
             return data;
         }
         // always defaults to utf-8 to avoid wrangler (cloudflare) worker "unknown encoding" exception
-        return data.toString(encoding !== null && encoding !== void 0 ? encoding : 'utf-8');
+        return data.toString(encoding ?? 'utf-8');
     }
     catch (e_6) {
         env_6.error = e_6;
@@ -680,8 +678,7 @@ function _resolveSync($, path, preserveSymlinks) {
     return _resolveSync($, target);
 }
 export function realpathSync(path, options) {
-    var _a;
-    const encoding = typeof options == 'string' ? options : ((_a = options === null || options === void 0 ? void 0 : options.encoding) !== null && _a !== void 0 ? _a : 'utf8');
+    const encoding = typeof options == 'string' ? options : (options?.encoding ?? 'utf8');
     path = normalizePath(path);
     const { fullPath } = _resolveSync(this, path);
     if (encoding == 'utf8' || encoding == 'utf-8')
@@ -711,14 +708,14 @@ export function rmSync(path, options) {
         stats = lstatSync.bind(this)(path);
     }
     catch (error) {
-        if (error.code != 'ENOENT' || !(options === null || options === void 0 ? void 0 : options.force))
+        if (error.code != 'ENOENT' || !options?.force)
             throw error;
     }
     if (!stats)
         return;
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
-            if (options === null || options === void 0 ? void 0 : options.recursive) {
+            if (options?.recursive) {
                 for (const entry of readdirSync.call(this, path)) {
                     rmSync.call(this, join(path, entry), options);
                 }
@@ -739,7 +736,7 @@ export function rmSync(path, options) {
 }
 rmSync;
 export function mkdtempSync(prefix, options) {
-    const encoding = typeof options === 'object' ? options === null || options === void 0 ? void 0 : options.encoding : options || 'utf8';
+    const encoding = typeof options === 'object' ? options?.encoding : options || 'utf8';
     const fsName = `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const resolvedPath = '/tmp/' + fsName;
     mkdirSync.call(this, resolvedPath);
@@ -820,11 +817,11 @@ export function cpSync(source, destination, opts) {
     source = normalizePath(source);
     destination = normalizePath(destination);
     const srcStats = lstatSync.call(this, source); // Use lstat to follow symlinks if not dereferencing
-    if ((opts === null || opts === void 0 ? void 0 : opts.errorOnExist) && existsSync.call(this, destination))
+    if (opts?.errorOnExist && existsSync.call(this, destination))
         throw UV('EEXIST', 'cp', destination);
     switch (srcStats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
-            if (!(opts === null || opts === void 0 ? void 0 : opts.recursive))
+            if (!opts?.recursive)
                 throw UV('EISDIR', 'cp', source);
             mkdirSync.call(this, destination, { recursive: true }); // Ensure the destination directory exists
             for (const dirent of readdirSync.call(this, source, { withFileTypes: true })) {
@@ -846,7 +843,7 @@ export function cpSync(source, destination, opts) {
             throw UV('ENOSYS', 'cp', source);
     }
     // Optionally preserve timestamps
-    if (opts === null || opts === void 0 ? void 0 : opts.preserveTimestamps) {
+    if (opts?.preserveTimestamps) {
         utimesSync.call(this, destination, srcStats.atime, srcStats.mtime);
     }
 }
@@ -854,7 +851,7 @@ cpSync;
 export function statfsSync(path, options) {
     path = normalizePath(path);
     const { fs } = resolveMount(path, this);
-    return _statfs(fs, options === null || options === void 0 ? void 0 : options.bigint);
+    return _statfs(fs, options?.bigint);
 }
 export function globSync(pattern, options = {}) {
     pattern = Array.isArray(pattern) ? pattern : [pattern];

package/dist/vfs/watchers.js

@@ -11,6 +11,8 @@ import { statSync } from './sync.js';
  * @template TEvents The type of events emitted by the watcher.
  */
 class Watcher extends EventEmitter {
+    _context;
+    path;
     /* eslint-disable @typescript-eslint/no-explicit-any */
     off(event, fn, context, once) {
         return super.off(event, fn, context, once);
@@ -56,10 +58,12 @@ class Watcher extends EventEmitter {
  * @template T The type of the filename, either `string` or `Buffer`.
  */
 export class FSWatcher extends Watcher {
+    options;
+    realpath;
     constructor(context, path, options) {
         super(context, path);
         this.options = options;
-        this.realpath = (context === null || context === void 0 ? void 0 : context.root) ? join(context.root, path) : path;
+        this.realpath = context?.root ? join(context.root, path) : path;
         addWatcher(this.realpath, this);
     }
     close() {
@@ -76,6 +80,9 @@ export class FSWatcher extends Watcher {
  * Instances of `StatWatcher` are used by `fs.watchFile()` to monitor changes to a file's statistics.
  */
 export class StatWatcher extends Watcher {
+    options;
+    intervalId;
+    previous;
     constructor(context, path, options) {
         super(context, path);
         this.options = options;
@@ -139,9 +146,8 @@ export function removeWatcher(path, watcher) {
  * @internal @hidden
  */
 export function emitChange($, eventType, filename) {
-    var _a;
     if ($)
-        filename = join((_a = $.root) !== null && _a !== void 0 ? _a : '/', filename);
+        filename = join($.root ?? '/', filename);
     filename = normalizePath(filename);
     // Notify watchers, including ones on parent directories if they are watching recursively
     for (let path = filename; path != '/'; path = dirname(path)) {

package/dist/vfs/xattr.js

@@ -16,14 +16,13 @@ function checkName($, name, 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');
     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());
+    inode.attributes ??= new Attributes();
     const value = inode.attributes.get(name);
     if (!value)
         throw UV('ENODATA', 'xattr.get', path);
@@ -31,7 +30,6 @@ export async function get(path, name, opt = {}) {
     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);
@@ -44,7 +42,7 @@ export function getSync(path, name, opt = {}) {
     }
     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());
+    inode.attributes ??= new Attributes();
     const value = inode.attributes.get(name);
     if (!value)
         throw UV('ENODATA', 'xattr.get', path);
@@ -60,14 +58,13 @@ export function getSync(path, name, opt = {}) {
  * @param opt Options for the operation
  */
 export async function set(path, name, value, opt = {}) {
-    var _a;
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     checkName(this, name, path, 'xattr.set');
     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());
+    inode.attributes ??= new Attributes();
     const attr = inode.attributes.get(name);
     if (opt.create && attr)
         throw UV('EEXIST', 'xattr.set', path);
@@ -85,7 +82,6 @@ export async function set(path, name, value, opt = {}) {
  * @param opt Options for the operation
  */
 export function setSync(path, name, value, opt = {}) {
-    var _a;
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     checkName(this, name, path, 'xattr.set');
@@ -98,7 +94,7 @@ export function setSync(path, name, value, opt = {}) {
     }
     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());
+    inode.attributes ??= new Attributes();
     const attr = inode.attributes.get(name);
     if (opt.create && attr)
         throw UV('EEXIST', 'xattr.set', path);
@@ -119,14 +115,13 @@ export function setSync(path, name, value, opt = {}) {
  * @param name Name of the attribute to remove
  */
 export async function remove(path, name) {
-    var _a;
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     checkName(this, name, path, 'xattr.remove');
     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());
+    inode.attributes ??= new Attributes();
     const attr = inode.attributes.get(name);
     if (!attr)
         throw UV('ENODATA', 'xattr.remove', path);
@@ -140,7 +135,6 @@ export async function remove(path, name) {
  * @param name Name of the attribute to remove
  */
 export function removeSync(path, name) {
-    var _a;
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     checkName(this, name, path, 'xattr.remove');
@@ -153,7 +147,7 @@ export function removeSync(path, name) {
     }
     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());
+    inode.attributes ??= new Attributes();
     const attr = inode.attributes.get(name);
     if (!attr)
         throw UV('ENODATA', 'xattr.remove', path);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.2.3",
+	"version": "2.3.0",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/scripts/test.js

@@ -89,11 +89,12 @@ if (options.ci) ci = await import('./ci.js');
 options.verbose && options.force && console.debug('Forcing tests to exit (--test-force-exit)');
 
 if (options.build) {
-	!options.quiet && console.log('Building...');
+	!options.quiet && process.stdout.write('Building... ');
 	try {
 		execSync('npm run build');
+		console.log('done.');
 	} catch {
-		console.warn('Build failed, continuing without it.');
+		console.warn('failed, continuing without it.');
 	}
 }
 
@@ -141,17 +142,19 @@ async function status(name) {
 		return color(`(${delta} ${unit})`, '2;37');
 	};
 
+	const maybeName = options.verbose ? `: ${name}` : '';
+
 	return {
 		async pass() {
-			if (!options.quiet) console.log(`${color('passed', 32)}: ${name} ${time()}`);
+			if (!options.quiet) console.log(`${color('passed', 32)}${maybeName} ${time()}`);
 			if (options.ci) await ci.completeCheck(name, 'success');
 		},
 		async skip() {
-			if (!options.quiet) console.log(`${color('skipped', 33)}: ${name} ${time()}`);
+			if (!options.quiet) console.log(`${color('skipped', 33)}${maybeName} ${time()}`);
 			if (options.ci) await ci.completeCheck(name, 'skipped');
 		},
 		async fail() {
-			console.error(`${color('failed', '1;31')}: ${name} ${time()}`);
+			console.error(`${color('failed', '1;31')}${maybeName} ${time()}`);
 			if (options.ci) await ci.completeCheck(name, 'failure');
 			process.exitCode = 1;
 			if (options['exit-on-fail']) process.exit();
@@ -163,7 +166,7 @@ if (!options.preserve) rmSync(options.coverage, { force: true, recursive: true }
 mkdirSync(options.coverage, { recursive: true });
 
 if (options.common) {
-	!options.quiet && console.log('Running common tests...');
+	!options.quiet && process.stdout.write('Running common tests...' + (options.verbose ? '\n' : ' '));
 	const { pass, fail } = await status('Common tests');
 	try {
 		execSync(
@@ -187,10 +190,14 @@ for (const setupFile of positionals) {
 	}
 
 	process.env.SETUP = setupFile;
+	process.env.VERBOSE = +options.verbose;
 
 	const name = options['file-names'] && !options.ci ? setupFile : parse(setupFile).name;
 
-	!options.quiet && console.log('Running tests:', name);
+	if (!options.quiet) {
+		if (options.verbose) console.log('Running tests:', name);
+		else process.stdout.write(`Running tests: ${name}... `);
+	}
 
 	const { pass, fail, skip } = await status(name);
 

package/tests/backend/fetch.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { join } from 'node:path';
-import { suite, test } from 'node:test';
+import { after, suite, test } from 'node:test';
 import { Worker } from 'node:worker_threads';
 import { Fetch, configureSingle, fs, mounts, type FetchFS } from '../../dist/index.js';
 import { baseUrl, defaultEntries, indexPath, whenServerReady } from '../fetch/config.js';
@@ -12,17 +12,15 @@ 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,
-		});
-	});
+await configureSingle({
+	backend: Fetch,
+	disableAsyncCache: true,
+	remoteWrite: true,
+	baseUrl,
+	index: baseUrl + indexPath,
+});
 
+suite('Fetch with `disableAsyncCache`', () => {
 	test('Read and write file', async () => {
 		await fs.promises.writeFile('/example', 'test');
 
@@ -45,9 +43,11 @@ await suite('Fetch with `disableAsyncCache`', () => {
 
 	test('Uncached synchronous operations throw', async () => {
 		assert.throws(() => fs.readFileSync('/x.txt', 'utf8'), { code: 'EAGAIN' });
-		await (mounts.get('/') as FetchFS)._asyncDone;
 	});
 });
 
-await server.terminate();
-server.unref();
+after(async () => {
+	await (mounts.get('/') as FetchFS)._asyncDone;
+	await server.terminate();
+	server.unref();
+});

package/tests/backend/port.test.ts

@@ -1,9 +1,9 @@
 import assert from 'node:assert/strict';
-import { suite, test } from 'node:test';
+import { after, suite, test } from 'node:test';
 import { MessageChannel, Worker } from 'node:worker_threads';
-import { Port, attachFS, waitOnline } from '../../dist/backends/port.js';
+import { Port, attachFS } from '../../dist/backends/port.js';
 import type { InMemoryStore, StoreFS } from '../../dist/index.js';
-import { InMemory, configure, configureSingle, fs, resolveMountConfig } from '../../dist/index.js';
+import { InMemory, configure, configureSingle, fs, resolveMountConfig, waitOnline } from '../../dist/index.js';
 import { setupLogs } from '../logs.js';
 setupLogs();
 
@@ -29,16 +29,18 @@ await suite('Timeout', { timeout: 1000 }, () => {
 
 		await assert.rejects(configured, { code: 'EIO', message: /RPC Failed/ });
 	});
-});
 
-timeoutChannel.port1.unref();
+	after(() => {
+		timeoutChannel.port1.unref();
+	});
+});
 
 // Test configuration
 
 const configPort = new Worker(import.meta.dirname + '/config.worker.js');
 await waitOnline(configPort);
 
-await suite('Remote FS with resolveRemoteMount', () => {
+suite('Remote FS with resolveRemoteMount', () => {
 	const content = 'FS is in a port';
 
 	test('Configuration', async () => {
@@ -52,10 +54,12 @@ await suite('Remote FS with resolveRemoteMount', () => {
 	test('Read', async () => {
 		assert.equal(await fs.promises.readFile('/test', 'utf8'), content);
 	});
-});
 
-await configPort.terminate();
-configPort.unref();
+	after(async () => {
+		await configPort.terminate();
+		configPort.unref();
+	});
+});
 
 // Test using a message channel
 
@@ -87,12 +91,14 @@ await suite('FS with MessageChannel', () => {
 	test('readFileSync should throw', () => {
 		assert.throws(() => fs.readFileSync('/test', 'utf8'), { code: 'ENOTSUP' });
 	});
-});
 
-channel.port1.close();
-channel.port2.close();
-channel.port1.unref();
-channel.port2.unref();
+	after(() => {
+		channel.port1.close();
+		channel.port2.close();
+		channel.port1.unref();
+		channel.port2.unref();
+	});
+});
 
 // Test using a worker
 
@@ -112,7 +118,9 @@ await suite('Remote FS', () => {
 	test('Read', async () => {
 		assert.equal(await fs.promises.readFile('/test', 'utf8'), content);
 	});
-});
 
-await remotePort.terminate();
-remotePort.unref();
+	after(async () => {
+		await remotePort.terminate();
+		remotePort.unref();
+	});
+});

package/tests/common/handle.test.ts

@@ -1,14 +1,14 @@
 import assert from 'node:assert/strict';
-import { suite, test } from 'node:test';
+import { after, suite, test } from 'node:test';
 import { wait } from 'utilium';
 import { constants, type FileHandle, open } from '../../dist/vfs/promises.js';
 
 const content = 'The cake is a lie',
 	appended = '\nAnother lie';
 
-await using handle: FileHandle = await open('./test.txt', 'ws+');
+const handle: FileHandle = await open('./test.txt', 'ws+');
 
-await suite('FileHandle', () => {
+suite('FileHandle', () => {
 	test('writeFile', async () => {
 		await handle.writeFile(content);
 		await handle.sync();
@@ -63,3 +63,5 @@ await suite('FileHandle', () => {
 		assert.deepEqual(lines, ['first line', 'second line', 'third line']);
 	});
 });
+
+after(() => handle.close());

package/tests/fetch/run.sh

@@ -6,7 +6,8 @@ SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 node $SCRIPT_DIR/server.js &
 PID=$!
 
-echo "Waiting for server to start..."
+echo -n "Waiting for server to start..."
+if [ -n "$VERBOSE" ]; then echo; fi
 until nc -z localhost 26514; do
   sleep 0.25
 done

package/tests/fs/scaling.test.ts

@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { fs } from '../common.js';
+
+const n_files = 130;
+const huge_size = 0x1000000;
+
+// Tests for having a lot of various things (number of inodes/files, individual file size, etc.).
+suite('Scaling', () => {
+	test('Lots of inodes/files', async () => {
+		fs.mkdirSync('/n');
+
+		for (let i = 0; i < n_files; i++) {
+			fs.writeFileSync('/n/' + i, i.toString(16));
+		}
+
+		assert.equal(fs.readdirSync('/n').length, n_files);
+
+		const results = [];
+
+		for (let i = 0; i < n_files; i++) {
+			results.push(fs.promises.readFile('/n/' + i, 'utf8').then(val => assert.equal(val, i.toString(16))));
+		}
+
+		await Promise.all(results);
+	});
+
+	test('Singular file size', () => {
+		fs.writeFileSync('/huge', new Uint8Array(huge_size));
+		assert.equal(fs.statSync('/huge').size, huge_size);
+	});
+});

package/tests/fs/watch.test.ts

@@ -9,9 +9,9 @@ await fs.promises.mkdir(testDir);
 await fs.promises.writeFile(testFile, 'Initial content');
 
 /**
- * @todo convert using watcher to void discards pending ES proposal
+ * @todo convert `using watcher = ...` to void discards pending ES proposal
  */
-await suite('Watch', () => {
+suite('Watch', async () => {
 	test('Events emitted on file change', async () => {
 		const { promise, resolve } = Promise.withResolvers<[string, string]>();
 
@@ -155,6 +155,3 @@ await suite('Watch', () => {
 		await promise;
 	});
 });
-
-await fs.promises.rm(testFile);
-await fs.promises.rm(testDir, { recursive: true, force: true });

package/tests/setup/single-buffer.ts

@@ -3,7 +3,7 @@ import { copySync, data } from '../setup.js';
 
 await configureSingle({
 	backend: SingleBuffer,
-	buffer: new ArrayBuffer(0x100000),
+	buffer: new ArrayBuffer(0x1100000),
 });
 
 copySync(data);

package/tests/tsconfig.json

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