@poe-platform/safe-fs 0.1.721 → 0.1.723

package/dist/safe-fs/fs/s3/http/xml.js

@@ -35,7 +35,11 @@ function decodeEntities(text) {
     }
     return result;
 }
-export function parseXml(bytes) {
+export function parseXml(bytes, limits = {}) {
+    for (const limit of [limits.maxNodes, limits.maxDepth]) {
+        if (limit !== undefined && (!Number.isSafeInteger(limit) || limit < 1))
+            throw new RangeError("XML limits must be positive safe integers");
+    }
     let xml;
     try {
         xml = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
@@ -146,7 +150,7 @@ export function parseXml(bytes) {
             position++;
         if (xml[position++] !== ">")
             malformed();
-        if (++nodes > 32_768 || stack.length >= 32)
+        if (++nodes > (limits.maxNodes ?? Infinity) || stack.length >= (limits.maxDepth ?? Infinity))
             malformed("XML structure limit exceeded");
         const node = { name: tag, text: "", children: [] };
         const parent = stack.at(-1);

package/dist/safe-fs/fs/s3/manifest-admission.d.ts

@@ -0,0 +1,8 @@
+import { type ByteSource } from '../../contracts/io.js';
+/** Admit the fixed manifest grammar before JSON.parse can allocate its graph. */
+export declare function admitManifest(source: ByteSource, options: {
+    maxManifestBytes: number;
+    maxEntries: number;
+    maxBytes: number;
+    signal?: AbortSignal | undefined;
+}): ByteSource;

package/dist/safe-fs/fs/s3/manifest-admission.js

@@ -0,0 +1,171 @@
+import { FsError } from '../../contracts/errors.js';
+import { readBytes } from '../../contracts/io.js';
+/** Admit the fixed manifest grammar before JSON.parse can allocate its graph. */
+export async function* admitManifest(source, options) {
+    const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+    const frames = [];
+    let started = false;
+    let done = false;
+    let token = '';
+    let quoted = false;
+    let escaped = false;
+    let entries = 0;
+    let bytes = 0;
+    let wireBytes = 0;
+    let allocation = 0;
+    // Conservative accounting for graph storage, array growth, and validation
+    // tables. This is an admission estimate, not a process-RSS guarantee.
+    const allocationLimit = options.maxManifestBytes * 4;
+    const invalid = () => { throw new FsError('EIO', { message: 'Invalid S3 namespace structure' }); };
+    const reserve = (amount) => {
+        if (amount > allocationLimit - allocation)
+            throw new FsError('EFBIG', { message: 'S3 namespace graph exceeds allocation budget' });
+        allocation += amount;
+    };
+    const open = (shape) => {
+        reserve(256);
+        frames.push({ shape, state: shape === 'bytes' ? 'valueOrEnd' : 'keyOrEnd', key: '', keys: new Set() });
+    };
+    const scalar = () => {
+        const frame = frames.at(-1) ?? invalid();
+        let value;
+        try {
+            value = JSON.parse(token);
+        }
+        catch {
+            invalid();
+        }
+        token = '';
+        if (frame.state === 'key' || frame.state === 'keyOrEnd') {
+            if (typeof value !== 'string' || frame.keys.has(value))
+                invalid();
+            const key = value;
+            if (frame.shape === 'nodes') {
+                if (key.length > 4096)
+                    invalid();
+                if (++entries > options.maxEntries)
+                    throw new FsError('ENOSPC');
+            }
+            else {
+                const fields = frame.shape === 'namespace' ? ['version', 'identity', 'nextInode', 'nodes']
+                    : ['ino', 'revision', 'type', 'mode', 'time', 'bytes'];
+                if (!fields.includes(key))
+                    invalid();
+            }
+            reserve(64 + key.length * 2);
+            frame.keys.add(key);
+            frame.key = key;
+            frame.state = 'colon';
+            return;
+        }
+        if (frame.state !== 'value' && frame.state !== 'valueOrEnd')
+            invalid();
+        if (frame.shape === 'bytes') {
+            if (!Number.isInteger(value) || value < 0 || value > 255)
+                invalid();
+            if (++bytes > options.maxBytes)
+                throw new FsError('ENOSPC');
+            reserve(16);
+        }
+        else if (frame.shape === 'nodes' || frame.key === 'nodes' || frame.key === 'bytes')
+            invalid();
+        else if (frame.key === 'identity' || frame.key === 'type') {
+            if (typeof value !== 'string' || (frame.key === 'identity' ? value.length < 1 || value.length > 128 : !['file', 'directory'].includes(value)))
+                invalid();
+            reserve(value.length * 2);
+        }
+        else if (typeof value !== 'number' || !Number.isFinite(value))
+            invalid();
+        frame.state = 'commaOrEnd';
+    };
+    const feed = (text) => {
+        for (const character of text) {
+            if (token) {
+                if (quoted) {
+                    token += character;
+                    if (token.length > 4096 * 6 + 2)
+                        invalid();
+                    if (escaped)
+                        escaped = false;
+                    else if (character === '\\')
+                        escaped = true;
+                    else if (character === '"') {
+                        quoted = false;
+                        scalar();
+                    }
+                    continue;
+                }
+                if (![' ', '\n', '\r', '\t', ',', '}', ']'].includes(character)) {
+                    if (token.length >= 64)
+                        invalid();
+                    token += character;
+                    continue;
+                }
+                scalar();
+            }
+            if ([' ', '\n', '\r', '\t'].includes(character))
+                continue;
+            if (done)
+                invalid();
+            if (!started) {
+                if (character !== '{')
+                    invalid();
+                started = true;
+                open('namespace');
+                continue;
+            }
+            const frame = frames.at(-1) ?? invalid();
+            if (character === '}' || character === ']') {
+                if ((character === ']') !== (frame.shape === 'bytes')
+                    || !['commaOrEnd', 'keyOrEnd', 'valueOrEnd'].includes(frame.state))
+                    invalid();
+                if (frame.shape === 'namespace' && frame.keys.size !== 4 || frame.shape === 'node' && frame.keys.size !== 6)
+                    invalid();
+                frames.pop();
+                if (!frames.length)
+                    done = true;
+                continue;
+            }
+            if (frame.state === 'commaOrEnd') {
+                if (character !== ',')
+                    invalid();
+                frame.state = frame.shape === 'bytes' ? 'value' : 'key';
+                continue;
+            }
+            if (frame.state === 'colon') {
+                if (character !== ':')
+                    invalid();
+                frame.state = 'value';
+                continue;
+            }
+            if (frame.state === 'key' || frame.state === 'keyOrEnd') {
+                if (character !== '"')
+                    invalid();
+            }
+            else if (character === '{' || character === '[') {
+                const shape = frame.shape === 'namespace' && frame.key === 'nodes' ? 'nodes'
+                    : frame.shape === 'nodes' ? 'node' : frame.shape === 'node' && frame.key === 'bytes' ? 'bytes' : invalid();
+                if ((character === '[') !== (shape === 'bytes'))
+                    invalid();
+                frame.state = 'commaOrEnd';
+                open(shape);
+                continue;
+            }
+            else if (frame.shape === 'nodes' || frame.key === 'nodes' || frame.key === 'bytes')
+                invalid();
+            quoted = character === '"';
+            escaped = false;
+            token = character;
+        }
+    };
+    for await (const chunk of readBytes(source, options.signal)) {
+        if (chunk.byteLength > options.maxManifestBytes - wireBytes)
+            throw new FsError('EFBIG');
+        wireBytes += chunk.byteLength;
+        feed(decoder.decode(chunk, { stream: true }));
+        yield chunk;
+    }
+    feed(decoder.decode());
+    if (!done || token || frames.length)
+        invalid();
+}

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

@@ -2,8 +2,11 @@ import { FsError } from '../../contracts/errors.js';
 import { collectBytes } from '../../contracts/io.js';
 import { dirname, normalizePath, validatePath } from '../../contracts/virtual-path.js';
 import { withObjectFileDescriptors } from '../object-publication/index.js';
-function limit(value, maximum) {
-    if (!Number.isSafeInteger(value) || value < 1 || value > maximum)
+import { admitManifest } from './manifest-admission.js';
+function limit(value) {
+    if (value === undefined)
+        return Infinity;
+    if (!Number.isSafeInteger(value) || value < 1)
         throw new RangeError('Invalid S3 namespace limit');
     return value;
 }
@@ -13,14 +16,14 @@ export async function createS3NamespaceFileSystem(options) {
         throw new FsError('ENOTSUP', { message: 'S3 namespaces require verified conditional PUT and bounded streaming reads' });
     if (![options.bucket, options.key].every(value => typeof value === 'string' && value.length > 0 && !value.includes('\0')))
         throw new TypeError('An explicit S3 bucket and manifest key are required');
-    const maxBytes = limit(options.maxBytes ?? 1048576, 67108864);
-    const maxEntries = limit(options.maxEntries ?? 1024, 65536);
-    const maxManifestBytes = limit(options.maxManifestBytes ?? 8388608, 268435456);
-    const maxAttempts = limit(options.maxAttempts ?? 8, 64);
-    const descriptorOptions = { ...options, maxFileBytes: options.maxFileBytes ?? maxBytes, maxOpenFiles: options.maxOpenFiles ?? 16 };
+    const maxBytes = limit(options.maxBytes);
+    const maxEntries = limit(options.maxEntries);
+    const maxManifestBytes = limit(options.maxManifestBytes ?? 4 * 1024 * 1024);
+    const maxAttempts = limit(options.maxAttempts);
+    const descriptorOptions = options;
     for (const key of ['chunkBytes', 'maxStagedBytes', 'maxStagedPages', 'maxFileBytes', 'maxOpenFiles']) {
         if (descriptorOptions[key] !== undefined)
-            limit(descriptorOptions[key], key === 'chunkBytes' ? 1048576 : Number.MAX_SAFE_INTEGER);
+            limit(descriptorOptions[key]);
     }
     const object = Object.freeze({ Bucket: options.bucket, Key: options.key });
     const scope = Object.freeze({});
@@ -76,7 +79,7 @@ export async function createS3NamespaceFileSystem(options) {
         forwarded.signal?.throwIfAborted();
         try {
             const response = await client.getObjectStream(object, forwarded.signal ? { abortSignal: forwarded.signal } : {});
-            const body = await collectBytes(response.Body, { ...forwarded, maxBytes: maxManifestBytes });
+            const body = await collectBytes(admitManifest(response.Body, { maxManifestBytes, maxEntries, maxBytes, ...(forwarded.signal ? { signal: forwarded.signal } : {}) }), { ...forwarded, maxBytes: maxManifestBytes });
             if (typeof response.ETag !== 'string' || !response.ETag || response.ETag.startsWith('W/'))
                 throw new FsError('EIO', { message: 'S3 namespace requires a strong object validator' });
             let decoded;
@@ -378,7 +381,7 @@ export async function createS3NamespaceFileSystem(options) {
             return version(node);
         },
         async publish(input, expectedRevision, source, forwarded) {
-            const bytes = await collectBytes(source, { ...forwarded, maxBytes });
+            const bytes = await collectBytes(source, { ...forwarded, ...(maxBytes === Infinity ? {} : { maxBytes: maxBytes }) });
             if (bytes.length !== forwarded.size)
                 throw new FsError('EIO');
             const published = await mutate(forwarded, value => {

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

@@ -1,6 +1,7 @@
 import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
 export declare function scopeFileSystem(filesystem: FileSystem, charge: () => void, signal: AbortSignal, cleanupCharge?: () => void, options?: {
     readonly preserveDescriptorWriteReceipt?: boolean;
+    readonly creationMask?: number;
 }): FileSystem;
 export interface RetainedFileSystemCleanupView {
     readonly removeFileConditional?: NonNullable<FileSystem["removeFileConditional"]>;

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

@@ -5,13 +5,26 @@ import { openRetainedResizeFile, retainedResizeCapabilities, ownedMutationCapabi
 const originals = new WeakMap();
 const operations = new Set([
     "publishFileConditional", "removeEntryConditional", "removeTreeConditional", "writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory",
-    "access", "appendFile", "canonicalizeMissingTarget", "capabilitiesFor", "chmod", "compareEntry",
+    "confineExtraction", "access", "appendFile", "canonicalizeMissingTarget", "capabilitiesFor", "chmod", "compareEntry",
     "copyFile", "link", "lstat", "mkdir", "openReadFile", "openResizeFile", "readFile", "readStream", "readdir",
     "readlink", "realpath", "rename", "resizeFile", "rm", "rmdir", "unlink", "stat", "symlink", "truncate", "utimes",
     "writeFile", "writeStream",
 ]);
 export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = charge, options = {}) {
     const original = originals.get(filesystem)?.filesystem ?? filesystem;
+    const creationMask = options.creationMask ?? originals.get(filesystem)?.creationMask;
+    if (creationMask !== undefined && (!Number.isInteger(creationMask) || creationMask < 0 || creationMask > 0o777))
+        throw new RangeError("creationMask must be a permission mask between 0 and 0777");
+    const creationOptions = (settings, directory = false) => {
+        // Explicit directory modes (mkdir -m) are independent of the shell mask.
+        // Modes remain advisory on adapters that do not enforce permissions.
+        if (creationMask === undefined || directory && settings.mode !== undefined)
+            return settings;
+        const mode = settings.mode ?? (directory ? 0o777 : 0o666);
+        if (!Number.isSafeInteger(mode) || mode < 0 || mode > 0o7777)
+            throw new FsError("EINVAL");
+        return { ...settings, mode: mode & ~creationMask };
+    };
     const methods = new Map();
     const assertOpen = (options) => {
         signal.throwIfAborted();
@@ -199,6 +212,10 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
                     const options = args.at(-1);
                     admit(options && typeof options === "object" && "signal" in options ? options : undefined);
                 }
+                if (["writeFile", "appendFile", "writeStream", "mkdir"].includes(String(property))) {
+                    const index = property === "mkdir" ? 1 : 2;
+                    args[index] = creationOptions((args[index] ?? {}), property === "mkdir");
+                }
                 if (["publishFileConditional", "removeEntryConditional", "removeTreeConditional", "writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory"].includes(String(property)))
                     return (async () => {
                         const path = typeof args[0] === "string" ? args[0] : args[0].directory.path;
@@ -229,43 +246,45 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
                     })();
                 return Reflect.apply(method, original, args);
             };
-            const scoped = property === "open"
-                ? async (path, options) => {
-                    admit(options);
-                    const selected = resizeOptions(options);
-                    let descriptor;
-                    try {
-                        descriptor = await Reflect.apply(method, original, [path, selected]);
-                        assertOpen(options);
-                        return wrapDescriptor(descriptor);
-                    }
-                    catch (error) {
-                        if (descriptor)
-                            await finishCleanup(() => descriptor.close(), true);
-                        assertOpen(options);
-                        throw error;
-                    }
-                }
-                : property === "openResizeFile"
-                    ? async (path, options = {}) => {
+            const scoped = property === "confineExtraction"
+                ? async (...args) => scopeFileSystem(await dispatch(...args), charge, signal, cleanupCharge, options)
+                : property === "open"
+                    ? async (path, options) => {
                         admit(options);
-                        assertOpen(options);
-                        return wrapResizeHandle(await openRetainedResizeFile(original, path, resizeOptions(options)));
+                        const selected = resizeOptions(creationOptions(options));
+                        let descriptor;
+                        try {
+                            descriptor = await Reflect.apply(method, original, [path, selected]);
+                            assertOpen(options);
+                            return wrapDescriptor(descriptor);
+                        }
+                        catch (error) {
+                            if (descriptor)
+                                await finishCleanup(() => descriptor.close(), true);
+                            assertOpen(options);
+                            throw error;
+                        }
                     }
-                    : property === "capabilitiesFor"
-                        ? async (...args) => ownedMutationCapabilities(original, retainedResizeCapabilities(original, await dispatch(...args)))
-                        : property === "openReadFile"
-                            ? async (...args) => wrapHandle(await dispatch(...args))
-                            : property === "readStream"
-                                ? (...args) => wrapStream(dispatch(...args), args[1])
-                                : operations.has(property) && property !== "canonicalizeMissingTarget"
-                                    ? async (...args) => dispatch(...args)
-                                    : dispatch;
+                    : property === "openResizeFile"
+                        ? async (path, options = {}) => {
+                            admit(options);
+                            assertOpen(options);
+                            return wrapResizeHandle(await openRetainedResizeFile(original, path, resizeOptions(creationOptions(options))));
+                        }
+                        : property === "capabilitiesFor"
+                            ? async (...args) => ownedMutationCapabilities(original, retainedResizeCapabilities(original, await dispatch(...args)))
+                            : property === "openReadFile"
+                                ? async (...args) => wrapHandle(await dispatch(...args))
+                                : property === "readStream"
+                                    ? (...args) => wrapStream(dispatch(...args), args[1])
+                                    : operations.has(property) && property !== "canonicalizeMissingTarget"
+                                        ? async (...args) => dispatch(...args)
+                                        : dispatch;
             methods.set(property, { original: method, scoped });
             return scoped;
         },
     });
-    originals.set(view, { filesystem: original, signal, cleanupCharge });
+    originals.set(view, { filesystem: original, signal, cleanupCharge, creationMask });
     registerEntryView(view, async (path, options) => {
         assertOpen(options);
         return { filesystem: original, path };
@@ -273,9 +292,9 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
     return view;
 }
 export function retainFileSystemCleanup(filesystem, cleanupCallback, options) {
-    const maximum = options?.maxOperations === undefined ? 256 : options.maxOperations;
-    if (!Number.isSafeInteger(maximum) || maximum < 0 || maximum > 4096)
-        throw new RangeError("cleanup maxOperations must be an integer between 0 and 4096");
+    const maximum = options?.maxOperations ?? Infinity;
+    if (options?.maxOperations !== undefined && (!Number.isSafeInteger(maximum) || maximum < 0))
+        throw new RangeError("cleanup maxOperations must be a nonnegative safe integer");
     if (typeof cleanupCallback !== "function")
         throw new TypeError("cleanup callback must be a function");
     const scope = originals.get(filesystem);

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

@@ -24,10 +24,12 @@ export interface WebDavFileSystemOptions {
     readonly fetch: WebDavFetch;
     readonly requestStreamSupport?: "native" | boolean;
     readonly headers?: Readonly<Record<string, string>>;
+    /** Response ceiling; defaults to 16 MiB. Hosts must budget for concurrent reads. */
     readonly maxResponseBytes?: number;
+    /** Metadata response ceiling; defaults to 1 MiB before decoding/parsing. */
     readonly maxXmlBytes?: number;
     readonly maxEntries?: number;
-    /** Per-request and aggregate stat/write-preflight walk timeout; defaults to 30,000 ms. */
+    /** Per-request and aggregate stat/write-preflight walk timeout; unlimited unless configured. */
     readonly timeoutMs?: number;
     readonly overwritePolicy?: "lock" | "etag";
     readonly atomicEmptyDirectory?: WebDavAtomicEmptyDirectoryBinding;
@@ -91,6 +93,7 @@ export declare class WebDavFileSystem implements FileSystem {
     private request;
     private requestStream;
     private bytes;
+    private responseLength;
     private bodyChunks;
     private xml;
     private multistatus;

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

@@ -6,6 +6,76 @@ import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admissi
 import { assertCallbackAuthorityAllowed, compareEntries, registerEntryAuthority } from "../mount/comparison.js";
 import { compareWebDavResources, ownedResponseIdentifier, recordOwnedResourceStat, registerResourceQuery, resourceIdentifier } from "./resource-id.js";
 const timestampNamespace = "urn:virtual-bash:metadata";
+const maxTimestampPropertyBytes = 4096;
+/** Admit only five scalar members before native JSON parsing can allocate a graph. */
+function preflightTimestamps(property) {
+    // Check the untrimmed text first; counting UTF-8 bytes does not allocate an encoded copy.
+    let bytes = 0;
+    for (const point of property.text) {
+        const code = point.codePointAt(0);
+        bytes += code <= 0x7f ? 1 : code <= 0x7ff ? 2 : code <= 0xffff ? 3 : 4;
+        if (bytes > maxTimestampPropertyBytes)
+            throw new Error("timestamp property exceeds 4KiB limit");
+    }
+    const text = scalar(property);
+    let offset = 0;
+    const invalid = () => { throw new Error("invalid timestamp property structure"); };
+    const whitespace = () => {
+        while (" \t\r\n".includes(text[offset] ?? "\0"))
+            offset++;
+    };
+    const stringEnd = () => {
+        if (text[offset++] !== '"')
+            invalid();
+        while (offset < text.length) {
+            const char = text[offset++];
+            if (char === '"')
+                return;
+            if (char === "\\")
+                offset++;
+        }
+        invalid();
+    };
+    if (text[offset++] !== "{")
+        invalid();
+    const fields = new Set();
+    while (true) {
+        whitespace();
+        const start = offset;
+        stringEnd();
+        const field = JSON.parse(text.slice(start, offset));
+        if (typeof field !== "string" || !["version", "etag", "type", "atimeMs", "mtimeMs"].includes(field)
+            || fields.has(field) || fields.size >= 5)
+            return invalid();
+        fields.add(field);
+        whitespace();
+        if (text[offset++] !== ":")
+            invalid();
+        whitespace();
+        if (text[offset] === '"')
+            stringEnd();
+        else {
+            const start = offset;
+            while (offset < text.length && text[offset] !== "," && text[offset] !== "}") {
+                if ('{[:"\\]'.includes(text[offset]))
+                    invalid();
+                offset++;
+            }
+            if (offset === start)
+                invalid();
+        }
+        whitespace();
+        const delimiter = text[offset++];
+        if (delimiter === "}")
+            break;
+        if (delimiter !== ",")
+            invalid();
+    }
+    whitespace();
+    if (offset !== text.length || fields.size !== 5)
+        invalid();
+    return text;
+}
 const propfindBody = '<?xml version="1.0" encoding="utf-8"?>'
     + '<d:propfind xmlns:d="DAV:"><d:prop><d:resourcetype/><d:getcontentlength/>'
     + `<d:getlastmodified/><d:creationdate/><d:getetag/><v:timestamps xmlns:v="${timestampNamespace}"/></d:prop></d:propfind>`;
@@ -24,7 +94,7 @@ function positive(value, name, zero = false) {
 }
 function createRequestTimeout(timeoutMs) {
     const controller = new AbortController();
-    const timer = setTimeout(() => {
+    const timer = timeoutMs === undefined ? undefined : setTimeout(() => {
         controller.abort(new DOMException("The operation was aborted due to timeout", "TimeoutError"));
     }, timeoutMs);
     if (typeof timer === "object" && timer !== null) {
@@ -216,15 +286,15 @@ export class WebDavFileSystem {
             removeDirectory: this.atomicEmptyDirectory !== undefined,
             streamingAppend: this.requestStreamSupport !== false,
         });
-        this.maxResponseBytes = positive(options.maxResponseBytes ?? 64 * 1024 * 1024, "maxResponseBytes");
-        this.maxXmlBytes = positive(options.maxXmlBytes ?? 2 * 1024 * 1024, "maxXmlBytes");
-        this.maxEntries = positive(options.maxEntries ?? 10_000, "maxEntries");
-        this.timeoutMs = positive(options.timeoutMs ?? 30_000, "timeoutMs");
+        this.maxResponseBytes = options.maxResponseBytes === undefined ? 16 * 1024 * 1024 : positive(options.maxResponseBytes, "maxResponseBytes");
+        this.maxXmlBytes = options.maxXmlBytes === undefined ? 1024 * 1024 : positive(options.maxXmlBytes, "maxXmlBytes");
+        this.maxEntries = options.maxEntries === undefined ? Infinity : positive(options.maxEntries, "maxEntries");
+        this.timeoutMs = options.timeoutMs === undefined ? undefined : positive(options.timeoutMs, "timeoutMs");
         this.overwritePolicy = options.overwritePolicy ?? "lock";
         this.configuredComparison = options.compareEntry !== undefined;
         if (!["lock", "etag"].includes(this.overwritePolicy))
             throw new FsError("EINVAL", { message: "invalid overwritePolicy" });
-        if (this.timeoutMs > 2_147_483_647)
+        if (this.timeoutMs !== undefined && this.timeoutMs > 2_147_483_647)
             throw new FsError("EINVAL", { message: "timeoutMs exceeds timer range" });
         registerResourceQuery(this, (path, settings) => this.resourceId(path, settings), originalWebDavComparison, options.compareEntry);
         registerEntryAuthority(this, compareWebDavResources);
@@ -424,29 +494,37 @@ export class WebDavFileSystem {
         }
     }
     async bytes(response, limit, signal) {
-        const chunks = [];
+        const expected = this.responseLength(response, limit);
+        let data = new Uint8Array(expected ?? 0);
         let size = 0;
-        for await (const chunk of this.bodyChunks(response, limit, signal)) {
-            chunks.push(chunk);
-            size += chunk.byteLength;
-        }
-        const data = new Uint8Array(size);
-        let offset = 0;
-        for (const chunk of chunks) {
-            data.set(chunk, offset);
-            offset += chunk.byteLength;
+        // Consume borrowed chunks immediately; only streaming callers need owned copies.
+        for await (const chunk of this.bodyChunks(response, limit, signal, false)) {
+            const nextSize = size + chunk.byteLength;
+            if (nextSize > data.byteLength) {
+                const grown = new Uint8Array(Math.min(limit, Math.max(nextSize, data.byteLength * 2)));
+                grown.set(data);
+                data = grown;
+            }
+            data.set(chunk, size);
+            size = nextSize;
         }
-        return data;
+        // A view avoids a second full allocation when the length was unknown.
+        return data.subarray(0, size);
     }
-    async *bodyChunks(response, limit, signal) {
+    responseLength(response, limit) {
         const length = response.headers.get("content-length");
-        if (length !== null && (!/^\d+$/.test(length) || !Number.isSafeInteger(Number(length)))) {
+        if (length !== null && (!length.length || [...length].some(char => char < "0" || char > "9")
+            || !Number.isSafeInteger(Number(length)))) {
             fail("EIO", "webdav", "", "invalid response Content-Length");
         }
         const encoding = response.headers.get("content-encoding");
         const expected = length !== null && (!encoding || encoding.toLowerCase() === "identity") ? Number(length) : undefined;
         if (expected !== undefined && expected > limit)
             fail("EFBIG", "webdav", "", "response exceeds byte limit");
+        return expected;
+    }
+    async *bodyChunks(response, limit, signal, copy = true) {
+        const expected = this.responseLength(response, limit);
         if (!response.body) {
             if (expected !== undefined && expected !== 0)
                 fail("EIO", "webdav", "", "response body length differs from Content-Length");
@@ -468,7 +546,7 @@ export class WebDavFileSystem {
                     fail("EFBIG", "webdav", "", "response exceeds byte limit");
                 if (expected !== undefined && size > expected)
                     fail("EIO", "webdav", "", "response body length differs from Content-Length");
-                yield new Uint8Array(result.value);
+                yield copy ? new Uint8Array(result.value) : result.value;
             }
             if (expected !== undefined && size !== expected)
                 fail("EIO", "webdav", "", "response body length differs from Content-Length");
@@ -492,7 +570,7 @@ export class WebDavFileSystem {
         }
         let root;
         try {
-            root = await this.xml(response, signal, this.maxEntries);
+            root = await this.xml(response, signal, this.maxEntries === Infinity ? undefined : this.maxEntries);
         }
         catch (error) {
             if (error instanceof XmlResponseLimitError)
@@ -604,7 +682,7 @@ export class WebDavFileSystem {
         let mtimeMs = date("getlastmodified") ?? 0;
         let atimeMs = 0;
         if (timestampProperty) {
-            const timestamps = JSON.parse(scalar(timestampProperty));
+            const timestamps = JSON.parse(preflightTimestamps(timestampProperty));
             if (typeof timestamps !== "object" || timestamps === null
                 || !("version" in timestamps) || timestamps.version !== 1
                 || !("etag" in timestamps) || typeof timestamps.etag !== "string" || !/^"[\x21\x23-\x7e\x80-\xff]*"$/.test(timestamps.etag)
@@ -762,7 +840,7 @@ export class WebDavFileSystem {
     }
     async readFile(path, options = {}) {
         const normalized = normalize(path);
-        const limit = Math.min(this.maxResponseBytes, positive(options.maxBytes ?? this.maxResponseBytes, "maxBytes", true));
+        const limit = Math.min(this.maxResponseBytes, options.maxBytes === undefined ? this.maxResponseBytes : positive(options.maxBytes, "maxBytes", true));
         if ((await this.stat(path, options)).type === "directory")
             fail("EISDIR", "readFile", path);
         return this.request("GET", normalized, options, { headers: { "Accept-Encoding": "identity" } }, async (response, signal) => {

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

@@ -1,11 +1,18 @@
 import type * as FsPromises from "node:fs/promises";
 import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
-export type NodeFsImplementation = Pick<typeof FsPromises, "access" | "appendFile" | "chmod" | "copyFile" | "cp" | "link" | "lstat" | "mkdir" | "mkdtemp" | "readFile" | "readdir" | "readlink" | "realpath" | "rename" | "rm" | "rmdir" | "stat" | "symlink" | "truncate" | "utimes" | "writeFile">;
+export type NodeFsImplementation = Pick<typeof FsPromises, "access" | "appendFile" | "chmod" | "copyFile" | "cp" | "link" | "lstat" | "mkdir" | "mkdtemp" | "readFile" | "readdir" | "readlink" | "realpath" | "unlink" | "rename" | "rm" | "rmdir" | "stat" | "symlink" | "truncate" | "utimes" | "writeFile">;
 export interface NodeFsBridgeOptions {
     readonly cwd?: string;
+    /** Optional confinement boundary; defaults to cwd. */
+    readonly root?: string;
     readonly signal?: AbortSignal;
+    /** Trusted per-read backend byte cap, enforced before copying or decoding. */
+    readonly readFileMaxBytes?: number;
+    /** Reserve host resources; release after decoding and actual backend settlement, including cancellation. */
+    readonly reserveReadFile?: () => () => void;
 }
 export interface NodeFsBridgeFileSystem extends FileSystem {
     rmdir?(path: string, options?: FsOptions): Promise<void>;
 }
+export declare function getNodeFsBridgeProvider(bridge: object): FileSystem | undefined;
 export declare function createNodeFsBridge(fs: FileSystem, options?: NodeFsBridgeOptions): NodeFsImplementation;