@zenfs/core 0.16.3 → 0.17.0

package/src/backends/store/fs.ts

@@ -65,8 +65,8 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @todo Make rename compatible with the cache.
 	 */
 	public async rename(oldPath: string, newPath: string, cred: Cred): Promise<void> {
-		const tx = this.store.transaction(),
-			oldParent = dirname(oldPath),
+		await using tx = this.store.transaction();
+		const oldParent = dirname(oldPath),
 			oldName = basename(oldPath),
 			newParent = dirname(newPath),
 			newName = basename(newPath),
@@ -108,13 +108,8 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 			// If it's a file, delete it.
 			const newNameNode = await this.getINode(tx, newDirList[newName], newPath);
 			if (newNameNode.toStats().isFile()) {
-				try {
-					await tx.remove(newNameNode.ino);
-					await tx.remove(newDirList[newName]);
-				} catch (e) {
-					await tx.abort();
-					throw e;
-				}
+				await tx.remove(newNameNode.ino);
+				await tx.remove(newDirList[newName]);
 			} else {
 				// If it's a directory, throw a permissions error.
 				throw ErrnoError.With('EPERM', newPath, 'rename');
@@ -122,20 +117,14 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 		}
 		newDirList[newName] = nodeId;
 		// Commit the two changed directory listings.
-		try {
-			await tx.set(oldDirNode.ino, encodeDirListing(oldDirList));
-			await tx.set(newDirNode.ino, encodeDirListing(newDirList));
-		} catch (e) {
-			await tx.abort();
-			throw e;
-		}
-
+		await tx.set(oldDirNode.ino, encodeDirListing(oldDirList));
+		await tx.set(newDirNode.ino, encodeDirListing(newDirList));
 		await tx.commit();
 	}
 
 	public renameSync(oldPath: string, newPath: string, cred: Cred): void {
-		const tx = this.store.transaction(),
-			oldParent = dirname(oldPath),
+		using tx = this.store.transaction();
+		const oldParent = dirname(oldPath),
 			oldName = basename(oldPath),
 			newParent = dirname(newPath),
 			newName = basename(newPath),
@@ -177,13 +166,8 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 			// If it's a file, delete it.
 			const newNameNode = this.getINodeSync(tx, newDirList[newName], newPath);
 			if (newNameNode.toStats().isFile()) {
-				try {
-					tx.removeSync(newNameNode.ino);
-					tx.removeSync(newDirList[newName]);
-				} catch (e) {
-					tx.abortSync();
-					throw e;
-				}
+				tx.removeSync(newNameNode.ino);
+				tx.removeSync(newDirList[newName]);
 			} else {
 				// If it's a directory, throw a permissions error.
 				throw ErrnoError.With('EPERM', newPath, 'rename');
@@ -192,19 +176,13 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 		newDirList[newName] = ino;
 
 		// Commit the two changed directory listings.
-		try {
-			tx.setSync(oldDirNode.ino, encodeDirListing(oldDirList));
-			tx.setSync(newDirNode.ino, encodeDirListing(newDirList));
-		} catch (e) {
-			tx.abortSync();
-			throw e;
-		}
-
+		tx.setSync(oldDirNode.ino, encodeDirListing(oldDirList));
+		tx.setSync(newDirNode.ino, encodeDirListing(newDirList));
 		tx.commitSync();
 	}
 
 	public async stat(path: string, cred: Cred): Promise<Stats> {
-		const tx = this.store.transaction();
+		await using tx = this.store.transaction();
 		const inode = await this.findINode(tx, path);
 		if (!inode) {
 			throw ErrnoError.With('ENOENT', path, 'stat');
@@ -217,8 +195,9 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	}
 
 	public statSync(path: string, cred: Cred): Stats {
+		using tx = this.store.transaction();
 		// Get the inode to the item, convert it into a Stats object.
-		const stats = this.findINodeSync(this.store.transaction(), path).toStats();
+		const stats = this.findINodeSync(tx, path).toStats();
 		if (!stats.hasAccess(R_OK, cred)) {
 			throw ErrnoError.With('EACCES', path, 'stat');
 		}
@@ -226,9 +205,8 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	}
 
 	public async createFile(path: string, flag: string, mode: number, cred: Cred): Promise<PreloadFile<this>> {
-		const data = new Uint8Array(0);
-		const file = await this.commitNew(this.store.transaction(), path, S_IFREG, mode, cred, data);
-		return new PreloadFile(this, path, flag, file.toStats(), data);
+		const node = await this.commitNew(path, S_IFREG, mode, cred, new Uint8Array(0));
+		return new PreloadFile(this, path, flag, node.toStats(), new Uint8Array(0));
 	}
 
 	public createFileSync(path: string, flag: string, mode: number, cred: Cred): PreloadFile<this> {
@@ -237,8 +215,8 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	}
 
 	public async openFile(path: string, flag: string, cred: Cred): Promise<PreloadFile<this>> {
-		const tx = this.store.transaction(),
-			node = await this.findINode(tx, path),
+		await using tx = this.store.transaction();
+		const node = await this.findINode(tx, path),
 			data = await tx.get(node.ino);
 		if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
 			throw ErrnoError.With('EACCES', path, 'openFile');
@@ -250,8 +228,8 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	}
 
 	public openFileSync(path: string, flag: string, cred: Cred): PreloadFile<this> {
-		const tx = this.store.transaction(),
-			node = this.findINodeSync(tx, path),
+		using tx = this.store.transaction();
+		const node = this.findINodeSync(tx, path),
 			data = tx.getSync(node.ino);
 		if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
 			throw ErrnoError.With('EACCES', path, 'openFile');
@@ -289,9 +267,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	}
 
 	public async mkdir(path: string, mode: number, cred: Cred): Promise<void> {
-		const tx = this.store.transaction(),
-			data = encode('{}');
-		await this.commitNew(tx, path, S_IFDIR, mode, cred, data);
+		await this.commitNew(path, S_IFDIR, mode, cred, encode('{}'));
 	}
 
 	public mkdirSync(path: string, mode: number, cred: Cred): void {
@@ -299,7 +275,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	}
 
 	public async readdir(path: string, cred: Cred): Promise<string[]> {
-		const tx = this.store.transaction();
+		await using tx = this.store.transaction();
 		const node = await this.findINode(tx, path);
 		if (!node.toStats().hasAccess(R_OK, cred)) {
 			throw ErrnoError.With('EACCES', path, 'readdur');
@@ -308,7 +284,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	}
 
 	public readdirSync(path: string, cred: Cred): string[] {
-		const tx = this.store.transaction();
+		using tx = this.store.transaction();
 		const node = this.findINodeSync(tx, path);
 		if (!node.toStats().hasAccess(R_OK, cred)) {
 			throw ErrnoError.With('EACCES', path, 'readdir');
@@ -321,23 +297,19 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @todo Ensure mtime updates properly, and use that to determine if a data update is required.
 	 */
 	public async sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void> {
-		const tx = this.store.transaction(),
-			// We use _findInode because we actually need the INode id.
-			fileInodeId = await this._findINode(tx, dirname(path), basename(path)),
+		await using tx = this.store.transaction();
+		// We use _findInode because we actually need the INode id.
+		const fileInodeId = await this._findINode(tx, dirname(path), basename(path)),
 			fileInode = await this.getINode(tx, fileInodeId, path),
 			inodeChanged = fileInode.update(stats);
 
-		try {
-			// Sync data.
-			await tx.set(fileInode.ino, data);
-			// Sync metadata.
-			if (inodeChanged) {
-				await tx.set(fileInodeId, fileInode.data);
-			}
-		} catch (e) {
-			await tx.abort();
-			throw e;
+		// Sync data.
+		await tx.set(fileInode.ino, data);
+		// Sync metadata.
+		if (inodeChanged) {
+			await tx.set(fileInodeId, fileInode.data);
 		}
+
 		await tx.commit();
 	}
 
@@ -346,29 +318,25 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @todo Ensure mtime updates properly, and use that to determine if a data update is required.
 	 */
 	public syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void {
-		const tx = this.store.transaction(),
-			// We use _findInode because we actually need the INode id.
-			fileInodeId = this._findINodeSync(tx, dirname(path), basename(path)),
+		using tx = this.store.transaction();
+		// We use _findInode because we actually need the INode id.
+		const fileInodeId = this._findINodeSync(tx, dirname(path), basename(path)),
 			fileInode = this.getINodeSync(tx, fileInodeId, path),
 			inodeChanged = fileInode.update(stats);
 
-		try {
-			// Sync data.
-			tx.setSync(fileInode.ino, data);
-			// Sync metadata.
-			if (inodeChanged) {
-				tx.setSync(fileInodeId, fileInode.data);
-			}
-		} catch (e) {
-			tx.abortSync();
-			throw e;
+		// Sync data.
+		tx.setSync(fileInode.ino, data);
+		// Sync metadata.
+		if (inodeChanged) {
+			tx.setSync(fileInodeId, fileInode.data);
 		}
+
 		tx.commitSync();
 	}
 
 	public async link(existing: string, newpath: string, cred: Cred): Promise<void> {
-		const tx = this.store.transaction(),
-			existingDir: string = dirname(existing),
+		await using tx = this.store.transaction();
+		const existingDir: string = dirname(existing),
 			existingDirNode = await this.findINode(tx, existingDir);
 
 		if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
@@ -392,19 +360,15 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 
 		node.nlink++;
 		newListing[basename(newpath)] = ino;
-		try {
-			tx.setSync(ino, node.data);
-			tx.setSync(newDirNode.ino, encodeDirListing(newListing));
-		} catch (e) {
-			tx.abortSync();
-			throw e;
-		}
+
+		tx.setSync(ino, node.data);
+		tx.setSync(newDirNode.ino, encodeDirListing(newListing));
 		tx.commitSync();
 	}
 
 	public linkSync(existing: string, newpath: string, cred: Cred): void {
-		const tx = this.store.transaction(),
-			existingDir: string = dirname(existing),
+		using tx = this.store.transaction();
+		const existingDir: string = dirname(existing),
 			existingDirNode = this.findINodeSync(tx, existingDir);
 
 		if (!existingDirNode.toStats().hasAccess(R_OK, cred)) {
@@ -427,13 +391,9 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 		}
 		node.nlink++;
 		newListing[basename(newpath)] = ino;
-		try {
-			tx.setSync(ino, node.data);
-			tx.setSync(newDirNode.ino, encodeDirListing(newListing));
-		} catch (e) {
-			tx.abortSync();
-			throw e;
-		}
+
+		tx.setSync(ino, node.data);
+		tx.setSync(newDirNode.ino, encodeDirListing(newListing));
 		tx.commitSync();
 	}
 
@@ -441,7 +401,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * Checks if the root directory exists. Creates it if it doesn't.
 	 */
 	public async checkRoot(): Promise<void> {
-		const tx = this.store.transaction();
+		await using tx = this.store.transaction();
 		if (await tx.get(rootIno)) {
 			return;
 		}
@@ -458,7 +418,7 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * Checks if the root directory exists. Creates it if it doesn't.
 	 */
 	public checkRootSync(): void {
-		const tx = this.store.transaction();
+		using tx = this.store.transaction();
 		if (tx.getSync(rootIno)) {
 			return;
 		}
@@ -656,7 +616,8 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @param cred The UID/GID to create the file with
 	 * @param data The data to store at the file's data node.
 	 */
-	private async commitNew(tx: Transaction, path: string, type: FileType, mode: number, cred: Cred, data: Uint8Array): Promise<Inode> {
+	private async commitNew(path: string, type: FileType, mode: number, cred: Cred, data: Uint8Array): Promise<Inode> {
+		await using tx = this.store.transaction();
 		const parentPath = dirname(path),
 			parent = await this.findINode(tx, parentPath);
 
@@ -682,25 +643,20 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 			await tx.abort();
 			throw ErrnoError.With('EEXIST', path, 'commitNewFile');
 		}
-		try {
-			// Commit data.
-
-			const inode = new Inode();
-			inode.ino = await this.addNew(tx, data, path);
-			inode.mode = mode | type;
-			inode.uid = cred.uid;
-			inode.gid = cred.gid;
-			inode.size = data.length;
-
-			// Update and commit parent directory listing.
-			listing[fname] = await this.addNew(tx, inode.data, path);
-			await tx.set(parent.ino, encodeDirListing(listing));
-			await tx.commit();
-			return inode;
-		} catch (e) {
-			await tx.abort();
-			throw e;
-		}
+
+		// Commit data.
+		const inode = new Inode();
+		inode.ino = await this.addNew(tx, data, path);
+		inode.mode = mode | type;
+		inode.uid = cred.uid;
+		inode.gid = cred.gid;
+		inode.size = data.length;
+
+		// Update and commit parent directory listing.
+		listing[fname] = await this.addNew(tx, inode.data, path);
+		await tx.set(parent.ino, encodeDirListing(listing));
+		await tx.commit();
+		return inode;
 	}
 
 	/**
@@ -713,8 +669,8 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @return The Inode for the new file.
 	 */
 	protected commitNewSync(path: string, type: FileType, mode: number, cred: Cred, data: Uint8Array = new Uint8Array()): Inode {
-		const tx = this.store.transaction(),
-			parentPath = dirname(path),
+		using tx = this.store.transaction();
+		const parentPath = dirname(path),
 			parent = this.findINodeSync(tx, parentPath);
 
 		//Check that the creater has correct access
@@ -739,21 +695,16 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 			throw ErrnoError.With('EEXIST', path, 'commitNewFile');
 		}
 
+		// Commit data.
 		const node = new Inode();
-		try {
-			// Commit data.
-			node.ino = this.addNewSync(tx, data, path);
-			node.size = data.length;
-			node.mode = mode | type;
-			node.uid = cred.uid;
-			node.gid = cred.gid;
-			// Update and commit parent directory listing.
-			listing[fname] = this.addNewSync(tx, node.data, path);
-			tx.setSync(parent.ino, encodeDirListing(listing));
-		} catch (e) {
-			tx.abortSync();
-			throw e;
-		}
+		node.ino = this.addNewSync(tx, data, path);
+		node.size = data.length;
+		node.mode = mode | type;
+		node.uid = cred.uid;
+		node.gid = cred.gid;
+		// Update and commit parent directory listing.
+		listing[fname] = this.addNewSync(tx, node.data, path);
+		tx.setSync(parent.ino, encodeDirListing(listing));
 		tx.commitSync();
 		return node;
 	}
@@ -765,8 +716,8 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @todo Update mtime.
 	 */
 	private async remove(path: string, isDir: boolean, cred: Cred): Promise<void> {
-		const tx = this.store.transaction(),
-			parent: string = dirname(path),
+		await using tx = this.store.transaction();
+		const parent: string = dirname(path),
 			parentNode = await this.findINode(tx, parent),
 			listing = await this.getDirListing(tx, parentNode, parent),
 			fileName: string = basename(path);
@@ -795,17 +746,12 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 			throw ErrnoError.With('ENOTDIR', path, 'removeEntry');
 		}
 
-		try {
-			await tx.set(parentNode.ino, encodeDirListing(listing));
+		await tx.set(parentNode.ino, encodeDirListing(listing));
 
-			if (--fileNode.nlink < 1) {
-				// remove file
-				await tx.remove(fileNode.ino);
-				await tx.remove(fileIno);
-			}
-		} catch (e) {
-			await tx.abort();
-			throw e;
+		if (--fileNode.nlink < 1) {
+			// remove file
+			await tx.remove(fileNode.ino);
+			await tx.remove(fileIno);
 		}
 
 		// Success.
@@ -819,8 +765,8 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 	 * @todo Update mtime.
 	 */
 	protected removeSync(path: string, isDir: boolean, cred: Cred): void {
-		const tx = this.store.transaction(),
-			parent: string = dirname(path),
+		using tx = this.store.transaction();
+		const parent: string = dirname(path),
 			parentNode = this.findINodeSync(tx, parent),
 			listing = this.getDirListingSync(tx, parentNode, parent),
 			fileName: string = basename(path),
@@ -848,19 +794,15 @@ export class StoreFS<T extends Store = Store> extends FileSystem {
 			throw ErrnoError.With('ENOTDIR', path, 'removeEntry');
 		}
 
-		try {
-			// Update directory listing.
-			tx.setSync(parentNode.ino, encodeDirListing(listing));
+		// Update directory listing.
+		tx.setSync(parentNode.ino, encodeDirListing(listing));
 
-			if (--fileNode.nlink < 1) {
-				// remove file
-				tx.removeSync(fileNode.ino);
-				tx.removeSync(fileIno);
-			}
-		} catch (e) {
-			tx.abortSync();
-			throw e;
+		if (--fileNode.nlink < 1) {
+			// remove file
+			tx.removeSync(fileNode.ino);
+			tx.removeSync(fileIno);
 		}
+
 		// Success.
 		tx.commitSync();
 	}

package/src/backends/store/simple.ts

@@ -103,10 +103,13 @@ export class SimpleTransaction extends SyncTransaction<SimpleSyncStore> {
 	}
 
 	public commitSync(): void {
-		/* NOP */
+		this.done = true;
 	}
 
 	public abortSync(): void {
+		if (!this.done) {
+			return;
+		}
 		// Rollback old values.
 		for (const key of this.modifiedKeys) {
 			const value = this.originalData.get(key);
@@ -118,6 +121,7 @@ export class SimpleTransaction extends SyncTransaction<SimpleSyncStore> {
 				this.store.set(key, value);
 			}
 		}
+		this.done = true;
 	}
 
 	/**

package/src/backends/store/store.ts

@@ -38,7 +38,10 @@ export interface Store {
 export abstract class Transaction<T extends Store = Store> {
 	constructor(protected store: T) {}
 
-	protected aborted: boolean = false;
+	/**
+	 * Whether the transaction was commited or aborted
+	 */
+	protected done: boolean = false;
 
 	/**
 	 * Retrieves the data at the given key.
@@ -92,11 +95,11 @@ export abstract class Transaction<T extends Store = Store> {
 	public abstract commit(): Promise<void>;
 
 	public async [Symbol.asyncDispose]() {
-		if (this.aborted) {
+		if (this.done) {
 			return;
 		}
 
-		await this.commit();
+		await this.abort();
 	}
 
 	/**
@@ -105,11 +108,11 @@ export abstract class Transaction<T extends Store = Store> {
 	public abstract commitSync(): void;
 
 	public [Symbol.dispose]() {
-		if (this.aborted) {
+		if (this.done) {
 			return;
 		}
 
-		this.commitSync();
+		this.abortSync();
 	}
 
 	/**
@@ -127,6 +130,7 @@ export abstract class Transaction<T extends Store = Store> {
  * Transaction that implements asynchronous operations with synchronous ones
  */
 export abstract class SyncTransaction<T extends Store = Store> extends Transaction<T> {
+	/* eslint-disable @typescript-eslint/require-await */
 	public async get(ino: Ino): Promise<Uint8Array> {
 		return this.getSync(ino);
 	}
@@ -142,6 +146,7 @@ export abstract class SyncTransaction<T extends Store = Store> extends Transacti
 	public async abort(): Promise<void> {
 		return this.abortSync();
 	}
+	/* eslint-enable @typescript-eslint/require-await */
 }
 
 /**

package/src/config.ts

@@ -64,7 +64,9 @@ export async function resolveMountConfig<T extends Backend>(config: MountConfigu
 	return mount;
 }
 
-export type ConfigMounts = { [K in AbsolutePath]: Backend };
+export interface ConfigMounts {
+	[K: AbsolutePath]: Backend;
+}
 
 /**
  * Configuration

package/src/emulation/async.ts

@@ -10,6 +10,7 @@ import { type Dir } from './dir.js';
 import * as promises from './promises.js';
 import { fd2file } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
+import { FSWatcher } from './watchers.js';
 
 /**
  * Asynchronous rename. No arguments other than a possible exception are given
@@ -675,7 +676,11 @@ access satisfies Omit<typeof fs.access, '__promisify__'>;
  */
 export function watchFile(path: fs.PathLike, listener: (curr: Stats, prev: Stats) => void): void;
 export function watchFile(path: fs.PathLike, options: { persistent?: boolean; interval?: number }, listener: (curr: Stats, prev: Stats) => void): void;
-export function watchFile(path: fs.PathLike, optsListener: any, listener: (curr: Stats, prev: Stats) => void = nop): void {
+export function watchFile(
+	path: fs.PathLike,
+	optsListener: { persistent?: boolean; interval?: number } | ((curr: Stats, prev: Stats) => void),
+	listener: (curr: Stats, prev: Stats) => void = nop
+): void {
 	throw ErrnoError.With('ENOSYS', path.toString(), 'watchFile');
 }
 watchFile satisfies Omit<typeof fs.watchFile, '__promisify__'>;
@@ -688,13 +693,17 @@ export function unwatchFile(path: fs.PathLike, listener: (curr: Stats, prev: Sta
 }
 unwatchFile satisfies Omit<typeof fs.unwatchFile, '__promisify__'>;
 
-/**
- * @todo Implement
- */
 export function watch(path: fs.PathLike, listener?: (event: string, filename: string) => any): fs.FSWatcher;
 export function watch(path: fs.PathLike, options: { persistent?: boolean }, listener?: (event: string, filename: string) => any): fs.FSWatcher;
-export function watch(path: fs.PathLike, options: any, listener: (event: string, filename: string) => any = nop): fs.FSWatcher {
-	throw ErrnoError.With('ENOSYS', path.toString(), 'watch');
+export function watch(
+	path: fs.PathLike,
+	options?: fs.WatchOptions | ((event: string, filename: string) => any),
+	listener?: (event: string, filename: string) => any
+): fs.FSWatcher {
+	const watcher = new FSWatcher<string>(typeof options == 'object' ? options : {});
+	listener = typeof options == 'function' ? options : listener;
+	watcher.on('change', listener || nop);
+	return watcher;
 }
 watch satisfies Omit<typeof fs.watch, '__promisify__'>;
 

package/src/emulation/dir.ts

@@ -57,15 +57,22 @@ export class Dir implements _Dir {
 
 	protected _entries: Dirent[] = [];
 
-	constructor(public readonly path: string) {}
+	/**
+	 * @internal
+	 */
+	public async _loadEntries() {
+		this._entries ??= await readdir(this.path, { withFileTypes: true });
+	}
+
+	public constructor(public readonly path: string) {}
 
 	/**
 	 * Asynchronously close the directory's underlying resource handle.
 	 * Subsequent reads will result in errors.
 	 */
-	close(): Promise<void>;
-	close(cb: Callback): void;
-	close(cb?: Callback): void | Promise<void> {
+	public close(): Promise<void>;
+	public close(cb: Callback): void;
+	public close(cb?: Callback): void | Promise<void> {
 		this.closed = true;
 		if (!cb) {
 			return Promise.resolve();
@@ -77,14 +84,12 @@ export class Dir implements _Dir {
 	 * Synchronously close the directory's underlying resource handle.
 	 * Subsequent reads will result in errors.
 	 */
-	closeSync(): void {
+	public closeSync(): void {
 		this.closed = true;
 	}
 
 	protected async _read(): Promise<Dirent | null> {
-		if (!this._entries) {
-			this._entries = await readdir(this.path, { withFileTypes: true });
-		}
+		await this._loadEntries();
 		if (!this._entries.length) {
 			return null;
 		}
@@ -96,9 +101,9 @@ export class Dir implements _Dir {
 	 * After the read is completed, a value is returned that will be resolved with an `Dirent`, or `null` if there are no more directory entries to read.
 	 * Directory entries returned by this function are in no particular order as provided by the operating system's underlying directory mechanisms.
 	 */
-	read(): Promise<Dirent | null>;
-	read(cb: Callback<[Dirent | null]>): void;
-	read(cb?: Callback<[Dirent | null]>): void | Promise<Dirent | null> {
+	public read(): Promise<Dirent | null>;
+	public read(cb: Callback<[Dirent | null]>): void;
+	public read(cb?: Callback<[Dirent | null]>): void | Promise<Dirent | null> {
 		if (!cb) {
 			return this._read();
 		}
@@ -111,10 +116,8 @@ export class Dir implements _Dir {
 	 * If there are no more directory entries to read, null will be returned.
 	 * Directory entries returned by this function are in no particular order as provided by the operating system's underlying directory mechanisms.
 	 */
-	readSync(): Dirent | null {
-		if (!this._entries) {
-			this._entries = readdirSync(this.path, { withFileTypes: true });
-		}
+	public readSync(): Dirent | null {
+		this._entries ??= readdirSync(this.path, { withFileTypes: true });
 		if (!this._entries.length) {
 			return null;
 		}
@@ -124,7 +127,7 @@ export class Dir implements _Dir {
 	/**
 	 * Asynchronously iterates over the directory via `readdir(3)` until all entries have been read.
 	 */
-	[Symbol.asyncIterator](): AsyncIterableIterator<Dirent> {
+	public [Symbol.asyncIterator](): AsyncIterableIterator<Dirent> {
 		const _this = this;
 
 		return {