@zenfs/core 1.2.8 → 1.2.9

package/dist/backends/store/fs.js

@@ -642,17 +642,17 @@ export class StoreFS extends FileSystem {
     async commitNew(path, type, mode, data) {
         const env_15 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_15, this.store.transaction(), true);
-            const parentPath = dirname(path), parent = await this.findINode(tx, parentPath);
-            const fname = basename(path), listing = await this.getDirListing(tx, parent, parentPath);
             /*
                 The root always exists.
                 If we don't check this prior to taking steps below,
-                we will create a file with name '' in root should path == '/'.
+                we will create a file with name '' in root if path is '/'.
             */
-            if (path === '/') {
+            if (path == '/') {
                 throw ErrnoError.With('EEXIST', path, 'commitNew');
             }
+            const tx = __addDisposableResource(env_15, this.store.transaction(), true);
+            const parentPath = dirname(path), parent = await this.findINode(tx, parentPath);
+            const fname = basename(path), listing = await this.getDirListing(tx, parent, parentPath);
             // Check if file already exists.
             if (listing[fname]) {
                 await tx.abort();
@@ -693,17 +693,17 @@ export class StoreFS extends FileSystem {
     commitNewSync(path, type, mode, data = new Uint8Array()) {
         const env_16 = { stack: [], error: void 0, hasError: false };
         try {
-            const tx = __addDisposableResource(env_16, this.store.transaction(), false);
-            const parentPath = dirname(path), parent = this.findINodeSync(tx, parentPath);
-            const fname = basename(path), listing = this.getDirListingSync(tx, parent, parentPath);
             /*
                 The root always exists.
                 If we don't check this prior to taking steps below,
-                we will create a file with name '' in root should p == '/'.
+                we will create a file with name '' in root if path is '/'.
             */
-            if (path === '/') {
+            if (path == '/') {
                 throw ErrnoError.With('EEXIST', path, 'commitNew');
             }
+            const tx = __addDisposableResource(env_16, this.store.transaction(), false);
+            const parentPath = dirname(path), parent = this.findINodeSync(tx, parentPath);
+            const fname = basename(path), listing = this.getDirListingSync(tx, parent, parentPath);
             // Check if file already exists.
             if (listing[fname]) {
                 throw ErrnoError.With('EEXIST', path, 'commitNew');

package/dist/config.js

@@ -1,9 +1,9 @@
 import { checkOptions, isBackend, isBackendConfig } from './backends/backend.js';
 import { credentials } from './credentials.js';
-import { DeviceFS, fullDevice, nullDevice, randomDevice, zeroDevice } from './devices.js';
+import { DeviceFS } from './devices.js';
 import * as cache from './emulation/cache.js';
-import * as fs from './emulation/index.js';
 import { config } from './emulation/config.js';
+import * as fs from './emulation/index.js';
 import { Errno, ErrnoError } from './error.js';
 import { FileSystem } from './filesystem.js';
 function isMountConfig(arg) {
@@ -60,6 +60,26 @@ export async function configureSingle(configuration) {
     fs.umount('/');
     fs.mount('/', resolved);
 }
+/**
+ * Like `fs.mount`, but it also creates missing directories.
+ * @privateRemarks
+ * This is implemented as a separate function to avoid a circular dependency between emulation/shared.ts and other emulation layer files.
+ * @internal
+ */
+async function mount(path, mount) {
+    if (path == '/') {
+        fs.mount(path, mount);
+        return;
+    }
+    const stats = await fs.promises.stat(path).catch(() => null);
+    if (!stats) {
+        await fs.promises.mkdir(path, { recursive: true });
+    }
+    else if (!stats.isDirectory()) {
+        throw ErrnoError.With('ENOTDIR', path, 'configure');
+    }
+    fs.mount(path, mount);
+}
 /**
  * Configures ZenFS with `configuration`
  * @see Configuration
@@ -74,16 +94,15 @@ export async function configure(configuration) {
     config.syncImmediately = !configuration.onlySyncOnClose;
     if (configuration.addDevices) {
         const devfs = new DeviceFS();
-        devfs.createDevice('/null', nullDevice);
-        devfs.createDevice('/zero', zeroDevice);
-        devfs.createDevice('/full', fullDevice);
-        devfs.createDevice('/random', randomDevice);
+        devfs.addDefaults();
         await devfs.ready();
-        fs.mount('/dev', devfs);
+        await mount('/dev', devfs);
     }
     if (!configuration.mounts) {
         return;
     }
+    const toMount = [];
+    let unmountRoot = false;
     for (const [point, mountConfig] of Object.entries(configuration.mounts)) {
         if (!point.startsWith('/')) {
             throw new ErrnoError(Errno.EINVAL, 'Mount points must have absolute paths');
@@ -91,7 +110,11 @@ export async function configure(configuration) {
         if (isBackendConfig(mountConfig)) {
             mountConfig.disableAsyncCache ?? (mountConfig.disableAsyncCache = configuration.disableAsyncCache || false);
         }
-        configuration.mounts[point] = await resolveMountConfig(mountConfig);
+        if (point == '/')
+            unmountRoot = true;
+        toMount.push([point, await resolveMountConfig(mountConfig)]);
     }
-    fs.mountObject(configuration.mounts);
+    if (unmountRoot)
+        fs.umount('/');
+    await Promise.all(toMount.map(([point, fs]) => mount(point, fs)));
 }

package/dist/credentials.d.ts

@@ -12,4 +12,7 @@ export interface Credentials {
     egid: number;
 }
 export declare const credentials: Credentials;
+/**
+ * @deprecated
+ */
 export declare const rootCredentials: Credentials;

package/dist/credentials.js

@@ -6,6 +6,9 @@ export const credentials = {
     euid: 0,
     egid: 0,
 };
+/**
+ * @deprecated
+ */
 export const rootCredentials = {
     uid: 0,
     gid: 0,

package/dist/devices.d.ts

@@ -124,6 +124,10 @@ export declare class DeviceFS extends StoreFS<InMemoryStore> {
      * Creates a new device at `path` relative to the `DeviceFS` root.
      */
     createDevice<TData = any>(path: string, driver: DeviceDriver<TData>): Device<TData | Record<string, never>>;
+    /**
+     * Adds default devices
+     */
+    addDefaults(): void;
     constructor();
     rename(oldPath: string, newPath: string): Promise<void>;
     renameSync(oldPath: string, newPath: string): void;

package/dist/devices.js

@@ -168,6 +168,15 @@ export class DeviceFS extends StoreFS {
         this.devices.set(path, dev);
         return dev;
     }
+    /**
+     * Adds default devices
+     */
+    addDefaults() {
+        this.createDevice('/null', nullDevice);
+        this.createDevice('/zero', zeroDevice);
+        this.createDevice('/full', fullDevice);
+        this.createDevice('/random', randomDevice);
+    }
     constructor() {
         super(new InMemoryStore('devfs'));
         this.devices = new Map();

package/dist/emulation/promises.js

@@ -53,11 +53,11 @@ import '../polyfills.js';
 import { BigIntStats } from '../stats.js';
 import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import * as cache from './cache.js';
+import { config } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
-import { config } from './config.js';
+import { _statfs, fd2file, fdMap, file2fd, fixError, resolveMount } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher, emitChange } from './watchers.js';
 export * as constants from './constants.js';
@@ -585,7 +585,7 @@ export async function rmdir(path) {
     try {
         const stats = await (cache.getStats(path) || fs.stat(resolved));
         if (!stats) {
-            throw ErrnoError.With('ENOENT', path, 'readdir');
+            throw ErrnoError.With('ENOENT', path, 'rmdir');
         }
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
@@ -655,16 +655,6 @@ export async function readdir(path, options) {
         throw ErrnoError.With('ENOTDIR', path, 'readdir');
     }
     const entries = await fs.readdir(resolved).catch(handleError);
-    for (const point of mounts.keys()) {
-        if (point.startsWith(path)) {
-            const entry = point.slice(path.length);
-            if (entry.includes('/') || entry.length == 0) {
-                // ignore FSs mounted in subdirectories and any FS mounted to `path`.
-                continue;
-            }
-            entries.push(entry);
-        }
-    }
     const values = [];
     const addEntry = async (entry) => {
         let entryStats;

package/dist/emulation/shared.d.ts

@@ -38,6 +38,9 @@ export declare function fixPaths(text: string, paths: Record<string, string>): s
  * @hidden
  */
 export declare function fixError<E extends ErrnoError>(e: E, paths: Record<string, string>): E;
+/**
+ * @deprecated
+ */
 export declare function mountObject(mounts: MountObject): void;
 /**
  * @hidden

package/dist/emulation/shared.js

@@ -90,6 +90,9 @@ export function fixError(e, paths) {
     e.message = fixPaths(e.message, paths);
     return e;
 }
+/**
+ * @deprecated
+ */
 export function mountObject(mounts) {
     if ('/' in mounts) {
         umount('/');

package/dist/emulation/sync.js

@@ -50,13 +50,13 @@ import { Errno, ErrnoError } from '../error.js';
 import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import { BigIntStats } from '../stats.js';
 import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import * as cache from './cache.js';
+import { config } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
-import { config } from './config.js';
+import { _statfs, fd2file, fdMap, file2fd, fixError, resolveMount } from './shared.js';
 import { emitChange } from './watchers.js';
-import * as cache from './cache.js';
 export function renameSync(oldPath, newPath) {
     oldPath = normalizePath(oldPath);
     newPath = normalizePath(newPath);
@@ -459,17 +459,6 @@ export function readdirSync(path, options) {
     catch (e) {
         throw fixError(e, { [resolved]: path });
     }
-    for (const mount of mounts.keys()) {
-        if (!mount.startsWith(path)) {
-            continue;
-        }
-        const entry = mount.slice(path.length);
-        if (entry.includes('/') || entry.length == 0) {
-            // ignore FSs mounted in subdirectories and any FS mounted to `path`.
-            continue;
-        }
-        entries.push(entry);
-    }
     // Iterate over entries and handle recursive case if needed
     const values = [];
     for (const entry of entries) {

package/dist/mixins/async.js

@@ -90,8 +90,8 @@ export function Async(FS) {
                 const sync = this._sync['store'].transaction();
                 const async = this['store'].transaction();
                 const promises = [];
-                for (const key of sync.keysSync()) {
-                    promises.push(async.set(key, sync.getSync(key)));
+                for (const key of await async.keys()) {
+                    promises.push(async.get(key).then(data => sync.setSync(key, data)));
                 }
                 await Promise.all(promises);
                 this._isInitialized = true;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.2.8",
+	"version": "1.2.9",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -58,6 +58,7 @@
 		"lint": "eslint src tests",
 		"test:common": "tsx --test --experimental-test-coverage 'tests/**/!(fs)/*.test.ts' 'tests/*.test.ts'",
 		"test": "tsx --test --experimental-test-coverage",
+		"pretest": "npm run build",
 		"build": "tsc -p tsconfig.json",
 		"build:docs": "typedoc",
 		"dev": "npm run build -- --watch",

package/src/backends/store/fs.ts

@@ -534,22 +534,22 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @param data The data to store at the file's data node.
 	 */
 	private async commitNew(path: string, type: FileType, mode: number, data: Uint8Array): Promise<Inode> {
-		await using tx = this.store.transaction();
-		const parentPath = dirname(path),
-			parent = await this.findINode(tx, parentPath);
-
-		const fname = basename(path),
-			listing = await this.getDirListing(tx, parent, parentPath);
-
 		/*
 			The root always exists.
 			If we don't check this prior to taking steps below,
-			we will create a file with name '' in root should path == '/'.
+			we will create a file with name '' in root if path is '/'.
 		*/
-		if (path === '/') {
+		if (path == '/') {
 			throw ErrnoError.With('EEXIST', path, 'commitNew');
 		}
 
+		await using tx = this.store.transaction();
+		const parentPath = dirname(path),
+			parent = await this.findINode(tx, parentPath);
+
+		const fname = basename(path),
+			listing = await this.getDirListing(tx, parent, parentPath);
+
 		// Check if file already exists.
 		if (listing[fname]) {
 			await tx.abort();
@@ -581,22 +581,22 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @return The Inode for the new file.
 	 */
 	protected commitNewSync(path: string, type: FileType, mode: number, data: Uint8Array = new Uint8Array()): Inode {
-		using tx = this.store.transaction();
-		const parentPath = dirname(path),
-			parent = this.findINodeSync(tx, parentPath);
-
-		const fname = basename(path),
-			listing = this.getDirListingSync(tx, parent, parentPath);
-
 		/*
 			The root always exists.
 			If we don't check this prior to taking steps below,
-			we will create a file with name '' in root should p == '/'.
+			we will create a file with name '' in root if path is '/'.
 		*/
-		if (path === '/') {
+		if (path == '/') {
 			throw ErrnoError.With('EEXIST', path, 'commitNew');
 		}
 
+		using tx = this.store.transaction();
+		const parentPath = dirname(path),
+			parent = this.findINodeSync(tx, parentPath);
+
+		const fname = basename(path),
+			listing = this.getDirListingSync(tx, parent, parentPath);
+
 		// Check if file already exists.
 		if (listing[fname]) {
 			throw ErrnoError.With('EEXIST', path, 'commitNew');

package/src/config.ts

@@ -1,12 +1,11 @@
 import type { Backend, BackendConfiguration, FilesystemOf, SharedConfig } from './backends/backend.js';
 import { checkOptions, isBackend, isBackendConfig } from './backends/backend.js';
 import { credentials } from './credentials.js';
-import { DeviceFS, fullDevice, nullDevice, randomDevice, zeroDevice } from './devices.js';
+import { DeviceFS } from './devices.js';
 import * as cache from './emulation/cache.js';
+import { config } from './emulation/config.js';
 import * as fs from './emulation/index.js';
 import type { AbsolutePath } from './emulation/path.js';
-import { type MountObject } from './emulation/shared.js';
-import { config } from './emulation/config.js';
 import { Errno, ErrnoError } from './error.js';
 import { FileSystem } from './filesystem.js';
 
@@ -151,6 +150,27 @@ export async function configureSingle<T extends Backend>(configuration: MountCon
 	fs.mount('/', resolved);
 }
 
+/**
+ * Like `fs.mount`, but it also creates missing directories.
+ * @privateRemarks
+ * This is implemented as a separate function to avoid a circular dependency between emulation/shared.ts and other emulation layer files.
+ * @internal
+ */
+async function mount(path: string, mount: FileSystem): Promise<void> {
+	if (path == '/') {
+		fs.mount(path, mount);
+		return;
+	}
+
+	const stats = await fs.promises.stat(path).catch(() => null);
+	if (!stats) {
+		await fs.promises.mkdir(path, { recursive: true });
+	} else if (!stats.isDirectory()) {
+		throw ErrnoError.With('ENOTDIR', path, 'configure');
+	}
+	fs.mount(path, mount);
+}
+
 /**
  * Configures ZenFS with `configuration`
  * @see Configuration
@@ -168,18 +188,18 @@ export async function configure<T extends ConfigMounts>(configuration: Partial<C
 
 	if (configuration.addDevices) {
 		const devfs = new DeviceFS();
-		devfs.createDevice('/null', nullDevice);
-		devfs.createDevice('/zero', zeroDevice);
-		devfs.createDevice('/full', fullDevice);
-		devfs.createDevice('/random', randomDevice);
+		devfs.addDefaults();
 		await devfs.ready();
-		fs.mount('/dev', devfs);
+		await mount('/dev', devfs);
 	}
 
 	if (!configuration.mounts) {
 		return;
 	}
 
+	const toMount: [string, FileSystem][] = [];
+	let unmountRoot = false;
+
 	for (const [point, mountConfig] of Object.entries(configuration.mounts)) {
 		if (!point.startsWith('/')) {
 			throw new ErrnoError(Errno.EINVAL, 'Mount points must have absolute paths');
@@ -189,8 +209,11 @@ export async function configure<T extends ConfigMounts>(configuration: Partial<C
 			mountConfig.disableAsyncCache ??= configuration.disableAsyncCache || false;
 		}
 
-		configuration.mounts[point as keyof T & `/${string}`] = await resolveMountConfig(mountConfig);
+		if (point == '/') unmountRoot = true;
+		toMount.push([point, await resolveMountConfig(mountConfig)]);
 	}
 
-	fs.mountObject(configuration.mounts as MountObject);
+	if (unmountRoot) fs.umount('/');
+
+	await Promise.all(toMount.map(([point, fs]) => mount(point, fs)));
 }

package/src/credentials.ts

@@ -21,6 +21,9 @@ export const credentials: Credentials = {
 	egid: 0,
 };
 
+/**
+ * @deprecated
+ */
 export const rootCredentials: Credentials = {
 	uid: 0,
 	gid: 0,

package/src/devices.ts

@@ -246,6 +246,16 @@ export class DeviceFS extends StoreFS<InMemoryStore> {
 		return dev;
 	}
 
+	/**
+	 * Adds default devices
+	 */
+	public addDefaults(): void {
+		this.createDevice('/null', nullDevice);
+		this.createDevice('/zero', zeroDevice);
+		this.createDevice('/full', fullDevice);
+		this.createDevice('/random', randomDevice);
+	}
+
 	public constructor() {
 		super(new InMemoryStore('devfs'));
 	}

package/src/emulation/promises.ts

@@ -13,11 +13,11 @@ import '../polyfills.js';
 import { BigIntStats, type Stats } from '../stats.js';
 import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import * as cache from './cache.js';
+import { config } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount, type InternalOptions, type ReaddirOptions } from './shared.js';
-import { config } from './config.js';
+import { _statfs, fd2file, fdMap, file2fd, fixError, resolveMount, type InternalOptions, type ReaddirOptions } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher, emitChange } from './watchers.js';
 export * as constants from './constants.js';
@@ -625,7 +625,7 @@ export async function rmdir(path: fs.PathLike): Promise<void> {
 	try {
 		const stats = await (cache.getStats(path) || fs.stat(resolved));
 		if (!stats) {
-			throw ErrnoError.With('ENOENT', path, 'readdir');
+			throw ErrnoError.With('ENOENT', path, 'rmdir');
 		}
 		if (!stats.isDirectory()) {
 			throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
@@ -736,17 +736,6 @@ export async function readdir(
 
 	const entries = await fs.readdir(resolved).catch(handleError);
 
-	for (const point of mounts.keys()) {
-		if (point.startsWith(path)) {
-			const entry = point.slice(path.length);
-			if (entry.includes('/') || entry.length == 0) {
-				// ignore FSs mounted in subdirectories and any FS mounted to `path`.
-				continue;
-			}
-			entries.push(entry);
-		}
-	}
-
 	const values: (string | Dirent | Buffer)[] = [];
 	const addEntry = async (entry: string) => {
 		let entryStats: Stats | undefined;

package/src/emulation/shared.ts

@@ -106,6 +106,9 @@ export function fixError<E extends ErrnoError>(e: E, paths: Record<string, strin
 	return e;
 }
 
+/**
+ * @deprecated
+ */
 export function mountObject(mounts: MountObject): void {
 	if ('/' in mounts) {
 		umount('/');

package/src/emulation/sync.ts

@@ -6,13 +6,13 @@ import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWrit
 import type { FileContents } from '../filesystem.js';
 import { BigIntStats, type Stats } from '../stats.js';
 import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import * as cache from './cache.js';
+import { config } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount, type InternalOptions, type ReaddirOptions } from './shared.js';
-import { config } from './config.js';
+import { _statfs, fd2file, fdMap, file2fd, fixError, resolveMount, type InternalOptions, type ReaddirOptions } from './shared.js';
 import { emitChange } from './watchers.js';
-import * as cache from './cache.js';
 
 export function renameSync(oldPath: fs.PathLike, newPath: fs.PathLike): void {
 	oldPath = normalizePath(oldPath);
@@ -472,18 +472,6 @@ export function readdirSync(
 		throw fixError(e as ErrnoError, { [resolved]: path });
 	}
 
-	for (const mount of mounts.keys()) {
-		if (!mount.startsWith(path)) {
-			continue;
-		}
-		const entry = mount.slice(path.length);
-		if (entry.includes('/') || entry.length == 0) {
-			// ignore FSs mounted in subdirectories and any FS mounted to `path`.
-			continue;
-		}
-		entries.push(entry);
-	}
-
 	// Iterate over entries and handle recursive case if needed
 	const values: (string | Dirent | Buffer)[] = [];
 	for (const entry of entries) {

package/src/mixins/async.ts

@@ -80,8 +80,8 @@ export function Async<T extends typeof FileSystem>(
 				const async = (this as StoreFS<Store>)['store'].transaction();
 
 				const promises = [];
-				for (const key of sync.keysSync()) {
-					promises.push(async.set(key, sync.getSync(key)));
+				for (const key of await async.keys()) {
+					promises.push(async.get(key).then(data => sync.setSync(key, data)));
 				}
 
 				await Promise.all(promises);

package/tests/fs/directory.test.ts

@@ -3,7 +3,22 @@ import { suite, test } from 'node:test';
 import { ErrnoError } from '../../dist/error.js';
 import { fs } from '../common.js';
 
-suite('Directory', () => {
+const testDir = 'test-dir';
+const testFiles = ['file1.txt', 'file2.txt', 'file3.txt'];
+const testDirectories = ['subdir1', 'subdir2'];
+
+await fs.promises.mkdir(testDir);
+for (const file of testFiles) {
+	await fs.promises.writeFile(`${testDir}/${file}`, 'Sample content');
+}
+for (const dir of testDirectories) {
+	await fs.promises.mkdir(`${testDir}/${dir}`);
+	for (const file of ['file4.txt', 'file5.txt']) {
+		await fs.promises.writeFile(`${testDir}/${dir}/${file}`, 'Sample content');
+	}
+}
+
+suite('Directories', () => {
 	test('mkdir', async () => {
 		await fs.promises.mkdir('/one', 0o755);
 		assert(await fs.promises.exists('/one'));
@@ -126,4 +141,71 @@ suite('Directory', () => {
 
 		fs.rmSync('/rmDirRecusrively', { recursive: true });
 	});
+
+	test('readdir returns files and directories', async () => {
+		const dirents = await fs.promises.readdir(testDir, { withFileTypes: true });
+		const files = dirents.filter(dirent => dirent.isFile()).map(dirent => dirent.name);
+		const dirs = dirents.filter(dirent => dirent.isDirectory()).map(dirent => dirent.name);
+
+		assert(testFiles.every(file => files.includes(file)));
+		assert(testDirectories.every(dir => dirs.includes(dir)));
+	});
+
+	test('readdirSync returns files and directories', () => {
+		const dirents = fs.readdirSync(testDir, { withFileTypes: true });
+		const files = dirents.filter(dirent => dirent.isFile()).map(dirent => dirent.name);
+		const dirs = dirents.filter(dirent => dirent.isDirectory()).map(dirent => dirent.name);
+
+		assert(testFiles.every(file => files.includes(file)));
+		assert(testDirectories.every(dir => dirs.includes(dir)));
+	});
+
+	test('readdir returns Dirent objects', async () => {
+		const dirents = await fs.promises.readdir(testDir, { withFileTypes: true });
+		assert(dirents[0] instanceof fs.Dirent);
+	});
+
+	test('readdirSync returns Dirent objects', () => {
+		const dirents = fs.readdirSync(testDir, { withFileTypes: true });
+		assert(dirents[0] instanceof fs.Dirent);
+	});
+
+	test('readdir works without withFileTypes option', async () => {
+		const files = await fs.promises.readdir(testDir);
+		assert(testFiles.every(entry => files.includes(entry)));
+		assert(testDirectories.every(entry => files.includes(entry)));
+	});
+
+	test('readdirSync works without withFileTypes option', () => {
+		const files = fs.readdirSync(testDir);
+		assert(testFiles.every(entry => files.includes(entry)));
+		assert(testDirectories.every(entry => files.includes(entry)));
+	});
+
+	test('readdir returns files recursively', async () => {
+		const entries = await fs.promises.readdir(testDir, { recursive: true });
+		assert(entries.includes('file1.txt'));
+		assert(entries.includes('subdir1/file4.txt'));
+		assert(entries.includes('subdir2/file5.txt'));
+	});
+
+	test('readdir returns Dirent recursively', async () => {
+		const entries = await fs.promises.readdir(testDir, { recursive: true, withFileTypes: true });
+		assert(entries.find(entry => entry.path === 'file1.txt'));
+		assert(entries.find(entry => entry.path === 'subdir1/file4.txt'));
+		assert(entries.find(entry => entry.path === 'subdir2/file5.txt'));
+	});
+
+	// New test for readdirSync with recursive: true
+	test('readdirSync returns files recursively', () => {
+		const entries = fs.readdirSync(testDir, { recursive: true });
+		assert(entries.includes('file1.txt'));
+		assert(entries.includes('subdir1/file4.txt'));
+		assert(entries.includes('subdir2/file5.txt'));
+	});
+
+	test('Cyrillic file names', () => {
+		fs.writeFileSync('/мой-файл.txt', 'HELLO!', 'utf-8');
+		assert(fs.readdirSync('/').includes('мой-файл.txt'));
+	});
 });

package/tests/fs/permissions.test.ts

@@ -1,12 +1,52 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
+import { credentials } from '../../dist/credentials.js';
 import { R_OK, W_OK, X_OK } from '../../dist/emulation/constants.js';
 import { join } from '../../dist/emulation/path.js';
 import { ErrnoError } from '../../dist/error.js';
 import { encodeUTF8 } from '../../dist/utils.js';
 import { fs } from '../common.js';
 
+const asyncMode = 0o777;
+const syncMode = 0o644;
+const file = 'a.js';
+
 suite('Permissions', () => {
+	test('chmod', async () => {
+		await fs.promises.chmod(file, asyncMode.toString(8));
+
+		const stats = await fs.promises.stat(file);
+		assert.equal(stats.mode & 0o777, asyncMode);
+
+		fs.chmodSync(file, syncMode);
+		assert.equal(fs.statSync(file).mode & 0o777, syncMode);
+	});
+
+	test('fchmod', async () => {
+		const handle = await fs.promises.open(file, 'a', 0o644);
+
+		await handle.chmod(asyncMode);
+		const stats = await handle.stat();
+
+		assert.equal(stats.mode & 0o777, asyncMode);
+
+		fs.fchmodSync(handle.fd, syncMode);
+		assert.equal(fs.statSync(file).mode & 0o777, syncMode);
+	});
+
+	test('lchmod', async () => {
+		const link = 'symbolic-link';
+
+		await fs.promises.symlink(file, link);
+		await fs.promises.lchmod(link, asyncMode);
+
+		const stats = await fs.promises.lstat(link);
+		assert.equal(stats.mode & 0o777, asyncMode);
+
+		fs.lchmodSync(link, syncMode);
+		assert.equal(fs.lstatSync(link).mode & 0o777, syncMode);
+	});
+
 	async function test_item(path: string): Promise<void> {
 		const stats = await fs.promises.stat(path).catch((error: ErrnoError) => {
 			assert(error instanceof ErrnoError);
@@ -27,7 +67,7 @@ suite('Permissions', () => {
 
 		if (stats.isDirectory()) {
 			for (const dir of await fs.promises.readdir(path)) {
-				await test_item(join(path, dir));
+				await test('Access controls: ' + join(path, dir), () => test_item(join(path, dir)));
 			}
 		} else {
 			await fs.promises.readFile(path).catch(checkError(R_OK));
@@ -48,5 +88,8 @@ suite('Permissions', () => {
 		assert(stats.hasAccess(R_OK));
 	}
 
-	test('recursive', () => test_item('/'));
+	const copy = { ...credentials };
+	Object.assign(credentials, { uid: 1000, gid: 1000, euid: 1000, egid: 1000 });
+	test('Access controls: /', () => test_item('/'));
+	Object.assign(credentials, copy);
 });

package/tests/mounts.test.ts

@@ -0,0 +1,18 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { configure } from '../src/config.js';
+import * as fs from '../src/emulation/index.js';
+import { InMemory } from '../src/index.js';
+
+suite('Mounts', () => {
+	test('Mount in nested directory', async () => {
+		await configure({
+			mounts: {
+				'/nested/dir': InMemory,
+			},
+		});
+
+		assert.deepStrictEqual(fs.readdirSync('/'), ['nested']);
+		assert.deepStrictEqual(fs.readdirSync('/nested'), ['dir']);
+	});
+});

package/tests/fs/chmod.test.ts

@@ -1,44 +0,0 @@
-import assert from 'node:assert';
-import { suite, test } from 'node:test';
-import { fs } from '../common.js';
-
-const asyncMode = 0o777;
-const syncMode = 0o644;
-const file = 'a.js';
-
-suite('chmod tests', () => {
-	test('chmod', async () => {
-		await fs.promises.chmod(file, asyncMode.toString(8));
-
-		const stats = await fs.promises.stat(file);
-		assert.equal(stats.mode & 0o777, asyncMode);
-
-		fs.chmodSync(file, syncMode);
-		assert.equal(fs.statSync(file).mode & 0o777, syncMode);
-	});
-
-	test('fchmod', async () => {
-		const handle = await fs.promises.open(file, 'a', 0o644);
-
-		await handle.chmod(asyncMode);
-		const stats = await handle.stat();
-
-		assert.equal(stats.mode & 0o777, asyncMode);
-
-		fs.fchmodSync(handle.fd, syncMode);
-		assert.equal(fs.statSync(file).mode & 0o777, syncMode);
-	});
-
-	test('lchmod', async () => {
-		const link = 'symbolic-link';
-
-		await fs.promises.symlink(file, link);
-		await fs.promises.lchmod(link, asyncMode);
-
-		const stats = await fs.promises.lstat(link);
-		assert.equal(stats.mode & 0o777, asyncMode);
-
-		fs.lchmodSync(link, syncMode);
-		assert.equal(fs.lstatSync(link).mode & 0o777, syncMode);
-	});
-});

package/tests/fs/readdir.test.ts

@@ -1,87 +0,0 @@
-import assert from 'node:assert';
-import { suite, test } from 'node:test';
-import { fs } from '../common.js';
-
-const testDir = 'test-dir';
-const testFiles = ['file1.txt', 'file2.txt', 'file3.txt'];
-const testDirectories = ['subdir1', 'subdir2'];
-
-await fs.promises.mkdir(testDir);
-for (const file of testFiles) {
-	await fs.promises.writeFile(`${testDir}/${file}`, 'Sample content');
-}
-for (const dir of testDirectories) {
-	await fs.promises.mkdir(`${testDir}/${dir}`);
-	for (const file of ['file4.txt', 'file5.txt']) {
-		await fs.promises.writeFile(`${testDir}/${dir}/${file}`, 'Sample content');
-	}
-}
-
-suite('readdir and readdirSync', () => {
-	test('readdir returns files and directories', async () => {
-		const dirents = await fs.promises.readdir(testDir, { withFileTypes: true });
-		const files = dirents.filter(dirent => dirent.isFile()).map(dirent => dirent.name);
-		const dirs = dirents.filter(dirent => dirent.isDirectory()).map(dirent => dirent.name);
-
-		assert(testFiles.every(file => files.includes(file)));
-		assert(testDirectories.every(dir => dirs.includes(dir)));
-	});
-
-	test('readdirSync returns files and directories', () => {
-		const dirents = fs.readdirSync(testDir, { withFileTypes: true });
-		const files = dirents.filter(dirent => dirent.isFile()).map(dirent => dirent.name);
-		const dirs = dirents.filter(dirent => dirent.isDirectory()).map(dirent => dirent.name);
-
-		assert(testFiles.every(file => files.includes(file)));
-		assert(testDirectories.every(dir => dirs.includes(dir)));
-	});
-
-	test('readdir returns Dirent objects', async () => {
-		const dirents = await fs.promises.readdir(testDir, { withFileTypes: true });
-		assert(dirents[0] instanceof fs.Dirent);
-	});
-
-	test('readdirSync returns Dirent objects', () => {
-		const dirents = fs.readdirSync(testDir, { withFileTypes: true });
-		assert(dirents[0] instanceof fs.Dirent);
-	});
-
-	test('readdir works without withFileTypes option', async () => {
-		const files = await fs.promises.readdir(testDir);
-		assert(testFiles.every(entry => files.includes(entry)));
-		assert(testDirectories.every(entry => files.includes(entry)));
-	});
-
-	test('readdirSync works without withFileTypes option', () => {
-		const files = fs.readdirSync(testDir);
-		assert(testFiles.every(entry => files.includes(entry)));
-		assert(testDirectories.every(entry => files.includes(entry)));
-	});
-
-	test('readdir returns files recursively', async () => {
-		const entries = await fs.promises.readdir(testDir, { recursive: true });
-		assert(entries.includes('file1.txt'));
-		assert(entries.includes('subdir1/file4.txt'));
-		assert(entries.includes('subdir2/file5.txt'));
-	});
-
-	test('readdir returns Dirent recursively', async () => {
-		const entries = await fs.promises.readdir(testDir, { recursive: true, withFileTypes: true });
-		assert(entries.find(entry => entry.path === 'file1.txt'));
-		assert(entries.find(entry => entry.path === 'subdir1/file4.txt'));
-		assert(entries.find(entry => entry.path === 'subdir2/file5.txt'));
-	});
-
-	// New test for readdirSync with recursive: true
-	test('readdirSync returns files recursively', () => {
-		const entries = fs.readdirSync(testDir, { recursive: true });
-		assert(entries.includes('file1.txt'));
-		assert(entries.includes('subdir1/file4.txt'));
-		assert(entries.includes('subdir2/file5.txt'));
-	});
-
-	test('Cyrillic file names', () => {
-		fs.writeFileSync('/мой-файл.txt', 'HELLO!', 'utf-8');
-		assert(fs.readdirSync('/').includes('мой-файл.txt'));
-	});
-});