@zenfs/core 1.1.0 → 1.1.2

package/dist/devices.d.ts

@@ -1,4 +1,4 @@
-import type { FileReadResult } from 'fs/promises';
+import type { FileReadResult } from 'node:fs/promises';
 import { InMemoryStore } from './backends/memory.js';
 import { StoreFS } from './backends/store/fs.js';
 import { File } from './file.js';

package/dist/emulation/dir.d.ts

@@ -1,4 +1,4 @@
-import type { Dir as _Dir, Dirent as _Dirent } from 'fs';
+import type { Dir as _Dir, Dirent as _Dirent } from 'node:fs';
 import type { Stats } from '../stats.js';
 import type { Callback } from '../utils.js';
 export declare class Dirent implements _Dirent {

package/dist/emulation/promises.d.ts

@@ -1,7 +1,6 @@
 import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
 import type * as promises from 'node:fs/promises';
-import type { CreateReadStreamOptions, CreateWriteStreamOptions, FileChangeInfo, FileReadResult, FlagAndOpenMode } from 'node:fs/promises';
 import type { Stream } from 'node:stream';
 import type { ReadableStream as TReadableStream } from 'node:stream/web';
 import type { Interface as ReadlineInterface } from 'readline';
@@ -60,7 +59,7 @@ export declare class FileHandle implements promises.FileHandle {
      * - `mode` defaults to `0o666`.
      * - `flag` defaults to `'a'`.
      */
-    appendFile(data: string | Uint8Array, _options?: (fs.ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding): Promise<void>;
+    appendFile(data: string | Uint8Array, _options?: (fs.ObjectEncodingOptions & promises.FlagAndOpenMode) | BufferEncoding): Promise<void>;
     /**
      * Asynchronously reads data from the file.
      * The `FileHandle` must have been opened for reading.
@@ -69,7 +68,7 @@ export declare class FileHandle implements promises.FileHandle {
      * @param length The number of bytes to read.
      * @param position The offset from the beginning of the file from which data should be read. If `null`, data will be read from the current position.
      */
-    read<TBuffer extends NodeJS.ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number | null): Promise<FileReadResult<TBuffer>>;
+    read<TBuffer extends NodeJS.ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number | null): Promise<promises.FileReadResult<TBuffer>>;
     /**
      * Asynchronously reads the entire contents of a file. The underlying file will _not_ be closed automatically.
      * The `FileHandle` must have been opened for reading.
@@ -79,7 +78,7 @@ export declare class FileHandle implements promises.FileHandle {
     readFile(_options?: {
         flag?: fs.OpenMode;
     }): Promise<Buffer>;
-    readFile(_options: (fs.ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding): Promise<string>;
+    readFile(_options: (fs.ObjectEncodingOptions & promises.FlagAndOpenMode) | BufferEncoding): Promise<string>;
     /**
      * Returns a `ReadableStream` that may be used to read the files data.
      *
@@ -153,12 +152,12 @@ export declare class FileHandle implements promises.FileHandle {
      * Creates a stream for reading from the file.
      * @param options Options for the readable stream
      */
-    createReadStream(options?: CreateReadStreamOptions): ReadStream;
+    createReadStream(options?: promises.CreateReadStreamOptions): ReadStream;
     /**
      * Creates a stream for writing to the file.
      * @param options Options for the writeable stream.
      */
-    createWriteStream(options?: CreateWriteStreamOptions): WriteStream;
+    createWriteStream(options?: promises.CreateWriteStreamOptions): WriteStream;
 }
 export declare function rename(oldPath: fs.PathLike, newPath: fs.PathLike): Promise<void>;
 /**
@@ -265,6 +264,11 @@ export declare function readdir(path: fs.PathLike, options: fs.ObjectEncodingOpt
     withFileTypes: true;
     recursive?: boolean;
 }): Promise<Dirent[]>;
+export declare function readdir(path: fs.PathLike, options?: {
+    withFileTypes?: boolean;
+    recursive?: boolean;
+    encoding?: BufferEncoding | 'buffer' | null;
+} | BufferEncoding | 'buffer' | null): Promise<string[] | Dirent[] | Buffer[]>;
 export declare function link(targetPath: fs.PathLike, linkPath: fs.PathLike): Promise<void>;
 /**
  * `symlink`.
@@ -295,9 +299,9 @@ export declare function lutimes(path: fs.PathLike, atime: fs.TimeLike, mtime: fs
  */
 export declare function realpath(path: fs.PathLike, options: fs.BufferEncodingOption): Promise<Buffer>;
 export declare function realpath(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding): Promise<string>;
