@zenfs/core 0.11.0 → 0.11.2

package/src/backends/locked.ts

@@ -16,7 +16,7 @@ import type { Stats } from '../stats.js';
  * @internal
  */
 export class LockedFS<FS extends FileSystem> implements FileSystem {
-	private _mu: Mutex = new Mutex();
+	private mutex: Mutex = new Mutex();
 
 	constructor(public readonly fs: FS) {}
 
@@ -32,148 +32,148 @@ export class LockedFS<FS extends FileSystem> implements FileSystem {
 	}
 
 	public async rename(oldPath: string, newPath: string, cred: Cred): Promise<void> {
-		await this._mu.lock(oldPath);
+		await this.mutex.lock(oldPath);
 		await this.fs.rename(oldPath, newPath, cred);
-		this._mu.unlock(oldPath);
+		this.mutex.unlock(oldPath);
 	}
 
 	public renameSync(oldPath: string, newPath: string, cred: Cred): void {
-		if (this._mu.isLocked(oldPath)) {
+		if (this.mutex.isLocked(oldPath)) {
 			throw ErrnoError.With('EBUSY', oldPath, 'rename');
 		}
 		return this.fs.renameSync(oldPath, newPath, cred);
 	}
 
 	public async stat(path: string, cred: Cred): Promise<Stats> {
-		await this._mu.lock(path);
+		await this.mutex.lock(path);
 		const stats = await this.fs.stat(path, cred);
-		this._mu.unlock(path);
+		this.mutex.unlock(path);
 		return stats;
 	}
 
 	public statSync(path: string, cred: Cred): Stats {
-		if (this._mu.isLocked(path)) {
+		if (this.mutex.isLocked(path)) {
 			throw ErrnoError.With('EBUSY', path, 'stat');
 		}
 		return this.fs.statSync(path, cred);
 	}
 
 	public async openFile(path: string, flag: string, cred: Cred): Promise<File> {
-		await this._mu.lock(path);
+		await this.mutex.lock(path);
 		const fd = await this.fs.openFile(path, flag, cred);
-		this._mu.unlock(path);
+		this.mutex.unlock(path);
 		return fd;
 	}
 
 	public openFileSync(path: string, flag: string, cred: Cred): File {
-		if (this._mu.isLocked(path)) {
+		if (this.mutex.isLocked(path)) {
 			throw ErrnoError.With('EBUSY', path, 'openFile');
 		}
 		return this.fs.openFileSync(path, flag, cred);
 	}
 
 	public async createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File> {
-		await this._mu.lock(path);
+		await this.mutex.lock(path);
 		const fd = await this.fs.createFile(path, flag, mode, cred);
-		this._mu.unlock(path);
+		this.mutex.unlock(path);
 		return fd;
 	}
 
 	public createFileSync(path: string, flag: string, mode: number, cred: Cred): File {
-		if (this._mu.isLocked(path)) {
+		if (this.mutex.isLocked(path)) {
 			throw ErrnoError.With('EBUSY', path, 'createFile');
 		}
 		return this.fs.createFileSync(path, flag, mode, cred);
 	}
 
 	public async unlink(path: string, cred: Cred): Promise<void> {
-		await this._mu.lock(path);
+		await this.mutex.lock(path);
 		await this.fs.unlink(path, cred);
-		this._mu.unlock(path);
+		this.mutex.unlock(path);
 	}
 
 	public unlinkSync(path: string, cred: Cred): void {
-		if (this._mu.isLocked(path)) {
+		if (this.mutex.isLocked(path)) {
 			throw ErrnoError.With('EBUSY', path, 'unlink');
 		}
 		return this.fs.unlinkSync(path, cred);
 	}
 
 	public async rmdir(path: string, cred: Cred): Promise<void> {
-		await this._mu.lock(path);
+		await this.mutex.lock(path);
 		await this.fs.rmdir(path, cred);
-		this._mu.unlock(path);
+		this.mutex.unlock(path);
 	}
 
 	public rmdirSync(path: string, cred: Cred): void {
-		if (this._mu.isLocked(path)) {
+		if (this.mutex.isLocked(path)) {
 			throw ErrnoError.With('EBUSY', path, 'rmdir');
 		}
 		return this.fs.rmdirSync(path, cred);
 	}
 
 	public async mkdir(path: string, mode: number, cred: Cred): Promise<void> {
-		await this._mu.lock(path);
+		await this.mutex.lock(path);
 		await this.fs.mkdir(path, mode, cred);
-		this._mu.unlock(path);
+		this.mutex.unlock(path);
 	}
 
 	public mkdirSync(path: string, mode: number, cred: Cred): void {
-		if (this._mu.isLocked(path)) {
+		if (this.mutex.isLocked(path)) {
 			throw ErrnoError.With('EBUSY', path, 'mkdir');
 		}
 		return this.fs.mkdirSync(path, mode, cred);
 	}
 
 	public async readdir(path: string, cred: Cred): Promise<string[]> {
-		await this._mu.lock(path);
+		await this.mutex.lock(path);
 		const files = await this.fs.readdir(path, cred);
-		this._mu.unlock(path);
+		this.mutex.unlock(path);
 		return files;
 	}
 
 	public readdirSync(path: string, cred: Cred): string[] {
-		if (this._mu.isLocked(path)) {
+		if (this.mutex.isLocked(path)) {
 			throw ErrnoError.With('EBUSY', path, 'readdir');
 		}
 		return this.fs.readdirSync(path, cred);
 	}
 
 	public async exists(path: string, cred: Cred): Promise<boolean> {
-		await this._mu.lock(path);
+		await this.mutex.lock(path);
 		const exists = await this.fs.exists(path, cred);
-		this._mu.unlock(path);
+		this.mutex.unlock(path);
 		return exists;
 	}
 
 	public existsSync(path: string, cred: Cred): boolean {
-		if (this._mu.isLocked(path)) {
+		if (this.mutex.isLocked(path)) {
 			throw ErrnoError.With('EBUSY', path, 'exists');
 		}
 		return this.fs.existsSync(path, cred);
 	}
 
 	public async link(srcpath: string, dstpath: string, cred: Cred): Promise<void> {
-		await this._mu.lock(srcpath);
+		await this.mutex.lock(srcpath);
 		await this.fs.link(srcpath, dstpath, cred);
-		this._mu.unlock(srcpath);
+		this.mutex.unlock(srcpath);
 	}
 
 	public linkSync(srcpath: string, dstpath: string, cred: Cred): void {
-		if (this._mu.isLocked(srcpath)) {
+		if (this.mutex.isLocked(srcpath)) {
 			throw ErrnoError.With('EBUSY', srcpath, 'link');
 		}
 		return this.fs.linkSync(srcpath, dstpath, cred);
 	}
 
 	public async sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void> {
-		await this._mu.lock(path);
+		await this.mutex.lock(path);
 		await this.fs.sync(path, data, stats);
-		this._mu.unlock(path);
+		this.mutex.unlock(path);
 	}
 
 	public syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void {
-		if (this._mu.isLocked(path)) {
+		if (this.mutex.isLocked(path)) {
 			throw ErrnoError.With('EBUSY', path, 'sync');
 		}
 		return this.fs.syncSync(path, data, stats);

package/src/backends/memory.ts

@@ -41,4 +41,4 @@ export const InMemory = {
 	create({ name }: { name?: string }) {
 		return new StoreFS(new InMemoryStore(name));
 	},
-} as const satisfies Backend<StoreFS, { name?: string }>;
+} as const satisfies Backend<StoreFS<InMemoryStore>, { name?: string }>;

package/src/backends/port/fs.ts

@@ -63,7 +63,8 @@ export class PortFile extends File {
 	}
 
 	public async read<TBuffer extends NodeJS.ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<FileReadResult<TBuffer>> {
-		return (await this.rpc('read', buffer, offset, length, position)) as FileReadResult<TBuffer>;
+		const result = await this.rpc('read', buffer, offset, length, position);
+		return result as FileReadResult<TBuffer>;
 	}
 
 	public readSync(): number {

package/src/backends/port/rpc.ts

@@ -85,10 +85,11 @@ export function request<const TRequest extends Request, TValue>(
 		const id = Math.random().toString(16).slice(10);
 		executors.set(id, { resolve, reject, fs });
 		port.postMessage({ ...request, _zenfs: true, id, stack });
-		setTimeout(() => {
+		const _ = setTimeout(() => {
 			const error = new ErrnoError(Errno.EIO, 'RPC Failed');
 			error.stack += stack;
 			reject(error);
+			if (typeof _ == 'object') _.unref();
 		}, timeout);
 	});
 }

package/src/backends/store/fs.ts

@@ -12,22 +12,22 @@ import type { Store, Transaction } from './store.js';
 const maxInodeAllocTries = 5;
 
 /**
- * A synchronous key-value file system. Uses a SyncStore to store the data.
+ * A file system which uses a key-value store.
  *
  * We use a unique ID for each node in the file system. The root node has a fixed ID.
  * @todo Introduce Node ID caching.
  * @todo Check modes.
  * @internal
  */
-export class StoreFS extends FileSystem {
-	protected get store(): Store {
+export class StoreFS<T extends Store = Store> extends FileSystem {
+	protected get store(): T {
 		if (!this._store) {
 			throw new ErrnoError(Errno.ENODATA, 'No store attached');
 		}
 		return this._store;
 	}
 
-	protected _store?: Store;
+	protected _store?: T;
 
 	private _initialized: boolean = false;
 
@@ -40,7 +40,7 @@ export class StoreFS extends FileSystem {
 		this._store = await this.$store;
 	}
 
-	constructor(private $store: Store | Promise<Store>) {
+	constructor(private $store: T | Promise<T>) {
 		super();
 
 		if (!($store instanceof Promise)) {

package/src/config.ts

@@ -58,7 +58,7 @@ export async function resolveMountConfig<FS extends FileSystem, TOptions extends
 		throw new ErrnoError(Errno.EPERM, 'Backend not available: ' + backend);
 	}
 	checkOptions(backend, config);
-	const mount = backend.create(config);
+	const mount = await backend.create(config);
 	await mount.ready();
 	return mount;
 }

package/src/emulation/promises.ts

@@ -144,8 +144,7 @@ export class FileHandle implements promises.FileHandle {
 		}
 
 		const { size } = await this.stat();
-		const data = new Uint8Array(size);
-		await this.file.read(data, 0, size, 0);
+		const { buffer: data } = await this.file.read(new Uint8Array(size), 0, size, 0);
 		const buffer = Buffer.from(data);
 		return options.encoding ? buffer.toString(options.encoding) : buffer;
 	}

package/src/emulation/sync.ts

@@ -16,7 +16,7 @@ type FileSystemMethod = {
 		: never;
 }[keyof FileSystem]; // https://stackoverflow.com/a/76335220/17637456
 
-function doOp<M extends FileSystemMethod, RT extends ReturnType<M>>(...[name, resolveSymlinks, path, ...args]: Parameters<M>): RT {
+function wrap<M extends FileSystemMethod, RT extends ReturnType<M>>(...[name, resolveSymlinks, path, ...args]: Parameters<M>): RT {
 	path = normalizePath(path!);
 	const { fs, path: resolvedPath } = resolveMount(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
 	try {
@@ -78,7 +78,7 @@ existsSync satisfies typeof fs.existsSync;
 export function statSync(path: fs.PathLike, options?: { bigint?: boolean }): Stats;
 export function statSync(path: fs.PathLike, options: { bigint: true }): BigIntStats;
 export function statSync(path: fs.PathLike, options?: fs.StatOptions): Stats | BigIntStats {
-	const stats: Stats = doOp('statSync', true, path.toString(), cred);
+	const stats: Stats = wrap('statSync', true, path.toString(), cred);
 	return options?.bigint ? new BigIntStats(stats) : stats;
 }
 statSync satisfies typeof fs.statSync;
@@ -92,7 +92,7 @@ statSync satisfies typeof fs.statSync;
 export function lstatSync(path: fs.PathLike, options?: { bigint?: boolean }): Stats;
 export function lstatSync(path: fs.PathLike, options: { bigint: true }): BigIntStats;
 export function lstatSync(path: fs.PathLike, options?: fs.StatOptions): Stats | BigIntStats {
-	const stats: Stats = doOp('statSync', false, path.toString(), cred);
+	const stats: Stats = wrap('statSync', false, path.toString(), cred);
 	return options?.bigint ? new BigIntStats(stats) : stats;
 }
 lstatSync satisfies typeof fs.lstatSync;
@@ -117,7 +117,7 @@ truncateSync satisfies typeof fs.truncateSync;
  * @param path
  */
 export function unlinkSync(path: fs.PathLike): void {
-	return doOp('unlinkSync', false, path.toString(), cred);
+	return wrap('unlinkSync', false, path.toString(), cred);
 }
 unlinkSync satisfies typeof fs.unlinkSync;
 
@@ -128,17 +128,17 @@ function _openSync(_path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | nul
 	// Check if the path exists, and is a file.
 	let stats: Stats;
 	try {
-		stats = doOp('statSync', resolveSymlinks, path, cred);
+		stats = wrap('statSync', resolveSymlinks, path, cred);
 	} catch (e) {
 		// File does not exist.
 		switch (pathNotExistsAction(flag)) {
 			case ActionType.CREATE:
 				// Ensure parent exists.
-				const parentStats: Stats = doOp('statSync', resolveSymlinks, dirname(path), cred);
+				const parentStats: Stats = wrap('statSync', resolveSymlinks, dirname(path), cred);
 				if (!parentStats.isDirectory()) {
 					throw ErrnoError.With('ENOTDIR', dirname(path), '_open');
 				}
-				return doOp('createFileSync', resolveSymlinks, path, flag, mode, cred);
+				return wrap('createFileSync', resolveSymlinks, path, flag, mode, cred);
 			case ActionType.THROW:
 				throw ErrnoError.With('ENOENT', path, '_open');
 			default:
@@ -155,16 +155,16 @@ function _openSync(_path: fs.PathLike, _flag: fs.OpenMode, _mode?: fs.Mode | nul
 			throw ErrnoError.With('EEXIST', path, '_open');
 		case ActionType.TRUNCATE:
 			// Delete file.
-			doOp('unlinkSync', resolveSymlinks, path, cred);
+			wrap('unlinkSync', resolveSymlinks, path, cred);
 			/*
 				Create file. Use the same mode as the old file.
 				Node itself modifies the ctime when this occurs, so this action
 				will preserve that behavior if the underlying file system
 				supports those properties.
 			*/
-			return doOp('createFileSync', resolveSymlinks, path, flag, stats.mode, cred);
+			return wrap('createFileSync', resolveSymlinks, path, flag, stats.mode, cred);
 		case ActionType.NOP:
-			return doOp('openFileSync', resolveSymlinks, path, flag, cred);
+			return wrap('openFileSync', resolveSymlinks, path, flag, cred);
 		default:
 			throw new ErrnoError(Errno.EINVAL, 'Invalid FileFlag object.');
 	}
@@ -230,21 +230,6 @@ export function readFileSync(path: fs.PathOrFileDescriptor, _options: fs.WriteFi
 }
 readFileSync satisfies typeof fs.readFileSync;
 
-/**
- * Synchronously writes data to a file, replacing the file
- * if it already exists.
- *
- * The encoding option is ignored if data is a buffer.
- */
-function _writeFileSync(fname: string, data: Uint8Array, flag: string, mode: number, resolveSymlinks: boolean): void {
-	const file = _openSync(fname, flag, mode, resolveSymlinks);
-	try {
-		file.writeSync(data, 0, data.byteLength, 0);
-	} finally {
-		file.closeSync();
-	}
-}
-
 /**
  * Synchronously writes data to a file, replacing the file if it already
  * exists.
@@ -272,22 +257,14 @@ export function writeFileSync(path: fs.PathOrFileDescriptor, data: FileContents,
 	if (!encodedData) {
 		throw new ErrnoError(Errno.EINVAL, 'Data not specified');
 	}
-	_writeFileSync(typeof path == 'number' ? fd2file(path).path! : path.toString(), encodedData, options.flag, options.mode, true);
-}
-writeFileSync satisfies typeof fs.writeFileSync;
-
-/**
- * Synchronously append data to a file, creating the file if
- * it not yet exists.
- */
-function _appendFileSync(fname: string, data: Uint8Array, flag: string, mode: number, resolveSymlinks: boolean): void {
-	const file = _openSync(fname, flag, mode, resolveSymlinks);
+	const file = _openSync(typeof path == 'number' ? fd2file(path).path! : path.toString(), flag, options.mode, true);
 	try {
-		file.writeSync(data, 0, data.byteLength, null);
+		file.writeSync(encodedData, 0, encodedData.byteLength, 0);
 	} finally {
 		file.closeSync();
 	}
 }
+writeFileSync satisfies typeof fs.writeFileSync;
 
 /**
  * Asynchronously append data to a file, creating the file if it not yet
@@ -310,7 +287,12 @@ export function appendFileSync(filename: fs.PathOrFileDescriptor, data: FileCont
 		throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
 	}
 	const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding!) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-	_appendFileSync(typeof filename == 'number' ? fd2file(filename).path! : filename.toString(), encodedData, options.flag, options.mode, true);
+	const file = _openSync(typeof filename == 'number' ? fd2file(filename).path! : filename.toString(), flag, options.mode, true);
+	try {
+		file.writeSync(encodedData, 0, encodedData.byteLength, null);
+	} finally {
+		file.closeSync();
+	}
 }
 appendFileSync satisfies typeof fs.appendFileSync;
 
@@ -481,7 +463,7 @@ futimesSync satisfies typeof fs.futimesSync;
  * @param path
  */
 export function rmdirSync(path: fs.PathLike): void {
-	return doOp('rmdirSync', true, path.toString(), cred);
+	return wrap('rmdirSync', true, path.toString(), cred);
 }
 rmdirSync satisfies typeof fs.rmdirSync;
 
@@ -497,7 +479,7 @@ export function mkdirSync(path: fs.PathLike, options?: fs.Mode | fs.MakeDirector
 export function mkdirSync(path: fs.PathLike, options?: fs.Mode | fs.MakeDirectoryOptions | null): string | undefined | void {
 	const mode: fs.Mode | undefined = typeof options == 'number' || typeof options == 'string' ? options : options?.mode;
 	const recursive = typeof options == 'object' && options?.recursive;
-	doOp('mkdirSync', true, path.toString(), normalizeMode(mode, 0o777), cred);
+	wrap('mkdirSync', true, path.toString(), normalizeMode(mode, 0o777), cred);
 }
 mkdirSync satisfies typeof fs.mkdirSync;
 
@@ -514,7 +496,7 @@ export function readdirSync(
 	options?: { recursive?: boolean; encoding?: BufferEncoding | 'buffer' | null; withFileTypes?: boolean } | BufferEncoding | 'buffer' | null
 ): string[] | Dirent[] | Buffer[] {
 	path = normalizePath(path);
-	const entries: string[] = doOp('readdirSync', true, path, cred);
+	const entries: string[] = wrap('readdirSync', true, path, cred);
 	for (const mount of mounts.keys()) {
 		if (!mount.startsWith(path)) {
 			continue;
@@ -549,7 +531,7 @@ readdirSync satisfies typeof fs.readdirSync;
  */
 export function linkSync(existing: fs.PathLike, newpath: fs.PathLike): void {
 	newpath = normalizePath(newpath);
-	return doOp('linkSync', false, existing.toString(), newpath.toString(), cred);
+	return wrap('linkSync', false, existing.toString(), newpath.toString(), cred);
 }
 linkSync satisfies typeof fs.linkSync;
 

package/src/filesystem.ts

@@ -197,7 +197,7 @@ export abstract class FileSystem {
 /**
  * @internal
  */
-declare abstract class SyncFileSystem extends FileSystem {
+declare abstract class SyncFS extends FileSystem {
 	metadata(): FileSystemMetadata;
 	ready(): Promise<void>;
 	exists(path: string, cred: Cred): Promise<boolean>;
@@ -217,8 +217,8 @@ declare abstract class SyncFileSystem extends FileSystem {
  * Implements the asynchronous API in terms of the synchronous API.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function Sync<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => SyncFileSystem) & T {
-	abstract class _SyncFileSystem extends FS implements SyncFileSystem {
+export function Sync<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => SyncFS) & T {
+	abstract class _SyncFS extends FS implements SyncFS {
 		public async exists(path: string, cred: Cred): Promise<boolean> {
 			return this.existsSync(path, cred);
 		}
@@ -263,13 +263,13 @@ export function Sync<T extends abstract new (...args: any[]) => FileSystem>(FS:
 			return this.syncSync(path, data, stats);
 		}
 	}
-	return _SyncFileSystem;
+	return _SyncFS;
 }
 
 /**
  * @internal
  */
-declare abstract class AsyncFileSystem extends FileSystem {
+declare abstract class AsyncFS extends FileSystem {
 	/**
 	 * @hidden
 	 */
@@ -312,8 +312,8 @@ type AsyncOperation = {
  *
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function Async<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => AsyncFileSystem) & T {
-	abstract class _AsyncFileSystem extends FS implements AsyncFileSystem {
+export function Async<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => AsyncFS) & T {
+	abstract class _AsyncFS extends FS implements AsyncFS {
 		/**
 		 * Queue of pending asynchronous operations.
 		 */
@@ -359,18 +359,19 @@ export function Async<T extends abstract new (...args: any[]) => FileSystem>(FS:
 		}
 
 		public createFileSync(path: string, flag: string, mode: number, cred: Cred): PreloadFile<this> {
-			const file = this._sync.createFileSync(path, flag, mode, cred);
+			this._sync.createFileSync(path, flag, mode, cred);
 			this.queue('createFile', path, flag, mode, cred);
+			return this.openFileSync(path, flag, cred);
+		}
+
+		public openFileSync(path: string, flag: string, cred: Cred): PreloadFile<this> {
+			const file = this._sync.openFileSync(path, flag, cred);
 			const stats = file.statSync();
 			const buffer = new Uint8Array(stats.size);
 			file.readSync(buffer);
 			return new PreloadFile(this, path, flag, stats, buffer);
 		}
 
-		public openFileSync(path: string, flag: string, cred: Cred): File {
-			return this._sync.openFileSync(path, flag, cred);
-		}
-
 		public unlinkSync(path: string, cred: Cred): void {
 			this._sync.unlinkSync(path, cred);
 			this.queue('unlink', path, cred);
@@ -455,13 +456,13 @@ export function Async<T extends abstract new (...args: any[]) => FileSystem>(FS:
 		}
 	}
 
-	return _AsyncFileSystem;
+	return _AsyncFS;
 }
 
 /**
  * @internal
  */
-declare abstract class ReadonlyFileSystem extends FileSystem {
+declare abstract class ReadonlyFS extends FileSystem {
 	metadata(): FileSystemMetadata;
 	rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
 	renameSync(oldPath: string, newPath: string, cred: Cred): void;
@@ -483,8 +484,8 @@ declare abstract class ReadonlyFileSystem extends FileSystem {
  * Implements the non-readonly methods to throw `EROFS`
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function Readonly<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => ReadonlyFileSystem) & T {
-	abstract class _ReadonlyFileSystem extends FS implements ReadonlyFileSystem {
+export function Readonly<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => ReadonlyFS) & T {
+	abstract class _ReadonlyFS extends FS implements ReadonlyFS {
 		public metadata(): FileSystemMetadata {
 			return { ...super.metadata(), readonly: true };
 		}
@@ -546,5 +547,5 @@ export function Readonly<T extends abstract new (...args: any[]) => FileSystem>(
 		}
 		/* eslint-enable @typescript-eslint/no-unused-vars */
 	}
-	return _ReadonlyFileSystem;
+	return _ReadonlyFS;
 }

package/src/index.ts

@@ -6,6 +6,8 @@ export * from './backends/Index.js';
 export * from './backends/locked.js';
 export * from './backends/overlay.js';
 export * from './backends/store/fs.js';
+export * from './backends/store/simple.js';
+export * from './backends/store/store.js';
 export * from './backends/backend.js';
 export * from './config.js';
 export * from './cred.js';

package/src/mutex.ts

@@ -5,24 +5,24 @@ import { ErrnoError, Errno } from './error.js';
  * @internal
  */
 export class Mutex {
-	private _locks: Map<string, (() => void)[]> = new Map();
+	protected locks: Map<string, (() => void)[]> = new Map();
 
 	public lock(path: string): Promise<void> {
 		return new Promise(resolve => {
-			if (this._locks.has(path)) {
-				this._locks.get(path)!.push(resolve);
+			if (this.locks.has(path)) {
+				this.locks.get(path)!.push(resolve);
 			} else {
-				this._locks.set(path, [resolve]);
+				this.locks.set(path, [resolve]);
 			}
 		});
 	}
 
 	public unlock(path: string): void {
-		if (!this._locks.has(path)) {
+		if (!this.locks.has(path)) {
 			throw new ErrnoError(Errno.EPERM, 'Can not unlock an already unlocked path', path);
 		}
 
-		const next = this._locks.get(path)?.shift();
+		const next = this.locks.get(path)?.shift();
 		/* 
 			don't unlock - we want to queue up next for the
 			end of the current task execution, but we don't
@@ -32,23 +32,23 @@ export class Mutex {
 			lock won't cause starvation.
 		*/
 		if (next) {
-			setTimeout(next, 0);
+			setTimeout(next);
 			return;
 		}
 
-		this._locks.delete(path);
+		this.locks.delete(path);
 	}
 
 	public tryLock(path: string): boolean {
-		if (this._locks.has(path)) {
+		if (this.locks.has(path)) {
 			return false;
 		}
 
-		this._locks.set(path, []);
+		this.locks.set(path, []);
 		return true;
 	}
 
 	public isLocked(path: string): boolean {
-		return this._locks.has(path);
+		return this.locks.has(path);
 	}
 }