@zenfs/core 1.1.6 → 1.2.1

package/dist/backends/file_index.js

@@ -151,9 +151,6 @@ export class IndexFS extends Readonly(FileSystem) {
         if (!stats) {
             throw ErrnoError.With('ENOENT', path, 'readdir');
         }
-        if (!stats.isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', path, 'readdir');
-        }
         const content = JSON.parse(decodeUTF8(stats.fileData));
         if (!Array.isArray(content)) {
             throw ErrnoError.With('ENODATA', path, 'readdir');

package/dist/backends/overlay.js

@@ -314,10 +314,6 @@ export class UnmutexedOverlayFS extends FileSystem {
     }
     async readdir(path) {
         this.checkInitialized();
-        const dirStats = await this.stat(path);
-        if (!dirStats.isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', path, 'readdir');
-        }
         // Readdir in both, check delete log on RO file system's listing, merge, return.
         const contents = [];
         try {
@@ -341,10 +337,6 @@ export class UnmutexedOverlayFS extends FileSystem {
     }
     readdirSync(path) {
         this.checkInitialized();
-        const dirStats = this.statSync(path);
-        if (!dirStats.isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', path, 'readdir');
-        }
         // Readdir in both, check delete log on RO file system's listing, merge, return.
         let contents = [];
         try {

package/dist/backends/store/fs.js

@@ -580,16 +580,12 @@ export class StoreFS extends FileSystem {
      * listing.
      */
     async getDirListing(tx, inode, path) {
-        if (!inode.toStats().isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', path, 'getDirListing');
-        }
         const data = await tx.get(inode.ino);
+        /*
+            Occurs when data is undefined,or corresponds to something other than a directory listing.
+            The latter should never occur unless the file system is corrupted.
+         */
         if (!data) {
-            /*
-                Occurs when data is undefined, or corresponds to something other
-                than a directory listing. The latter should never occur unless
-                the file system is corrupted.
-             */
             throw ErrnoError.With('ENOENT', path, 'getDirListing');
         }
         return decodeDirListing(data);
@@ -598,9 +594,6 @@ export class StoreFS extends FileSystem {
      * Given the Inode of a directory, retrieves the corresponding directory listing.
      */
     getDirListingSync(tx, inode, p) {
-        if (!inode.toStats().isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', p, 'getDirListing');
-        }
         const data = tx.getSync(inode.ino);
         if (!data) {
             throw ErrnoError.With('ENOENT', p, 'getDirListing');
@@ -758,9 +751,6 @@ export class StoreFS extends FileSystem {
             if (!isDir && fileNode.toStats().isDirectory()) {
                 throw ErrnoError.With('EISDIR', path, 'remove');
             }
-            if (isDir && !fileNode.toStats().isDirectory()) {
-                throw ErrnoError.With('ENOTDIR', path, 'remove');
-            }
             await tx.set(parentNode.ino, encodeDirListing(listing));
             if (--fileNode.nlink < 1) {
                 // remove file
@@ -801,9 +791,6 @@ export class StoreFS extends FileSystem {
             if (!isDir && fileNode.toStats().isDirectory()) {
                 throw ErrnoError.With('EISDIR', path, 'remove');
             }
-            if (isDir && !fileNode.toStats().isDirectory()) {
-                throw ErrnoError.With('ENOTDIR', path, 'remove');
-            }
             // Update directory listing.
             tx.setSync(parentNode.ino, encodeDirListing(listing));
             if (--fileNode.nlink < 1) {

package/dist/config.d.ts

@@ -34,10 +34,33 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
     gid: number;
     /**
      * Whether to automatically add normal Linux devices
-     * @default false
      * @experimental
+     * @default false
      */
     addDevices: boolean;
+    /**
+     * If true, enables caching stats for certain operations.
+     * This should reduce the number of stat calls performed.
+     * @experimental
+     * @default false
+     */
+    cacheStats: boolean;
+    /**
+     * If true, disables *all* permissions checking.
+     *
+     * This can increase performance.
+     * @experimental
+     * @default false
+     */
+    disableAccessChecks: boolean;
+    /**
+     * If true, disables `read` and `readSync` from immediately syncing the updated atime to the file system.
+     *
+     * This can increase performance.
+     * @experimental
+     * @default false
+     */
+    disableSyncOnRead: boolean;
 }
 /**
  * Configures ZenFS with single mount point /

package/dist/config.js

@@ -1,7 +1,9 @@
 import { checkOptions, isBackend, isBackendConfig } from './backends/backend.js';
 import { credentials } from './credentials.js';
 import { DeviceFS, fullDevice, nullDevice, randomDevice, zeroDevice } from './devices.js';
+import * as cache from './emulation/cache.js';
 import * as fs from './emulation/index.js';
+import { config } from './emulation/config.js';
 import { Errno, ErrnoError } from './error.js';
 import { FileSystem } from './filesystem.js';
 function isMountConfig(arg) {
@@ -66,6 +68,9 @@ export async function configure(configuration) {
     const uid = 'uid' in configuration ? configuration.uid || 0 : 0;
     const gid = 'gid' in configuration ? configuration.gid || 0 : 0;
     Object.assign(credentials, { uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
+    cache.setEnabled(configuration.cacheStats ?? false);
+    config.checkAccess = !configuration.disableAccessChecks;
+    config.syncOnRead = !configuration.disableSyncOnRead;
     if (configuration.addDevices) {
         const devfs = new DeviceFS();
         devfs.createDevice('/null', nullDevice);

package/dist/devices.js

@@ -254,15 +254,9 @@ export class DeviceFS extends StoreFS {
         return super.unlinkSync(path);
     }
     async rmdir(path) {
-        if (this.devices.has(path)) {
-            throw ErrnoError.With('ENOTDIR', path, 'rmdir');
-        }
         return super.rmdir(path);
     }
     rmdirSync(path) {
-        if (this.devices.has(path)) {
-            throw ErrnoError.With('ENOTDIR', path, 'rmdir');
-        }
         return super.rmdirSync(path);
     }
     async mkdir(path, mode) {
@@ -278,9 +272,6 @@ export class DeviceFS extends StoreFS {
         return super.mkdirSync(path, mode);
     }
     async readdir(path) {
-        if (this.devices.has(path)) {
-            throw ErrnoError.With('ENOTDIR', path, 'readdir');
-        }
         const entries = await super.readdir(path);
         for (const dev of this.devices.keys()) {
             if (dirname(dev) == path) {
@@ -290,9 +281,6 @@ export class DeviceFS extends StoreFS {
         return entries;
     }
     readdirSync(path) {
-        if (this.devices.has(path)) {
-            throw ErrnoError.With('ENOTDIR', path, 'readdirSync');
-        }
         const entries = super.readdirSync(path);
         for (const dev of this.devices.keys()) {
             if (dirname(dev) == path) {

package/dist/emulation/cache.d.ts

@@ -0,0 +1,21 @@
+import type { Stats } from '../stats.js';
+/**
+ * Whether the cache is enabled
+ */
+export declare let isEnabled: boolean;
+/**
+ * Sets whether the cache is enabled or not
+ */
+export declare function setEnabled(value: boolean): void;
+/**
+ * Gets stats from the cache, if they exist and the cache is enabled.
+ */
+export declare function getStats(path: string): Stats | undefined;
+/**
+ * Adds stats if the cache is enabled
+ */
+export declare function setStats(path: string, value: Stats): void;
+/**
+ * Clears the cache if it is enabled
+ */
+export declare function clearStats(): void;

package/dist/emulation/cache.js

@@ -0,0 +1,36 @@
+/* Experimental caching */
+/**
+ * Whether the cache is enabled
+ */
+export let isEnabled = false;
+/**
+ * Sets whether the cache is enabled or not
+ */
+export function setEnabled(value) {
+    isEnabled = value;
+}
+const stats = new Map();
+/**
+ * Gets stats from the cache, if they exist and the cache is enabled.
+ */
+export function getStats(path) {
+    if (!isEnabled)
+        return;
+    return stats.get(path);
+}
+/**
+ * Adds stats if the cache is enabled
+ */
+export function setStats(path, value) {
+    if (!isEnabled)
+        return;
+    stats.set(path, value);
+}
+/**
+ * Clears the cache if it is enabled
+ */
+export function clearStats() {
+    if (!isEnabled)
+        return;
+    stats.clear();
+}

package/dist/emulation/config.d.ts

@@ -0,0 +1,10 @@
+export declare const config: {
+    /**
+     * Whether to perform access checks
+     */
+    checkAccess: boolean;
+    /**
+     * Whether to sync atime updates immediately when reading from a file
+     */
+    syncOnRead: boolean;
+};

package/dist/emulation/config.js

@@ -0,0 +1,10 @@
+export const config = {
+    /**
+     * Whether to perform access checks
+     */
+    checkAccess: true,
+    /**
+     * Whether to sync atime updates immediately when reading from a file
+     */
+    syncOnRead: true,
+};

package/dist/emulation/promises.d.ts

@@ -9,6 +9,7 @@ import type { FileContents } from '../filesystem.js';
 import '../polyfills.js';
 import { BigIntStats, type Stats } from '../stats.js';
 import { Dir, Dirent } from './dir.js';
+import { type InternalOptions, type ReaddirOptions } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
 export declare class FileHandle implements promises.FileHandle {
@@ -248,30 +249,24 @@ export declare function mkdir(path: fs.PathLike, options?: fs.Mode | (fs.MakeDir
 export declare function mkdir(path: fs.PathLike, options?: fs.Mode | fs.MakeDirectoryOptions | null): Promise<string | undefined>;
 /**
  * Asynchronous readdir(3) - read a directory.
+ *
+ * Note: The order of entries is not guaranteed
  * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
  * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'`.
  */
-export declare function readdir(path: fs.PathLike, options?: (fs.ObjectEncodingOptions & {
+export declare function readdir(path: fs.PathLike, options?: (fs.ObjectEncodingOptions & ReaddirOptions & {
     withFileTypes?: false;
-    recursive?: boolean;
 }) | BufferEncoding | null): Promise<string[]>;
-export declare function readdir(path: fs.PathLike, options: fs.BufferEncodingOption & {
+export declare function readdir(path: fs.PathLike, options: fs.BufferEncodingOption & ReaddirOptions & {
     withFileTypes?: false;
-    recursive?: boolean;
 }): Promise<Buffer[]>;
-export declare function readdir(path: fs.PathLike, options?: (fs.ObjectEncodingOptions & {
+export declare function readdir(path: fs.PathLike, options?: (fs.ObjectEncodingOptions & ReaddirOptions & {
     withFileTypes?: false;
-    recursive?: boolean;
 }) | BufferEncoding | null): Promise<string[] | Buffer[]>;
-export declare function readdir(path: fs.PathLike, options: fs.ObjectEncodingOptions & {
+export declare function readdir(path: fs.PathLike, options: fs.ObjectEncodingOptions & ReaddirOptions & {
     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 readdir(path: fs.PathLike, options?: (ReaddirOptions & (fs.ObjectEncodingOptions | fs.BufferEncodingOption)) | BufferEncoding | null): Promise<string[] | Dirent[] | Buffer[]>;
 export declare function link(targetPath: fs.PathLike, linkPath: fs.PathLike): Promise<void>;
 /**
  * `symlink`.
@@ -311,7 +306,7 @@ export declare function access(path: fs.PathLike, mode?: number): Promise<void>;
  * Asynchronous `rm`. Removes files or directories (recursively).
  * @param path The path to the file or directory to remove.
  */
-export declare function rm(path: fs.PathLike, options?: fs.RmOptions): Promise<void>;
+export declare function rm(path: fs.PathLike, options?: fs.RmOptions & InternalOptions): Promise<void>;
 /**
  * Asynchronous `mkdtemp`. Creates a unique temporary directory.
  * @param prefix The directory prefix.

package/dist/emulation/promises.js

@@ -52,10 +52,12 @@ import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWrit
 import '../polyfills.js';
 import { BigIntStats } from '../stats.js';
 import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import * as cache from './cache.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
 import { _statfs, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
+import { config } from './config.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher, emitChange } from './watchers.js';
 export * as constants from './constants.js';
@@ -217,7 +219,7 @@ export class FileHandle {
     }
     async stat(opts) {
         const stats = await this.file.stat();
-        if (!stats.hasAccess(constants.R_OK)) {
+        if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
             throw ErrnoError.With('EACCES', this.file.path, 'stat');
         }
         return opts?.bigint ? new BigIntStats(stats) : stats;
@@ -351,7 +353,7 @@ export async function rename(oldPath, newPath) {
     newPath = normalizePath(newPath);
     const src = resolveMount(oldPath);
     const dst = resolveMount(newPath);
-    if (!(await stat(dirname(oldPath))).hasAccess(constants.W_OK)) {
+    if (config.checkAccess && !(await stat(dirname(oldPath))).hasAccess(constants.W_OK)) {
         throw ErrnoError.With('EACCES', oldPath, 'rename');
     }
     try {
@@ -389,7 +391,7 @@ export async function stat(path, options) {
     const { fs, path: resolved } = resolveMount(await realpath(path));
     try {
         const stats = await fs.stat(resolved);
-        if (!stats.hasAccess(constants.R_OK)) {
+        if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'stat');
         }
         return options?.bigint ? new BigIntStats(stats) : stats;
@@ -433,7 +435,7 @@ export async function unlink(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (!(await fs.stat(resolved)).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(cache.getStats(path) || (await fs.stat(resolved))).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         await fs.unlink(resolved);
@@ -460,7 +462,7 @@ async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
         }
         // Create the file
         const parentStats = await fs.stat(dirname(resolved));
-        if (!parentStats.hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !parentStats.hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', dirname(path), '_open');
         }
         if (!parentStats.isDirectory()) {
@@ -468,7 +470,7 @@ async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
         }
         return new FileHandle(await fs.createFile(resolved, flag, mode));
     }
-    if (!stats.hasAccess(flagToMode(flag))) {
+    if (config.checkAccess && !stats.hasAccess(flagToMode(flag))) {
         throw ErrnoError.With('EACCES', path, '_open');
     }
     if (isExclusive(flag)) {
@@ -579,11 +581,14 @@ export async function appendFile(path, data, _options) {
 appendFile;
 // DIRECTORY-ONLY METHODS
 export async function rmdir(path) {
-    path = normalizePath(path);
     path = await realpath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (!(await fs.stat(resolved)).hasAccess(constants.W_OK)) {
+        const stats = cache.getStats(path) || (await fs.stat(resolved));
+        if (!stats.isDirectory()) {
+            throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
+        }
+        if (config.checkAccess && !stats.hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'rmdir');
         }
         await fs.rmdir(resolved);
@@ -597,12 +602,12 @@ rmdir;
 export async function mkdir(path, options) {
     options = typeof options === 'object' ? options : { mode: options };
     const mode = normalizeMode(options?.mode, 0o777);
-    path = await realpath(normalizePath(path));
+    path = await realpath(path);
     const { fs, path: resolved } = resolveMount(path);
     const errorPaths = { [resolved]: path };
     try {
         if (!options?.recursive) {
-            if (!(await fs.stat(dirname(resolved))).hasAccess(constants.W_OK)) {
+            if (config.checkAccess && !(await fs.stat(dirname(resolved))).hasAccess(constants.W_OK)) {
                 throw ErrnoError.With('EACCES', dirname(resolved), 'mkdir');
             }
             await fs.mkdir(resolved, mode);
@@ -615,7 +620,7 @@ export async function mkdir(path, options) {
             errorPaths[dir] = origDir;
         }
         for (const dir of dirs) {
-            if (!(await fs.stat(dirname(dir))).hasAccess(constants.W_OK)) {
+            if (config.checkAccess && !(await fs.stat(dirname(dir))).hasAccess(constants.W_OK)) {
                 throw ErrnoError.With('EACCES', dirname(dir), 'mkdir');
             }
             await fs.mkdir(dir, mode);
@@ -630,14 +635,20 @@ export async function mkdir(path, options) {
 mkdir;
 export async function readdir(path, options) {
     options = typeof options === 'object' ? options : { encoding: options };
-    path = await realpath(normalizePath(path));
+    path = await realpath(path);
+    const handleError = (e) => {
+        throw fixError(e, { [resolved]: path });
+    };
     const { fs, path: resolved } = resolveMount(path);
-    if (!(await fs.stat(resolved)).hasAccess(constants.R_OK)) {
+    const stats = cache.getStats(path) || (await fs.stat(resolved).catch(handleError));
+    cache.setStats(path, stats);
+    if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
         throw ErrnoError.With('EACCES', path, 'readdir');
     }
-    const entries = await fs.readdir(resolved).catch((e) => {
-        throw fixError(e, { [resolved]: path });
-    });
+    if (!stats.isDirectory()) {
+        throw ErrnoError.With('ENOTDIR', path, 'readdir');
+    }
+    const entries = await fs.readdir(resolved).catch(handleError);
     for (const point of mounts.keys()) {
         if (point.startsWith(path)) {
             const entry = point.slice(path.length);
@@ -649,26 +660,24 @@ export async function readdir(path, options) {
         }
     }
     const values = [];
-    for (const entry of entries) {
-        let stats;
+    const addEntry = async (entry) => {
+        let entryStats;
         if (options?.recursive || options?.withFileTypes) {
-            stats = await fs.stat(join(resolved, entry)).catch((error) => {
-                throw fixError(error, { [resolved]: path });
-            });
+            entryStats = cache.getStats(join(path, entry)) || (await fs.stat(join(resolved, entry)).catch(handleError));
+            cache.setStats(join(path, entry), entryStats);
         }
         if (options?.withFileTypes) {
-            values.push(new Dirent(entry, stats));
+            values.push(new Dirent(entry, entryStats));
         }
-        else if (options?.encoding === 'buffer') {
+        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(join(path, entry), options)) {
+        if (!options?.recursive || !entryStats?.isDirectory())
+            return;
+        for (const subEntry of await readdir(join(path, entry), { ...options, _isIndirect: true })) {
             if (subEntry instanceof Dirent) {
                 subEntry.path = join(entry, subEntry.path);
                 values.push(subEntry);
@@ -681,26 +690,30 @@ export async function readdir(path, options) {
                 values.push(join(entry, subEntry));
             }
         }
+    };
+    await Promise.all(entries.map(addEntry));
+    if (!options?._isIndirect) {
+        cache.clearStats();
     }
     return values;
 }
 readdir;
 export async function link(targetPath, linkPath) {
     targetPath = normalizePath(targetPath);
-    if (!(await stat(dirname(targetPath))).hasAccess(constants.R_OK)) {
-        throw ErrnoError.With('EACCES', dirname(targetPath), 'link');
-    }
     linkPath = normalizePath(linkPath);
-    if (!(await stat(dirname(linkPath))).hasAccess(constants.W_OK)) {
-        throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
-    }
     const { fs, path } = resolveMount(targetPath);
     const link = resolveMount(linkPath);
     if (fs != link.fs) {
         throw ErrnoError.With('EXDEV', linkPath, 'link');
     }
     try {
-        if (!(await fs.stat(path)).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(await fs.stat(dirname(targetPath))).hasAccess(constants.R_OK)) {
+            throw ErrnoError.With('EACCES', dirname(path), 'link');
+        }
+        if (config.checkAccess && !(await stat(dirname(linkPath))).hasAccess(constants.W_OK)) {
+            throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
+        }
+        if (config.checkAccess && !(await fs.stat(path)).hasAccess(constants.W_OK | constants.R_OK)) {
             throw ErrnoError.With('EACCES', path, 'link');
         }
         return await fs.link(path, link.path);
@@ -907,6 +920,8 @@ export function watch(filename, options = {}) {
 }
 watch;
 export async function access(path, mode = constants.F_OK) {
+    if (!config.checkAccess)
+        return;
     const stats = await stat(path);
     if (!stats.hasAccess(mode)) {
         throw new ErrnoError(Errno.EACCES);
@@ -919,33 +934,39 @@ access;
  */
 export async function rm(path, options) {
     path = normalizePath(path);
-    const stats = await stat(path).catch((error) => {
-        if (error.code != 'ENOENT' || !options?.force)
-            throw error;
-    });
+    const stats = cache.getStats(path) ||
+        (await stat(path).catch((error) => {
+            if (error.code != 'ENOENT' || !options?.force)
+                throw error;
+        }));
     if (!stats) {
         return;
     }
+    cache.setStats(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options?.recursive) {
-                for (const entry of await readdir(path)) {
-                    await rm(join(path, entry), options);
+                for (const entry of await readdir(path, { _isIndirect: true })) {
+                    await rm(join(path, entry), { ...options, _isIndirect: true });
                 }
             }
             await rmdir(path);
-            return;
+            break;
         case constants.S_IFREG:
         case constants.S_IFLNK:
             await unlink(path);
-            return;
+            break;
         case constants.S_IFBLK:
         case constants.S_IFCHR:
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
+            cache.clearStats();
             throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
     }
+    if (!options?._isIndirect) {
+        cache.clearStats();
+    }
 }
 rm;
 export async function mkdtemp(prefix, options) {
@@ -1005,18 +1026,21 @@ export async function cp(source, destination, opts) {
         throw new ErrnoError(Errno.EEXIST, 'Destination file or directory already exists.', destination, 'cp');
     }
     switch (srcStats.mode & constants.S_IFMT) {
-        case constants.S_IFDIR:
+        case constants.S_IFDIR: {
             if (!opts?.recursive) {
                 throw new ErrnoError(Errno.EISDIR, source + ' is a directory (not copied)', source, 'cp');
             }
-            await mkdir(destination, { recursive: true }); // Ensure the destination directory exists
-            for (const dirent of await readdir(source, { withFileTypes: true })) {
+            const [entries] = await Promise.all([readdir(source, { withFileTypes: true }), mkdir(destination, { recursive: true })] // Ensure the destination directory exists
+            );
+            const _cp = async (dirent) => {
                 if (opts.filter && !opts.filter(join(source, dirent.name), join(destination, dirent.name))) {
-                    continue; // Skip if the filter returns false
+                    return; // Skip if the filter returns false
                 }
                 await cp(join(source, dirent.name), join(destination, dirent.name), opts);
-            }
+            };
+            await Promise.all(entries.map(_cp));
             break;
+        }
         case constants.S_IFREG:
         case constants.S_IFLNK:
             await copyFile(source, destination);

package/dist/emulation/shared.d.ts

@@ -43,3 +43,19 @@ export declare function mountObject(mounts: MountObject): void;
  * @hidden
  */
 export declare function _statfs<const T extends boolean>(fs: FileSystem, bigint?: T): T extends true ? BigIntStatsFs : StatsFs;
+/**
+ * Options used for caching, among other things.
+ * @internal *UNSTABLE*
+ */
+export interface InternalOptions {
+    /**
+     * If true, then this readdir was called from another function.
+     * In this case, don't clear the cache when done.
+     * @internal *UNSTABLE*
+     */
+    _isIndirect?: boolean;
+}
+export interface ReaddirOptions extends InternalOptions {
+    withFileTypes?: boolean;
+    recursive?: boolean;
+}