-export declare function watch(filename: fs.PathLike, options?: fs.WatchOptions | BufferEncoding): AsyncIterable<FileChangeInfo<string>>;
-export declare function watch(filename: fs.PathLike, options: fs.WatchOptions | fs.BufferEncodingOption): AsyncIterable<FileChangeInfo<Buffer>>;
-export declare function watch(filename: fs.PathLike, options?: fs.WatchOptions | string): AsyncIterable<FileChangeInfo<string>> | AsyncIterable<FileChangeInfo<Buffer>>;
+export declare function watch(filename: fs.PathLike, options?: fs.WatchOptions | BufferEncoding): AsyncIterable<promises.FileChangeInfo<string>>;
+export declare function watch(filename: fs.PathLike, options: fs.WatchOptions | fs.BufferEncodingOption): AsyncIterable<promises.FileChangeInfo<Buffer>>;
+export declare function watch(filename: fs.PathLike, options?: fs.WatchOptions | string): AsyncIterable<promises.FileChangeInfo<string>> | AsyncIterable<promises.FileChangeInfo<Buffer>>;
 export declare function access(path: fs.PathLike, mode?: number): Promise<void>;
 /**
  * Asynchronous `rm`. Removes files or directories (recursively).

package/dist/emulation/promises.js

@@ -51,7 +51,7 @@ import { Errno, ErrnoError } from '../error.js';
 import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import '../polyfills.js';
 import { BigIntStats } from '../stats.js';
-import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
@@ -627,19 +627,16 @@ export async function mkdir(path, options) {
 }
 mkdir;
 export async function readdir(path, options) {
+    options = typeof options === 'object' ? options : { encoding: options };
     path = normalizePath(path);
     if (!(await stat(path)).hasAccess(constants.R_OK)) {
         throw ErrnoError.With('EACCES', path, 'readdir');
     }
     path = (await exists(path)) ? await realpath(path) : path;
     const { fs, path: resolved } = resolveMount(path);
-    let entries;
-    try {
-        entries = await fs.readdir(resolved);
-    }
-    catch (e) {
+    const entries = await fs.readdir(resolved).catch((e) => {
         throw fixError(e, { [resolved]: path });
-    }
+    });
     for (const point of mounts.keys()) {
         if (point.startsWith(path)) {
             const entry = point.slice(path.length);
@@ -652,12 +649,37 @@ export async function readdir(path, options) {
     }
     const values = [];
     for (const entry of entries) {
-        values.push(typeof options == 'object' && options?.withFileTypes ? new Dirent(entry, await stat(join(path, entry))) : entry);
+        const fullPath = join(path, entry);
+        const stats = options?.recursive || options?.withFileTypes ? await stat(fullPath) : null;
+        if (options?.withFileTypes) {
+            values.push(new Dirent(entry, stats));
+        }
+        else if (options?.encoding === 'buffer') {
+            values.push(Buffer.from(entry));
+        }
+        else {
+            values.push(entry);
+        }
+        if (!options?.recursive || !stats?.isDirectory()) {
+            continue;
+        }
+        for (const subEntry of await readdir(fullPath, options)) {
+            if (subEntry instanceof Dirent) {
+                subEntry.path = join(entry, subEntry.path);
+                values.push(subEntry);
+            }
+            else if (Buffer.isBuffer(subEntry)) {
+                // Convert Buffer to string, prefix with the full path
+                values.push(Buffer.from(join(entry, decodeUTF8(subEntry))));
+            }
+            else {
+                values.push(join(entry, subEntry));
+            }
+        }
     }
     return values;
 }
 readdir;
-// SYMLINK METHODS
 export async function link(targetPath, linkPath) {
     targetPath = normalizePath(targetPath);
     if (!(await stat(dirname(targetPath))).hasAccess(constants.R_OK)) {
@@ -849,20 +871,28 @@ realpath;
 export function watch(filename, options = {}) {
     return {
         [Symbol.asyncIterator]() {
-            const watcher = new FSWatcher(filename.toString(), typeof options != 'string' ? options : { encoding: options });
-            function withDone(done) {
-                return function () {
-                    const event = Promise.withResolvers();
-                    watcher.on('change', (eventType, filename) => {
-                        event.resolve({ value: { eventType, filename }, done });
-                    });
-                    return event.promise;
-                };
+            const watcher = new FSWatcher(filename.toString(), typeof options !== 'string' ? options : { encoding: options });
+            // A queue to hold change events, since we need to resolve them in the async iterator
+            const eventQueue = [];
+            watcher.on('change', (eventType, filename) => {
+                eventQueue.shift()?.({ value: { eventType, filename }, done: false });
+            });
+            function cleanup() {
+                watcher.close();
+                for (const resolve of eventQueue) {
+                    resolve({ value: null, done: true });
+                }
+                eventQueue.length = 0; // Clear the queue
+                return Promise.resolve({ value: null, done: true });
             }
             return {
-                next: withDone(false),
-                return: withDone(true),
-                throw: withDone(true),
+                async next() {
+                    const { promise, resolve } = Promise.withResolvers();
+                    eventQueue.push(resolve);
+                    return promise;
+                },
+                return: cleanup,
+                throw: cleanup,
             };
         },
     };

package/dist/emulation/streams.d.ts

@@ -1,4 +1,4 @@
-import type * as Node from 'fs';
+import type * as Node from 'node:fs';
 import { Readable, Writable } from 'readable-stream';
 import type { Callback } from '../utils.js';
 export declare class ReadStream extends Readable implements Node.ReadStream {

package/dist/emulation/sync.d.ts

@@ -128,6 +128,11 @@ export declare function readdirSync(path: fs.PathLike, options?: (fs.ObjectEncod
     withFileTypes?: false;
     recursive?: boolean;
 }) | BufferEncoding | null): string[] | Buffer[];
+export declare function readdirSync(path: fs.PathLike, options?: {
+    withFileTypes?: boolean;
+    recursive?: boolean;
+    encoding?: BufferEncoding | 'buffer' | null;
+} | BufferEncoding | 'buffer' | null): string[] | Dirent[] | Buffer[];
 export declare function linkSync(targetPath: fs.PathLike, linkPath: fs.PathLike): void;
 /**
  * Synchronous `symlink`.

package/dist/emulation/sync.js

@@ -49,7 +49,7 @@ import { Buffer } from 'buffer';
 import { Errno, ErrnoError } from '../error.js';
 import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import { BigIntStats } from '../stats.js';
-import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
@@ -431,6 +431,7 @@ export function mkdirSync(path, options) {
 }
 mkdirSync;
 export function readdirSync(path, options) {
+    options = typeof options === 'object' ? options : { encoding: options };
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
     let entries;
@@ -454,15 +455,36 @@ export function readdirSync(path, options) {
         }
         entries.push(entry);
     }
-    return entries.map((entry) => {
-        if (typeof options == 'object' && options?.withFileTypes) {
-            return new Dirent(entry, statSync(join(path.toString(), entry)));
+    // Iterate over entries and handle recursive case if needed
+    const values = [];
+    for (const entry of entries) {
+        const fullPath = join(path, entry);
+        const entryStat = statSync(fullPath);
+        if (options?.withFileTypes) {
+            values.push(new Dirent(entry, entryStat));
         }
-        if (options == 'buffer' || (typeof options == 'object' && options?.encoding == 'buffer')) {
-            return Buffer.from(entry);
+        else if (options?.encoding === 'buffer') {
+            values.push(Buffer.from(entry));
         }
-        return entry;
-    });
+        else {
+            values.push(entry);
+        }
+        if (!entryStat.isDirectory() || !options?.recursive)
+            continue;
+        for (const subEntry of readdirSync(fullPath, options)) {
+            if (subEntry instanceof Dirent) {
+                subEntry.path = join(entry, subEntry.path);
+                values.push(subEntry);
+            }
+            else if (Buffer.isBuffer(subEntry)) {
+                values.push(Buffer.from(join(entry, decodeUTF8(subEntry))));
+            }
+            else {
+                values.push(join(entry, subEntry));
+            }
+        }
+    }
+    return values;
 }
 readdirSync;
 // SYMLINK METHODS

package/dist/stats.d.ts

@@ -1,4 +1,4 @@
-import type * as Node from 'fs';
+import type * as Node from 'node:fs';
 import { type Credentials } from './credentials.js';
 import { S_IFDIR, S_IFLNK, S_IFREG } from './emulation/constants.js';
 /**

package/package.json

@@ -1,7 +1,11 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.1.0",
+	"version": "1.1.2",
 	"description": "A filesystem, anywhere",
+	"funding": {
+		"type": "individual",
+		"url": "https://github.com/sponsors/james-pre"
+	},
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"keywords": [

package/src/devices.ts

@@ -1,4 +1,4 @@
-import type { FileReadResult } from 'fs/promises';
+import type { FileReadResult } from 'node:fs/promises';
 import { InMemoryStore } from './backends/memory.js';
 import { StoreFS } from './backends/store/fs.js';
 import { S_IFBLK, S_IFCHR } from './emulation/constants.js';

package/src/emulation/dir.ts

@@ -1,4 +1,4 @@
-import type { Dir as _Dir, Dirent as _Dirent } from 'fs';
+import type { Dir as _Dir, Dirent as _Dirent } from 'node:fs';
 import { Errno, ErrnoError } from '../error.js';
 import type { Stats } from '../stats.js';
 import type { Callback } from '../utils.js';

package/src/emulation/promises.ts

@@ -2,18 +2,16 @@
 import { Buffer } from 'buffer';
 import type * as fs from 'node:fs';
 import type * as promises from 'node:fs/promises';
-import type { CreateReadStreamOptions, CreateWriteStreamOptions, FileChangeInfo, FileReadResult, FlagAndOpenMode } from 'node:fs/promises';
 import type { Stream } from 'node:stream';
-import type { ReadableStream as TReadableStream } from 'node:stream/web';
+import type { ReadableStreamController, ReadableStream as TReadableStream } from 'node:stream/web';
 import type { Interface as ReadlineInterface } from 'readline';
-import type { ReadableStreamController } from 'stream/web';
 import { Errno, ErrnoError } from '../error.js';
 import type { File } from '../file.js';
 import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import type { FileContents } from '../filesystem.js';
 import '../polyfills.js';
 import { BigIntStats, type Stats } from '../stats.js';
-import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
@@ -107,7 +105,7 @@ export class FileHandle implements promises.FileHandle {
 	 * - `mode` defaults to `0o666`.
 	 * - `flag` defaults to `'a'`.
 	 */
