@zenfs/core 0.11.1 → 0.12.0

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/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/file.ts

@@ -701,8 +701,8 @@ export class PreloadFile<FS extends FileSystem> extends File {
  * For the filesystems which do not sync to anything..
  */
 export class NoSyncFile<T extends FileSystem> extends PreloadFile<T> {
-	constructor(_fs: T, _path: string, _flag: string, _stat: Stats, contents?: Uint8Array) {
-		super(_fs, _path, _flag, _stat, contents);
+	constructor(fs: T, path: string, flag: string, stats: Stats, contents?: Uint8Array) {
+		super(fs, path, flag, stats, contents);
 	}
 	/**
 	 * Asynchronous sync. Doesn't do anything, simply calls the cb.

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

@@ -2,7 +2,7 @@ export * from './error.js';
 export * from './backends/port/fs.js';
 export * from './backends/fetch.js';
 export * from './backends/memory.js';
-export * from './backends/Index.js';
+export * from './backends/index/fs.js';
 export * from './backends/locked.js';
 export * from './backends/overlay.js';
 export * from './backends/store/fs.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);
 	}
 }

package/src/stats.ts

@@ -14,45 +14,45 @@ export enum FileType {
 /**
  *
  */
-export interface StatsLike {
+export interface StatsLike<T extends number | bigint = number | bigint> {
 	/**
 	 * Size of the item in bytes.
 	 * For directories/symlinks, this is normally the size of the struct that represents the item.
 	 */
-	size: number | bigint;
+	size: T;
 	/**
 	 * Unix-style file mode (e.g. 0o644) that includes the item type
 	 * Type of the item can be FILE, DIRECTORY, SYMLINK, or SOCKET
 	 */
-	mode: number | bigint;
+	mode: T;
 	/**
 	 * time of last access, in milliseconds since epoch
 	 */
-	atimeMs: number | bigint;
+	atimeMs: T;
 	/**
 	 * time of last modification, in milliseconds since epoch
 	 */
-	mtimeMs: number | bigint;
+	mtimeMs: T;
 	/**
 	 * time of last time file status was changed, in milliseconds since epoch
 	 */
-	ctimeMs: number | bigint;
+	ctimeMs: T;
 	/**
 	 * time of file creation, in milliseconds since epoch
 	 */
-	birthtimeMs: number | bigint;
+	birthtimeMs: T;
 	/**
 	 * the id of the user that owns the file
 	 */
-	uid: number | bigint;
+	uid: T;
 	/**
 	 * the id of the group that owns the file
 	 */
-	gid: number | bigint;
+	gid: T;
 	/**
 	 * the ino
 	 */
-	ino: number | bigint;
+	ino: T;
 }
 
 /**