@poe-platform/safe-fs 0.1.70 → 0.1.72

package/dist/safe-fs/contracts/filesystem.d.ts

@@ -61,6 +61,16 @@ export interface FsOptions {
 export interface ReadFileOptions extends FsOptions {
     readonly maxBytes?: number;
 }
+export interface ReadDirectoryOptions extends FsOptions {
+    /**
+     * Optional per-listing entry admission limit, a nonnegative safe integer.
+     * Zero permits an empty listing; overflow rejects with EFBIG, never truncates.
+     * Omission preserves the adapter's existing limits and ordering. Composed
+     * adapters may conservatively count distinct candidates before visibility
+     * filtering. This is not a global traversal, host-allocation or work quota.
+     */
+    readonly maxEntries?: number;
+}
 export interface WriteFileOptions extends FsOptions {
     readonly flag?: "w" | "wx" | "a" | "ax";
     readonly mode?: number;
@@ -93,7 +103,7 @@ export interface FileSystem {
     stat(path: string, options?: FsOptions): Promise<FileStat>;
     lstat(path: string, options?: FsOptions): Promise<FileStat>;
     compareEntry?(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<EntryComparison>;
-    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    readdir(path: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
     mkdir(path: string, options?: MkdirOptions): Promise<void>;
     rm(path: string, options?: RemoveOptions): Promise<void>;
     rmdir?(path: string, options?: FsOptions): Promise<void>;

package/dist/safe-fs/fs/directory-admission.d.ts

@@ -0,0 +1,3 @@
+import type { ReadDirectoryOptions } from "../contracts/filesystem.js";
+export declare function directoryEntryLimit(options: ReadDirectoryOptions, path: string): number | undefined;
+export declare function admitDirectoryEntries(count: number, limit: number | undefined, path: string): void;

package/dist/safe-fs/fs/directory-admission.js

@@ -0,0 +1,14 @@
+import { FsError } from "../contracts/errors.js";
+export function directoryEntryLimit(options, path) {
+    options.signal?.throwIfAborted();
+    const limit = options.maxEntries;
+    if (limit !== undefined && (!Number.isSafeInteger(limit) || limit < 0)) {
+        throw new FsError("EINVAL", { syscall: "readdir", path, message: "directory entry limit must be a nonnegative safe integer" });
+    }
+    return limit;
+}
+export function admitDirectoryEntries(count, limit, path) {
+    if (limit !== undefined && count > limit) {
+        throw new FsError("EFBIG", { syscall: "readdir", path, message: "directory entry limit exceeded" });
+    }
+}

package/dist/safe-fs/fs/memory/index.d.ts

@@ -1,4 +1,4 @@
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 import type { ByteSource } from "../../contracts/io.js";
 export declare class MemoryFileSystem implements FileSystem {
     readonly capabilities: Readonly<{
@@ -60,7 +60,7 @@ export declare class MemoryFileSystem implements FileSystem {
     appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
     stat(path: string, options?: FsOptions): Promise<FileStat>;
     lstat(path: string, options?: FsOptions): Promise<FileStat>;
-    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    readdir(path: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
     mkdir(path: string, options?: MkdirOptions): Promise<void>;
     rmdir(path: string, options?: FsOptions): Promise<void>;
     rm(path: string, options?: RemoveOptions): Promise<void>;

package/dist/safe-fs/fs/memory/index.js

@@ -2,6 +2,7 @@ import { FsError } from "../../contracts/errors.js";
 import { assertCallbackAuthorityAllowed, compareEntries, registerEntryAuthority } from "../mount/comparison.js";
 import { getOwnedS3Entry } from "../s3/registry.js";
 import { getOwnedWebDavEntry } from "../webdav/resource-id.js";
+import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
 const typeModes = { file: 0o100000, directory: 0o040000, symlink: 0o120000 };
 const ownedStats = new WeakMap();
 const ownedStores = new WeakMap();
@@ -285,11 +286,12 @@ export class MemoryFileSystem {
         return stat;
     }
     async readdir(path, options = {}) {
-        options.signal?.throwIfAborted();
+        const limit = directoryEntryLimit(options, path);
         const node = this.resolve(path, "readdir").node;
         if (node.type !== "directory")
             this.fail("ENOTDIR", "readdir", path);
         this.permission(node, 4, "readdir", path);
+        admitDirectoryEntries(node.entries.size, limit, path);
         node.atimeMs = Date.now();
         return [...node.entries].map(([name, entry]) => ({ name, type: entry.type }))
             .sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);

package/dist/safe-fs/fs/mount/index.d.ts

@@ -1,4 +1,4 @@
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 import type { ByteSource } from "../../contracts/io.js";
 export interface MountFileSystemOptions {
     readonly root: FileSystem;
@@ -24,7 +24,7 @@ export declare class MountFileSystem implements FileSystem {
     appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
     stat(path: string, options?: FsOptions): Promise<FileStat>;
     lstat(path: string, options?: FsOptions): Promise<FileStat>;
-    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    readdir(path: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
     mkdir(path: string, options?: MkdirOptions): Promise<void>;
     rmdir(path: string, options?: FsOptions): Promise<void>;
     rm(path: string, options?: RemoveOptions): Promise<void>;

package/dist/safe-fs/fs/mount/index.js

@@ -2,6 +2,7 @@ import { FsError, isFsError, toFsError } from "../../contracts/errors.js";
 import { readBytes } from "../../contracts/io.js";
 import { finishCleanup } from "../../contracts/cleanup.js";
 import { readOnlyCapabilities } from "../capabilities.js";
+import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
 import { normalizePath, validatePath } from "../../contracts/virtual-path.js";
 import { compareIdentity } from "./identity.js";
 import { compareEntries, registerEntryAuthority, registerEntryView } from "./comparison.js";
@@ -338,15 +339,22 @@ export class MountFileSystem {
     }
     readdir(path, options = {}) {
         return this.operation("readdir", path, options, async () => {
+            const limit = directoryEntryLimit(options, path);
             const location = await this.resolve(path, options);
             if (location.stat?.type !== "directory")
                 fail("ENOTDIR");
             const entries = new Map();
             if (!location.synthetic) {
-                for (const entry of await location.mount.backend.readdir(location.local, options)) {
+                const children = await location.mount.backend.readdir(location.local, options);
+                options.signal?.throwIfAborted();
+                admitDirectoryEntries(children.length, limit, path);
+                for (const entry of children) {
+                    options.signal?.throwIfAborted();
                     const { name, type } = entry;
                     if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\0"))
                         fail("EIO");
+                    if (!entries.has(name))
+                        admitDirectoryEntries(entries.size + 1, limit, path);
                     entries.set(name, { name, type });
                 }
             }
@@ -354,6 +362,8 @@ export class MountFileSystem {
                 if (mount.path !== location.path && within(location.path, mount.path)) {
                     const suffix = mount.path.slice(location.path === "/" ? 1 : location.path.length + 1);
                     const name = suffix.split("/")[0];
+                    if (!entries.has(name))
+                        admitDirectoryEntries(entries.size + 1, limit, path);
                     entries.set(name, { name, type: "directory" });
                 }
             }

package/dist/safe-fs/fs/overlay/index.d.ts

@@ -1,5 +1,5 @@
 import type { ByteSource } from "../../contracts/io.js";
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 export interface OverlayFileSystemOptions {
     readonly upper: FileSystem;
     readonly lower: FileSystem;
@@ -49,7 +49,7 @@ export declare class OverlayFileSystem implements FileSystem {
     stat(path: string, options?: FsOptions): Promise<FileStat>;
     lstat(path: string, options?: FsOptions): Promise<FileStat>;
     compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<import("../../contracts/filesystem.js").EntryComparison>;
-    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    readdir(path: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
     realpath(path: string, options?: FsOptions): Promise<string>;
     access(path: string, requestedMode?: number, options?: FsOptions): Promise<void>;
     mkdir(path: string, options?: MkdirOptions): Promise<void>;

package/dist/safe-fs/fs/overlay/index.js

@@ -6,6 +6,7 @@ import { FsError, toFsError } from "../../contracts/errors.js";
 import { dirname, isPathWithin, normalizePath, validatePath } from "../../contracts/virtual-path.js";
 import { compareIdentity } from "../mount/identity.js";
 import { compareEntries, registerEntryView } from "../mount/comparison.js";
+import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
 function snapshotStat(stat) {
     const { type, size, allocatedBytes, mode, mtimeMs, atimeMs, ctimeMs, birthtimeMs, identityScope, ino, dev, nlink, uid, gid } = stat;
     return {
@@ -343,21 +344,33 @@ export class OverlayFileSystem {
     async required(path, options, followFinal = true) {
         return (await this.resolve(path, options, followFinal)).entry;
     }
-    async listing(entry, options) {
+    async listing(entry, options, limit) {
         if (entry.stat.type !== "directory")
             fail("ENOTDIR", entry.path);
         this.permission(entry, 4);
         const names = new Set();
+        const admit = (name) => {
+            options.signal?.throwIfAborted();
+            if (!names.has(name))
+                admitDirectoryEntries(names.size + 1, limit, entry.path);
+            names.add(name);
+        };
         const upper = await this.maybeStat(this.#upper, entry.path, options);
         if (upper?.type === "directory") {
-            for (const child of await this.#upper.readdir(entry.path, options))
-                names.add(child.name);
+            const children = await this.#upper.readdir(entry.path, options);
+            options.signal?.throwIfAborted();
+            admitDirectoryEntries(children.length, limit, entry.path);
+            for (const child of children)
+                admit(child.name);
         }
         if (await this.lowerVisible(entry.path, options) && !this.opaque.has(entry.path)) {
             const lower = await this.maybeStat(this.#lower, entry.path, options);
             if (lower?.type === "directory") {
-                for (const child of await this.#lower.readdir(entry.path, options))
-                    names.add(child.name);
+                const children = await this.#lower.readdir(entry.path, options);
+                options.signal?.throwIfAborted();
+                admitDirectoryEntries(children.length, limit, entry.path);
+                for (const child of children)
+                    admit(child.name);
             }
         }
         const entries = [];
@@ -572,7 +585,8 @@ export class OverlayFileSystem {
         return compareEntries(this, path, peer, peerPath, options);
     }
     async readdir(path, options = {}) {
-        return this.run(options, async () => this.listing(await this.required(path, options), options), false);
+        const limit = directoryEntryLimit(options, path);
+        return this.run(options, async () => this.listing(await this.required(path, options), options, limit), false);
     }
     async realpath(path, options = {}) {
         return this.run(options, async () => (await this.required(path, options)).path, false);

package/dist/safe-fs/fs/readonly/index.d.ts

@@ -1,5 +1,5 @@
 import type { ByteSource } from "../../contracts/io.js";
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 export declare class ReadOnlyFileSystem implements FileSystem {
     #private;
     constructor(filesystem: FileSystem);
@@ -9,7 +9,7 @@ export declare class ReadOnlyFileSystem implements FileSystem {
     stat(path: string, options?: FsOptions): Promise<FileStat>;
     lstat(path: string, options?: FsOptions): Promise<FileStat>;
     compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<import("../../contracts/filesystem.js").EntryComparison>;
-    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    readdir(path: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
     realpath(path: string, options?: FsOptions): Promise<string>;
     access(path: string, mode?: number, options?: FsOptions): Promise<void>;
     readlink(path: string, options?: FsOptions): Promise<string>;

package/dist/safe-fs/fs/readonly/index.js

@@ -3,6 +3,7 @@ import { FsError } from "../../contracts/errors.js";
 import { readBytes } from "../../contracts/io.js";
 import { compareEntries, registerEntryView } from "../mount/comparison.js";
 import { readOnlyCapabilities } from "../capabilities.js";
+import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
 function readOnly(syscall, path, dest) {
     throw new FsError("EROFS", { syscall, path, ...(dest === undefined ? {} : { dest }) });
 }
@@ -60,7 +61,12 @@ export class ReadOnlyFileSystem {
         return compareEntries(this, path, peer, peerPath, options);
     }
     async readdir(path, options) {
-        return (await this.#filesystem.readdir(path, options)).map((entry) => ({ name: entry.name, type: entry.type }));
+        const limit = options?.maxEntries === undefined ? undefined : directoryEntryLimit(options, path);
+        const entries = await this.#filesystem.readdir(path, options);
+        if (limit !== undefined)
+            options?.signal?.throwIfAborted();
+        admitDirectoryEntries(entries.length, limit, path);
+        return entries.map((entry) => ({ name: entry.name, type: entry.type }));
     }
     async realpath(path, options) {
         return this.#filesystem.realpath(path, options);

package/dist/safe-fs/fs/real/index.d.ts

@@ -1,4 +1,4 @@
-import type { AppendFileOptions, ByteSource, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/index.js";
+import type { AppendFileOptions, ByteSource, CopyFileOptions, DirectoryEntry, FileStat, FileSystem, FileSystemCapabilities, FsOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/index.js";
 export interface RealFileSystemOptions {
     /** An existing, absolute host directory. It is never created implicitly. */
     readonly root: string;
@@ -55,7 +55,7 @@ export declare class RealFileSystem implements FileSystem {
     appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
     stat(path: string, options?: FsOptions): Promise<FileStat>;
     lstat(path: string, options?: FsOptions): Promise<FileStat>;
-    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    readdir(path: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
     mkdir(path: string, options?: MkdirOptions): Promise<void>;
     rmdir(path: string, options?: FsOptions): Promise<void>;
     rm(path: string, options?: RemoveOptions): Promise<void>;

package/dist/safe-fs/fs/real/index.js

@@ -3,6 +3,7 @@ import * as native from "node:fs/promises";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { nativeAllocatedBytes } from "./allocation.js";
 import { finishCleanup } from "../../contracts/cleanup.js";
+import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
 import { FsError, collectBytes, isErrnoCode, toByteSource, toFsError, validatePath, } from "../../contracts/index.js";
 function fileType(stats) {
     if (stats.isFile())
@@ -273,11 +274,35 @@ export class RealFileSystem {
         });
     }
     async readdir(path, options = {}) {
+        const limit = directoryEntryLimit(options, path);
         return this.operation("readdir", path, options, async () => {
             const target = await this.path(path, options);
             options.signal?.throwIfAborted();
-            const entries = await native.readdir(target, { withFileTypes: true });
-            return entries.map((entry) => ({ name: entry.name, type: fileType(entry) }));
+            if (limit === undefined) {
+                const entries = await native.readdir(target, { withFileTypes: true });
+                return entries.map((entry) => ({ name: entry.name, type: fileType(entry) }));
+            }
+            const handle = await native.opendir(target, { bufferSize: 1 });
+            let failed = false;
+            try {
+                const entries = [];
+                while (true) {
+                    options.signal?.throwIfAborted();
+                    const entry = await handle.read();
+                    options.signal?.throwIfAborted();
+                    if (entry === null)
+                        return entries;
+                    admitDirectoryEntries(entries.length + 1, limit, path);
+                    entries.push({ name: entry.name, type: fileType(entry) });
+                }
+            }
+            catch (error) {
+                failed = true;
+                throw error;
+            }
+            finally {
+                await finishCleanup(() => handle.close(), failed);
+            }
         });
     }
     async mkdir(path, options = {}) {

package/dist/safe-fs/fs/s3/filesystem.d.ts

@@ -1,5 +1,5 @@
 import { FsError } from "../../contracts/errors.js";
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 import type { ByteSource } from "../../contracts/io.js";
 import type { S3Transport } from "./transport.js";
 export interface S3FileSystemOptions {
@@ -93,7 +93,7 @@ export declare class S3FileSystem implements FileSystem {
     private writeMetadata;
     appendFile(path: string, data: Uint8Array, options?: AppendFileOptions): Promise<void>;
     mkdir(input: string, options?: MkdirOptions): Promise<void>;
-    readdir(input: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    readdir(input: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
     private tree;
     rmdir(input: string, options?: FsOptions): Promise<void>;
     rm(input: string, options?: RemoveOptions): Promise<void>;

package/dist/safe-fs/fs/s3/filesystem.js

@@ -5,6 +5,7 @@ import { collectBytes, readBytes } from "../../contracts/io.js";
 import { compareEntries, registerEntryAuthority } from "../mount/comparison.js";
 import { compareOwnedS3Entries, queryS3Head, recordS3Stat, registerS3EntryOwner } from "./authority.js";
 import { encodeCopySource } from "./transport.js";
+import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
 export class S3RenameError extends FsError {
     phase;
     copiedKeys;
@@ -495,20 +496,29 @@ export class S3FileSystem {
         }, this.requestOptions(options)), "EEXIST");
     }
     async readdir(input, options = {}) {
+        let limit;
+        if (options.maxEntries !== undefined) {
+            this.checkAbort(options, "readdir", input);
+            limit = directoryEntryLimit(options, input);
+        }
         const path = this.path(input);
         if ((await this.stat(input, options)).type !== "directory")
             fail("ENOTDIR", "readdir", path);
         const prefix = this.directoryKey(path);
         const entries = new Map();
         const add = (name, type) => {
+            this.checkAbort(options, "readdir", path);
             if (!name || name.includes("/"))
                 fail("EIO", "readdir", path, "invalid direct child in delimited listing");
             const existing = entries.get(name);
             if (existing && existing.type !== type)
                 this.unsupported("file/prefix collisions", path);
+            if (!existing)
+                admitDirectoryEntries(entries.size + 1, limit, path);
             entries.set(name, { name, type });
         };
-        for await (const page of this.pages(prefix, path, options, "/")) {
+        const maxKeys = limit === undefined ? this.pageSize : Math.min(this.pageSize, limit + 1);
+        for await (const page of this.pages(prefix, path, options, "/", maxKeys)) {
             for (const item of page.Contents ?? []) {
                 if (item.Key === prefix)
                     continue;

package/dist/safe-fs/fs/webdav/webdav.d.ts

@@ -1,6 +1,6 @@
 import type { PlatformComparisonCallback } from "#safe-fs-platform";
 import type { ByteSource } from "../../contracts/io.js";
-import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, MkdirOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 export type WebDavFetch = (url: string, init: RequestInit) => Promise<Response>;
 export interface WebDavAtomicEmptyDirectoryRequest {
     readonly operation: "atomic-empty-rmdir/v1";
@@ -100,7 +100,7 @@ export declare class WebDavFileSystem implements FileSystem {
     stat(path: string, options?: FsOptions): Promise<FileStat>;
     private statWithAncestors;
     lstat(path: string, options?: FsOptions): Promise<FileStat>;
-    readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
+    readdir(path: string, options?: ReadDirectoryOptions): Promise<DirectoryEntry[]>;
     readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
     readStream(path: string, options?: ReadStreamOptions): AsyncGenerator<Uint8Array>;
     private prepareWrite;

package/dist/safe-fs/fs/webdav/webdav.js

@@ -2,6 +2,7 @@ import { FsError, isErrnoCode, isFsError } from "../../contracts/errors.js";
 import { composeAbortSignals } from "../../contracts/abort.js";
 import { readBytes } from "../../contracts/io.js";
 import { davChild, davChildren, parseXml, scalar } from "./xml.js";
+import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
 import { assertCallbackAuthorityAllowed, compareEntries, registerEntryAuthority } from "../mount/comparison.js";
 import { compareWebDavResources, ownedResponseIdentifier, recordOwnedResourceStat, registerResourceQuery, resourceIdentifier } from "./resource-id.js";
 const timestampNamespace = "urn:virtual-bash:metadata";
@@ -616,14 +617,16 @@ export class WebDavFileSystem {
             this.etags.set(stat, validator);
         return stat;
     }
-    async entries(path, depth, options, collection = depth === "1") {
+    async entries(path, depth, options, collection = depth === "1", limit) {
         return this.request("PROPFIND", path, options, {
             headers: { Depth: depth, "Content-Type": "application/xml; charset=utf-8" }, body: propfindBody,
         }, async (response, signal) => {
             if (response.status !== 207)
                 this.httpError(response.status, "PROPFIND", path);
             const result = new Map();
+            let children = 0;
             for (const element of await this.multistatus(response, signal)) {
+                signal.throwIfAborted();
                 const href = davChild(element, "href");
                 if (!href)
                     throw new Error("missing DAV:href");
@@ -634,6 +637,8 @@ export class WebDavFileSystem {
                 }
                 if (result.has(member))
                     throw new Error("duplicate response href");
+                if (member !== path)
+                    admitDirectoryEntries(++children, limit, path);
                 const stat = this.entryStat(element, member);
                 recordOwnedResourceStat(response, this, member, stat);
                 result.set(member, stat);
@@ -730,8 +735,14 @@ export class WebDavFileSystem {
         return this.stat(path, options);
     }
     async readdir(path, options = {}) {
+        let limit;
+        if (options.maxEntries !== undefined) {
+            if (options.signal?.aborted)
+                fail("ECANCELED", "readdir", path);
+            limit = directoryEntryLimit(options, path);
+        }
         const normalized = normalize(path);
-        const entries = await this.entries(normalized, "1", options);
+        const entries = await this.entries(normalized, "1", options, true, limit);
         if (entries.get(normalized).type !== "directory")
             fail("ENOTDIR", "readdir", path);
         return [...entries].filter(([member]) => member !== normalized)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-fs",
-  "version": "0.1.70",
+  "version": "0.1.72",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",