-	public async appendFile(data: string | Uint8Array, _options: (fs.ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding = {}): Promise<void> {
+	public async appendFile(data: string | Uint8Array, _options: (fs.ObjectEncodingOptions & promises.FlagAndOpenMode) | BufferEncoding = {}): Promise<void> {
 		const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
 		const flag = parseFlag(options.flag);
 		if (!isAppendable(flag)) {
@@ -129,7 +127,7 @@ export class FileHandle implements promises.FileHandle {
 	 * @param length The number of bytes to read.
 	 * @param position The offset from the beginning of the file from which data should be read. If `null`, data will be read from the current position.
 	 */
-	public read<TBuffer extends NodeJS.ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number | null): Promise<FileReadResult<TBuffer>> {
+	public read<TBuffer extends NodeJS.ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number | null): Promise<promises.FileReadResult<TBuffer>> {
 		if (isNaN(+position!)) {
 			position = this.file.position;
 		}
@@ -143,8 +141,8 @@ export class FileHandle implements promises.FileHandle {
 	 * If a flag is not provided, it defaults to `'r'`.
 	 */
 	public async readFile(_options?: { flag?: fs.OpenMode }): Promise<Buffer>;
-	public async readFile(_options: (fs.ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding): Promise<string>;
-	public async readFile(_options?: (fs.ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding): Promise<string | Buffer> {
+	public async readFile(_options: (fs.ObjectEncodingOptions & promises.FlagAndOpenMode) | BufferEncoding): Promise<string>;
+	public async readFile(_options?: (fs.ObjectEncodingOptions & promises.FlagAndOpenMode) | BufferEncoding): Promise<string | Buffer> {
 		const options = normalizeOptions(_options, null, 'r', 0o444);
 		const flag = parseFlag(options.flag);
 		if (!isReadable(flag)) {
@@ -334,7 +332,7 @@ export class FileHandle implements promises.FileHandle {
 	 * Creates a stream for reading from the file.
 	 * @param options Options for the readable stream
 	 */
-	public createReadStream(options?: CreateReadStreamOptions): ReadStream {
+	public createReadStream(options?: promises.CreateReadStreamOptions): ReadStream {
 		const stream = new ReadStream({
 			highWaterMark: options?.highWaterMark || 64 * 1024,
 			encoding: options!.encoding!,
@@ -359,7 +357,7 @@ export class FileHandle implements promises.FileHandle {
 	 * Creates a stream for writing to the file.
 	 * @param options Options for the writeable stream.
 	 */
-	public createWriteStream(options?: CreateWriteStreamOptions): WriteStream {
+	public createWriteStream(options?: promises.CreateWriteStreamOptions): WriteStream {
 		const streamOptions = {
 			highWaterMark: options?.highWaterMark,
 			encoding: options?.encoding,
@@ -692,22 +690,28 @@ export async function readdir(
 	options?: (fs.ObjectEncodingOptions & { withFileTypes?: false; recursive?: boolean }) | BufferEncoding | null
 ): Promise<string[] | Buffer[]>;
 export async function readdir(path: fs.PathLike, options: fs.ObjectEncodingOptions & { withFileTypes: true; recursive?: boolean }): Promise<Dirent[]>;
+export async function readdir(
+	path: fs.PathLike,
+	options?: { withFileTypes?: boolean; recursive?: boolean; encoding?: BufferEncoding | 'buffer' | null } | BufferEncoding | 'buffer' | null
+): Promise<string[] | Dirent[] | Buffer[]>;
 export async function readdir(
 	path: fs.PathLike,
 	options?: { withFileTypes?: boolean; recursive?: boolean; encoding?: BufferEncoding | 'buffer' | null } | BufferEncoding | 'buffer' | null
 ): Promise<string[] | Dirent[] | Buffer[]> {
+	options = typeof options === 'object' ? options : { encoding: options };
 	path = normalizePath(path);
+
 	if (!(await stat(path)).hasAccess(constants.R_OK)) {
 		throw ErrnoError.With('EACCES', path, 'readdir');
 	}
+
 	path = (await exists(path)) ? await realpath(path) : path;
 	const { fs, path: resolved } = resolveMount(path);
-	let entries: string[];
-	try {
-		entries = await fs.readdir(resolved);
-	} catch (e) {
+
+	const entries = await fs.readdir(resolved).catch((e: Error) => {
 		throw fixError(e as Error, { [resolved]: path });
-	}
+	});
+
 	for (const point of mounts.keys()) {
 		if (point.startsWith(path)) {
 			const entry = point.slice(path.length);
@@ -718,16 +722,41 @@ export async function readdir(
 			entries.push(entry);
 		}
 	}
-	const values: (string | Dirent)[] = [];
+
+	const values: (string | Dirent | Buffer)[] = [];
 	for (const entry of entries) {
-		values.push(typeof options == 'object' && options?.withFileTypes ? new Dirent(entry, await stat(join(path, entry))) : entry);
+		const fullPath = join(path, entry);
+
+		const stats = options?.recursive || options?.withFileTypes ? await stat(fullPath) : null;
+		if (options?.withFileTypes) {
+			values.push(new Dirent(entry, stats!));
+		} else if (options?.encoding === 'buffer') {
+			values.push(Buffer.from(entry));
+		} else {
+			values.push(entry);
+		}
+
+		if (!options?.recursive || !stats?.isDirectory()) {
+			continue;
+		}
+
+		for (const subEntry of await readdir(fullPath, options)) {
+			if (subEntry instanceof Dirent) {
+				subEntry.path = join(entry, subEntry.path);
+				values.push(subEntry);
+			} else if (Buffer.isBuffer(subEntry)) {
+				// Convert Buffer to string, prefix with the full path
+				values.push(Buffer.from(join(entry, decodeUTF8(subEntry))));
+			} else {
+				values.push(join(entry, subEntry));
+			}
+		}
 	}
+
 	return values as string[] | Dirent[];
 }
 readdir satisfies typeof promises.readdir;
 
-// SYMLINK METHODS
-
 export async function link(targetPath: fs.PathLike, linkPath: fs.PathLike): Promise<void> {
 	targetPath = normalizePath(targetPath);
 	if (!(await stat(dirname(targetPath))).hasAccess(constants.R_OK)) {
@@ -856,28 +885,38 @@ export async function realpath(path: fs.PathLike, options?: fs.EncodingOption |
 }
 realpath satisfies typeof promises.realpath;
 
-export function watch(filename: fs.PathLike, options?: fs.WatchOptions | BufferEncoding): AsyncIterable<FileChangeInfo<string>>;
-export function watch(filename: fs.PathLike, options: fs.WatchOptions | fs.BufferEncodingOption): AsyncIterable<FileChangeInfo<Buffer>>;
-export function watch(filename: fs.PathLike, options?: fs.WatchOptions | string): AsyncIterable<FileChangeInfo<string>> | AsyncIterable<FileChangeInfo<Buffer>>;
-export function watch<T extends string | Buffer>(filename: fs.PathLike, options: fs.WatchOptions | string = {}): AsyncIterable<FileChangeInfo<T>> {
+export function watch(filename: fs.PathLike, options?: fs.WatchOptions | BufferEncoding): AsyncIterable<promises.FileChangeInfo<string>>;
+export function watch(filename: fs.PathLike, options: fs.WatchOptions | fs.BufferEncodingOption): AsyncIterable<promises.FileChangeInfo<Buffer>>;
+export function watch(filename: fs.PathLike, options?: fs.WatchOptions | string): AsyncIterable<promises.FileChangeInfo<string>> | AsyncIterable<promises.FileChangeInfo<Buffer>>;
+export function watch<T extends string | Buffer>(filename: fs.PathLike, options: fs.WatchOptions | string = {}): AsyncIterable<promises.FileChangeInfo<T>> {
 	return {
-		[Symbol.asyncIterator](): AsyncIterator<FileChangeInfo<T>> {
-			const watcher = new FSWatcher<T>(filename.toString(), typeof options != 'string' ? options : { encoding: options as BufferEncoding | 'buffer' });
-
-			function withDone(done: boolean) {
-				return function () {
-					const event = Promise.withResolvers<IteratorResult<FileChangeInfo<T>>>();
-					watcher.on('change', (eventType, filename) => {
-						event.resolve({ value: { eventType, filename }, done });
-					});
-					return event.promise;
-				};
+		[Symbol.asyncIterator](): AsyncIterator<promises.FileChangeInfo<T>> {
+			const watcher = new FSWatcher<T>(filename.toString(), typeof options !== 'string' ? options : { encoding: options as BufferEncoding | 'buffer' });
+
+			// A queue to hold change events, since we need to resolve them in the async iterator
+			const eventQueue: ((value: IteratorResult<promises.FileChangeInfo<T>>) => void)[] = [];
+
+			watcher.on('change', (eventType: promises.FileChangeInfo<T>['eventType'], filename: T) => {
+				eventQueue.shift()?.({ value: { eventType, filename }, done: false });
+			});
+
+			function cleanup() {
+				watcher.close();
+				for (const resolve of eventQueue) {
+					resolve({ value: null, done: true });
+				}
+				eventQueue.length = 0; // Clear the queue
+				return Promise.resolve({ value: null, done: true as const });
 			}
 
 			return {
-				next: withDone(false),
-				return: withDone(true),
-				throw: withDone(true),
+				async next() {
+					const { promise, resolve } = Promise.withResolvers<IteratorResult<promises.FileChangeInfo<T>>>();
+					eventQueue.push(resolve);
+					return promise;
+				},
+				return: cleanup,
+				throw: cleanup,
 			};
 		},
 	};

package/src/emulation/streams.ts

@@ -1,4 +1,4 @@
-import type * as Node from 'fs';
+import type * as Node from 'node:fs';
 import { Readable, Writable } from 'readable-stream';
 import type { Callback } from '../utils.js';
 import { ErrnoError, Errno } from '../error.js';

package/src/emulation/sync.ts

@@ -5,7 +5,7 @@ import type { File } from '../file.js';
 import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
 import type { FileContents } from '../filesystem.js';
 import { BigIntStats, type Stats } from '../stats.js';
-import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
@@ -437,10 +437,15 @@ export function readdirSync(path: fs.PathLike, options?: { recursive?: boolean;
 export function readdirSync(path: fs.PathLike, options: { recursive?: boolean; encoding: 'buffer'; withFileTypes?: false } | 'buffer'): Buffer[];
 export function readdirSync(path: fs.PathLike, options: { recursive?: boolean; withFileTypes: true }): Dirent[];
 export function readdirSync(path: fs.PathLike, options?: (fs.ObjectEncodingOptions & { withFileTypes?: false; recursive?: boolean }) | BufferEncoding | null): string[] | Buffer[];
+export function readdirSync(
+	path: fs.PathLike,
+	options?: { withFileTypes?: boolean; recursive?: boolean; encoding?: BufferEncoding | 'buffer' | null } | BufferEncoding | 'buffer' | null
+): string[] | Dirent[] | Buffer[];
 export function readdirSync(
 	path: fs.PathLike,
 	options?: { recursive?: boolean; encoding?: BufferEncoding | 'buffer' | null; withFileTypes?: boolean } | BufferEncoding | 'buffer' | null
 ): string[] | Dirent[] | Buffer[] {
+	options = typeof options === 'object' ? options : { encoding: options };
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
 	let entries: string[];
@@ -452,6 +457,7 @@ export function readdirSync(
 	} catch (e) {
 		throw fixError(e as Error, { [resolved]: path });
 	}
+
 	for (const mount of mounts.keys()) {
 		if (!mount.startsWith(path)) {
 			continue;
@@ -463,17 +469,35 @@ export function readdirSync(
 		}
 		entries.push(entry);
 	}
-	return entries.map((entry: string) => {
-		if (typeof options == 'object' && options?.withFileTypes) {
-			return new Dirent(entry, statSync(join(path.toString(), entry)));
-		}
 
-		if (options == 'buffer' || (typeof options == 'object' && options?.encoding == 'buffer')) {
-			return Buffer.from(entry);
+	// Iterate over entries and handle recursive case if needed
+	const values: (string | Dirent | Buffer)[] = [];
+	for (const entry of entries) {
+		const fullPath = join(path, entry);
+		const entryStat = statSync(fullPath);
+
+		if (options?.withFileTypes) {
+			values.push(new Dirent(entry, entryStat));
+		} else if (options?.encoding === 'buffer') {
+			values.push(Buffer.from(entry));
+		} else {
+			values.push(entry);
+		}
+		if (!entryStat.isDirectory() || !options?.recursive) continue;
+
+		for (const subEntry of readdirSync(fullPath, options)) {
+			if (subEntry instanceof Dirent) {
+				subEntry.path = join(entry, subEntry.path);
+				values.push(subEntry);
+			} else if (Buffer.isBuffer(subEntry)) {
+				values.push(Buffer.from(join(entry, decodeUTF8(subEntry))));
+			} else {
+				values.push(join(entry, subEntry));
+			}
 		}
+	}
 
-		return entry;
-	}) as string[] | Dirent[] | Buffer[];
+	return values as string[] | Dirent[] | Buffer[];
 }
 readdirSync satisfies typeof fs.readdirSync;
 

package/src/stats.ts

@@ -1,4 +1,4 @@
-import type * as Node from 'fs';
+import type * as Node from 'node:fs';
 import { credentials, type Credentials } from './credentials.js';
 import { S_IFBLK, S_IFCHR, S_IFDIR, S_IFIFO, S_IFLNK, S_IFMT, S_IFREG, S_IFSOCK, S_IRWXG, S_IRWXO, S_IRWXU, size_max } from './emulation/constants.js';