@poe-platform/safe-fs 0.1.735 → 0.1.737

package/README.md

@@ -41,10 +41,10 @@ To create new outputs with Safe Bash's `dos2unix`, `unix2dos`, or compression co
 
 | Import | Use |
 | --- | --- |
-| `@poe-platform/safe-fs` | Full Node API; selects the portable core under the `browser` condition. |
+| `@poe-platform/safe-fs` | Full Node API; selects the portable core under the `browser` and `workerd` conditions. |
 | `@poe-platform/safe-fs/core` | Memory, mounts, overlays, read-only, WebDAV, portable bridges, types, and errors. Bundle with the `browser` condition for browsers and Workers. |
 | `@poe-platform/safe-fs/node` | Host filesystem, Node bridge, S3, and configuration helpers; unavailable in browsers. |
-| `@poe-platform/safe-fs/fs/*` | Individual adapters: `memory`, `readonly`, `mount`, `overlay`, `webdav`, `real`, `s3`, and `s3/http`. The last three are Node-only. |
+| `@poe-platform/safe-fs/fs/*` | Individual adapters: `memory`, `readonly`, `mount`, `overlay`, `webdav`, `real`, `s3`, and `s3/http`. S3 and its mock accept an injected transport in browsers and Workers; `s3/http` is Node-only. |
 
 ```ts
 import { createMemoryFileSystem, FsError, type FileSystem } from "@poe-platform/safe-fs/core";
@@ -117,7 +117,7 @@ See the [staging contract](src/contracts/filesystem.md#atomic-owned-staging).
 | --- | --- |
 | `createMemoryFileSystem()` | Isolated, nonpersistent storage with links, permissions, timestamps, and streams; each path resolution admits at most 65,536 cumulative UTF-16 code units across the input and followed symlink targets, rejecting excess with `ENAMETOOLONG` before component allocation |
 | `createRealFileSystem({ root })` | An existing host directory, with virtual paths rooted inside it; Node or qualified Workerd operations |
-| `new S3FileSystem({ transport, bucket, … })` | Bucket/prefix storage through an explicitly supplied transport; Node only |
+| `new S3FileSystem({ transport, bucket, … })` | Bucket/prefix storage through an explicitly supplied transport in Node, browsers, and Workers |
 | `new WebDavFileSystem({ baseUrl, fetch, … })` | A WebDAV namespace through an explicitly supplied Fetch implementation |
 | `createReadOnlyFileSystem(filesystem)` | Rejecting writes through one view of an existing filesystem |
 | `createMountFileSystem({ root, mounts })` | Routing absolute virtual mount paths to different filesystems |
@@ -268,7 +268,7 @@ Every raw filesystem operation accepts an optional `signal`. Additional fields a
 
 `access` takes a separate mode bitmask from `ACCESS_MODES`. `chmod` takes a mode, `utimes` takes millisecond timestamps, and `truncate` takes a byte length (default 0). For conditional chmod, check `capabilitiesFor(path, { conditionalChmod: true })` (or `capabilities`) and require `conditionalChmod: true`; supply `parent`, `expected`, and complete root-to-parent `ancestors` together. An optional mutation-free `commitGuard` must return literal `true` synchronously. Memory validates at its metadata commit; mount and supported Memory overlays preserve wrapper ancestry. Real uses its existing externally isolated host-tree boundary and does not prevent races with other processes. Backend limits still apply. Node-shaped bridge methods translate their own options rather than accepting these raw option objects; see the [bridge signatures](src/bridge/filesystem.ts).
 
-`collectBytes(source, { maxBytes, maxMemoryBytes, signal })` snapshots streamed chunks into one growing buffer. `maxBytes` and `maxMemoryBytes` accept explicit `Infinity`. `maxMemoryBytes` limits owned capacity, the current input's full backing buffer, and overlapping allocations during growth; exhaustion throws `EFBIG`. Browser and Worker bundles additionally share a fixed 32 MiB budget across active collectors, even when byte limits are omitted. The returned view may retain geometric spare capacity. This budget covers collection, not caller-retained results, transport buffering, archive decoding, strings, or the rest of the runtime; use streaming APIs and limit concurrent workloads for larger inputs.
+`collectBytes(source, { maxBytes, maxMemoryBytes, signal })` snapshots streamed chunks into one growing buffer. `maxBytes` and `maxMemoryBytes` accept explicit `Infinity`. `maxMemoryBytes` limits owned capacity, the current input's full backing buffer, and overlapping allocations during growth; exhaustion throws `EFBIG`. Collection limits are disabled by default on Node, browser, and Worker targets. The returned view may retain geometric spare capacity. Configured budgets cover collection, not caller-retained results, transport buffering, archive decoding, strings, or the rest of the runtime; use streaming APIs and limit concurrent workloads for larger inputs.
 
 <details>
 <summary>S3 filesystem and HTTP transport options</summary>
@@ -344,17 +344,18 @@ Each batch lists from the beginning because previous keys have been deleted; it
 | --- | --- |
 | `headers` | Empty; explicit authentication/custom headers. Protocol-reserved headers are rejected; authorization and cookies require HTTPS. |
 | `requestStreamSupport` | `native` for global Fetch, otherwise false; accepts `native` or a boolean declaration for the injected transport |
-| `maxResponseBytes` | 16 MiB; applies to decoded response bytes |
-| `maxXmlBytes` | 1 MiB before metadata decoding/parsing |
+| `maxResponseBytes` | Unlimited unless configured; applies to decoded response bytes |
+| `maxXmlBytes` | Unlimited unless configured; applies before metadata decoding/parsing |
+| `xmlLimits` | Optional `maxNodes`, `maxContentNodes`, `maxDepth`, and `maxAttributes`; each accepts a positive safe integer or `Infinity`, and is unlimited unless configured |
 | `maxEntries` | Unlimited unless configured |
 | `timeoutMs` | Unlimited unless configured |
 | `overwritePolicy` | `lock`; alternative `etag` uses conditional overwrites |
 | `atomicEmptyDirectory` | Optional trusted binding with the canonical `namespaceUrl` and `removeEmptyDirectory` callback; required for strict empty-only `rmdir` |
 | `compareEntry` | Optional trusted backing-identity callback on Node; unavailable under browser policy |
 
-Known identity Content-Length responses use one result buffer; other responses grow storage up to the configured ceiling and return a view without a final copy. Growth can temporarily retain the old and new buffers (up to three times the response size), plus transport chunks. These per-response defaults leave headroom in Workers; hosts must still budget for metadata parsing, text decoding, transport buffers, and concurrent reads, especially when raising the limits. Use streaming reads for large files.
+Known identity Content-Length responses use one result buffer; other responses grow storage up to the configured ceiling and return a view without a final copy. Growth can temporarily retain the old and new buffers (up to three times the response size), plus transport chunks. Hosts can configure per-response limits to budget for metadata parsing, text decoding, transport buffers, and concurrent reads. Use streaming reads for large files.
 
-WebDAV `maxEntries`, `maxResponseBytes`, `maxXmlBytes`, and per-read `maxBytes` accept explicit `Infinity`. WebDAV metadata parsing limits the document to 100,000 elements, 100,000 content nodes, 100,000 attributes, and 256 levels of nesting, independently of `maxEntries`. Text is bounded by `maxXmlBytes`. Exceeding a structural budget reports `EFBIG`; parsing yields cooperatively so caller cancellation and `timeoutMs` remain active.
+WebDAV `maxEntries`, `maxResponseBytes`, `maxXmlBytes`, and per-read `maxBytes` accept explicit `Infinity`. WebDAV metadata structure limits are disabled by default; configure `xmlLimits` independently of `maxEntries`. Text is bounded by `maxXmlBytes`. Exceeding a structural budget reports `EFBIG`; parsing yields cooperatively so caller cancellation and `timeoutMs` remain active.
 
 See the [binding types](src/fs/webdav/webdav.ts) before implementing atomic directory removal. A recursive WebDAV DELETE does not satisfy that contract.
 
@@ -366,7 +367,7 @@ See the [binding types](src/fs/webdav/webdav.ts) before implementing atomic dire
 - **A read-only view is not an immutable store.** Mount views serialize guest symlink, rename, and removal operations against active path operations. Finish or close read streams before awaiting these namespace changes. Other references can still change the backing filesystem; this coordination applies only to operations through the same mount view. Overlay reads require retained handles and stable object and ancestor identities; unsupported backends or changed read admission fail with `ENOTSUP`. Overlays with two stock MemoryFileSystem layers support race-safe patch publication and confined directory creation/removal. Publication checks both layers, retains logical directory identity across copy-up, and leaves lower bytes intact; wrapped or customized layers remain unsupported. Overlays are not transactions; cancellation and cleanup do not guarantee rollback. Cross-mount rename can fail with `EXDEV`.
 - **Remote storage is not a POSIX disk.** S3 and WebDAV do not provide hardlinks or symlinks. S3 rename is non-atomic and may leave partial copies/deletions; `S3RenameError` reports the phase and affected keys. Strong empty-only removal and conditional writes depend on backend support, not a prior listing.
 - **The bridges are partial Node compatibility layers.** No synchronous/callback API, file handles, watchers, bigint stats, flush/retry support, or `cp` dereference/timestamp-preservation options. Missing optional operations fail rather than being approximated with destructive alternatives.
-- **Browser support is filesystem-only.** The `browser` export condition selects the portable surface: memory, mounts, overlays, read-only, WebDAV, and the codec-based bridge. Real storage, S3, the Node bridge, and the configuration registry are not browser exports. WebDAV still needs server CORS support; no OPFS or directory-handle adapter is included. This does not make the SafeJS runtime browser-compatible.
+- **Browser support is filesystem-only.** The `browser` and `workerd` export conditions select the portable surface: memory, mounts, overlays, read-only, WebDAV, and the codec-based bridge. S3 is available through `fs/s3` with an explicit transport, including its portable mock. Real storage, the Node bridge, and the configuration registry are not browser exports. WebDAV still needs server CORS support; no OPFS or directory-handle adapter is included. This does not make the SafeJS runtime browser-compatible.
 - **Portable temporary names require secure randomness.** Browser overlay staging and portable bridge `mkdtemp` require `crypto.randomUUID` or `crypto.getRandomValues`; without either, they fail with `ENOTSUP` rather than use `Math.random`.
 - **Allocation and identity may be unknown.** Optional `FileStat.allocatedBytes` is provider-reported allocation, not logical length or reclaimable space. Do not infer identity from size, timestamps, or inode numbers across unrelated backends.
 

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

@@ -1,4 +1,4 @@
-import { posix } from "node:path";
+import { posix } from "#safe-fs-platform";
 export { assertPathWithin, isPathWithin, normalizePath, relativePath, resolvePath, validatePath } from "./virtual-path.js";
 export declare const posixPath: typeof posix;
 export declare const basename: typeof posix.basename;

package/dist/safe-fs/contracts/path.js

@@ -1,4 +1,4 @@
-import { posix } from "node:path";
+import { posix } from "#safe-fs-platform";
 export { assertPathWithin, isPathWithin, normalizePath, relativePath, resolvePath, validatePath } from "./virtual-path.js";
 export const posixPath = posix;
 export const basename = posix.basename;

package/dist/safe-fs/fs/object-authority.d.ts

@@ -5,8 +5,8 @@ import type { WireObjectMetadata, OpenFileObjectOptions, WireExactFileStat, Wire
  * not bearer authorization. All admitted operations drain before disposal. */
 export declare class ObjectAuthority {
     #private;
-    constructor(filesystem: FileSystem | Pick<FileSystem, "objects">, options: {
-        readonly maxHandles: number;
+    constructor(filesystem: FileSystem | Pick<FileSystem, "objects">, options?: {
+        readonly maxHandles?: number;
         readonly maxIoBytes?: number;
     });
     open(path: BytePath, options?: OpenFileObjectOptions): Promise<WireObjectHandle>;

package/dist/safe-fs/fs/object-authority.js

@@ -13,7 +13,7 @@ export class ObjectAuthority {
     #sequence = 0;
     #tail = Promise.resolve();
     #disposal;
-    constructor(filesystem, options) {
+    constructor(filesystem, options = {}) {
         const backend = filesystem.objects;
         // One issued authority keeps its qualified namespace. Bound operations
         // observe live backend state without accepting replacement capabilities.
@@ -27,11 +27,12 @@ export class ObjectAuthority {
                 specialFiles: Object.freeze({ ...specialFiles }),
             });
         }
-        this.#maxHandles = options.maxHandles;
-        this.#maxIoBytes = options.maxIoBytes ?? 1048576;
-        if (!Number.isSafeInteger(this.#maxHandles) || this.#maxHandles < 1 ||
-            !Number.isSafeInteger(this.#maxIoBytes) || this.#maxIoBytes < 1)
-            throw new FsError("EINVAL");
+        this.#maxHandles = options.maxHandles ?? Infinity;
+        this.#maxIoBytes = options.maxIoBytes ?? Infinity;
+        for (const limit of [this.#maxHandles, this.#maxIoBytes]) {
+            if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 1))
+                throw new FsError("EINVAL");
+        }
     }
     #run(operation) {
         if (this.#disposal)

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

@@ -3,5 +3,5 @@ import type { S3HeadOutput, S3ObjectInput } from "./transport.js";
 export { registerS3EntryOwner, getOwnedS3Entry, compareOwnedS3Entries } from "./registry.js";
 export type { OwnedS3Entry } from "./registry.js";
 export declare function recordMockS3Head(output: S3HeadOutput, input: S3ObjectInput, storage: object): void;
-export declare function queryS3Head(input: S3ObjectInput, action: () => Promise<S3HeadOutput>): Promise<S3HeadOutput>;
+export declare function queryS3Head(input: S3ObjectInput, action: (query: S3ObjectInput) => Promise<S3HeadOutput>): Promise<S3HeadOutput>;
 export declare function recordS3Stat(filesystem: FileSystem, path: string, stat: FileStat, metadata: S3HeadOutput | undefined): void;

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

@@ -1,25 +1,32 @@
-import { AsyncLocalStorage } from "node:async_hooks";
 import { recordS3Observation } from "./registry.js";
 export { registerS3EntryOwner, getOwnedS3Entry, compareOwnedS3Entries } from "./registry.js";
-const queries = new AsyncLocalStorage();
+const queryKey = Symbol("s3-head-query");
+const queries = new WeakMap();
 const providerHeads = new WeakMap();
 const acceptedHeads = new WeakMap();
 export function recordMockS3Head(output, input, storage) {
-    const query = queries.getStore();
+    const token = input[queryKey];
+    const query = token && queries.get(token);
     if (query && query.Bucket === input.Bucket && query.Key === input.Key) {
         providerHeads.set(output, { query, entry: { storage, key: input.Key } });
     }
 }
 export async function queryS3Head(input, action) {
-    const query = { ...input };
-    return queries.run(query, async () => {
-        const output = await action();
+    const token = Object.freeze({});
+    const query = Object.freeze({ ...input });
+    const forwarded = { ...query, [queryKey]: token };
+    queries.set(token, query);
+    try {
+        const output = await action(forwarded);
         acceptedHeads.delete(output);
         const proof = providerHeads.get(output);
         if (proof?.query === query)
             acceptedHeads.set(output, proof.entry);
         return output;
-    });
+    }
+    finally {
+        queries.delete(token);
+    }
 }
 export function recordS3Stat(filesystem, path, stat, metadata) {
     if (!metadata)

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

@@ -1,4 +1,5 @@
-import { posix } from "node:path";
+import { posixPath as posix } from "../../contracts/portable-path.js";
+import { compareKeys } from "./key-order.js";
 import { FsError, isFsError } from "../../contracts/errors.js";
 import { composeAbortSignals } from "../../contracts/abort.js";
 import { collectBytes, readBytes } from "../../contracts/io.js";
@@ -263,7 +264,7 @@ export class S3FileSystem {
     async head(key, path, options) {
         try {
             const input = { Bucket: this.bucket, Key: key };
-            return await this.call("headObject", path, options, () => queryS3Head(input, () => this.transport.headObject(input, this.requestOptions(options))));
+            return await this.call("headObject", path, options, () => queryS3Head(input, query => this.transport.headObject(query, this.requestOptions(options))));
         }
         catch (error) {
             if (isFsError(error, "ENOENT") && serviceCode(error.cause) !== "NoSuchBucket")
@@ -593,7 +594,7 @@ export class S3FileSystem {
             for (const item of page.CommonPrefixes ?? [])
                 add(item.Prefix.slice(prefix.length, -1), "directory");
         }
-        return [...entries.values()].sort((left, right) => Buffer.compare(Buffer.from(left.name), Buffer.from(right.name)));
+        return [...entries.values()].sort((left, right) => compareKeys(left.name, right.name));
     }
     async tree(path, options) {
         const objects = new Map();

package/dist/safe-fs/fs/s3/key-order.d.ts

@@ -0,0 +1,2 @@
+/** S3 orders keys lexicographically by their UTF-8 bytes. */
+export declare function compareKeys(left: string, right: string): number;

package/dist/safe-fs/fs/s3/key-order.js

@@ -0,0 +1,11 @@
+/** S3 orders keys lexicographically by their UTF-8 bytes. */
+export function compareKeys(left, right) {
+    const encoder = new TextEncoder();
+    const a = encoder.encode(left), b = encoder.encode(right);
+    for (let index = 0; index < Math.min(a.length, b.length); index++) {
+        const difference = a[index] - b[index];
+        if (difference)
+            return difference;
+    }
+    return a.length - b.length;
+}

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

@@ -15,13 +15,10 @@ function utf8ByteLength(value) {
     }
     return bytes;
 }
-import { createHash } from "node:crypto";
+import { compareKeys } from "./key-order.js";
 import { collectBytes } from "../../contracts/io.js";
 import { recordMockS3Head } from "./authority.js";
 import { S3ServiceError } from "./transport.js";
-function compareKeys(left, right) {
-    return Buffer.compare(Buffer.from(left), Buffer.from(right));
-}
 export class MockS3Client {
     capabilities = Object.freeze({ conditionalPut: true, conditionalCopy: true, conditionalDelete: true, streamingRead: true, streamingWrite: true });
     buckets = new Map();
@@ -78,13 +75,13 @@ export class MockS3Client {
             Metadata: { ...object.metadata },
         };
     }
-    store(body, metadata = {}) {
+    async store(body, metadata = {}) {
         const metadataBytes = Object.entries(metadata).reduce((total, [key, value]) => total + utf8ByteLength(key) + utf8ByteLength(value), 0);
         if (metadataBytes > 2048)
             throw new S3ServiceError("MetadataTooLarge", 400);
         return {
             body: new Uint8Array(body),
-            etag: `"${createHash("md5").update(body).digest("hex")}"`,
+            etag: `"${Array.from(new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", new Uint8Array(body))), byte => byte.toString(16).padStart(2, "0")).join("")}"`,
             modified: new Date(this.now()),
             metadata: { ...metadata },
         };
@@ -104,6 +101,7 @@ export class MockS3Client {
         if (!(input.Body instanceof Uint8Array))
             throw new S3ServiceError("InvalidArgument", 400);
         input = { ...input, Body: new Uint8Array(input.Body), ...(input.Metadata ? { Metadata: { ...input.Metadata } } : {}) };
+        const object = await this.store(input.Body, input.Metadata);
         await this.begin("putObject", input, options);
         const bucket = this.bucket(input.Bucket);
         const previous = bucket.get(input.Key);
@@ -113,7 +111,6 @@ export class MockS3Client {
             || (input.IfMatch !== undefined && previous?.etag !== input.IfMatch)) {
             throw new S3ServiceError("PreconditionFailed", 412);
         }
-        const object = this.store(input.Body, input.Metadata);
         bucket.set(input.Key, object);
         return { ETag: object.etag };
     }
@@ -148,6 +145,8 @@ export class MockS3Client {
         const snapshot = { ...input, Body: new Uint8Array(), ...(input.Metadata ? { Metadata: { ...input.Metadata } } : {}) };
         await this.begin("putObject", snapshot, options);
         const body = await collectBytes(input.Body, { maxBytes: 5_000_000_000, ...(options?.abortSignal ? { signal: options.abortSignal } : {}) });
+        const object = await this.store(body, snapshot.Metadata);
+        options?.abortSignal?.throwIfAborted();
         const bucket = this.bucket(input.Bucket);
         const previous = bucket.get(input.Key);
         if (input.IfMatch !== undefined && !previous)
@@ -155,7 +154,6 @@ export class MockS3Client {
         if ((input.IfNoneMatch === "*" && previous) || (input.IfMatch !== undefined && previous?.etag !== input.IfMatch)) {
             throw new S3ServiceError("PreconditionFailed", 412);
         }
-        const object = this.store(body, snapshot.Metadata);
         bucket.set(input.Key, object);
         return { ETag: object.etag };
     }
@@ -184,7 +182,9 @@ export class MockS3Client {
         if (separator < 1)
             throw new S3ServiceError("InvalidArgument", 400);
         const source = this.object({ Bucket: decoded.slice(0, separator), Key: decoded.slice(separator + 1) });
-        if (input.CopySourceIfMatch !== undefined && input.CopySourceIfMatch !== source.etag) {
+        const copy = await this.store(source.body, input.MetadataDirective === "REPLACE" ? input.Metadata : source.metadata);
+        options?.abortSignal?.throwIfAborted();
+        if (input.CopySourceIfMatch !== undefined && input.CopySourceIfMatch !== this.object({ Bucket: decoded.slice(0, separator), Key: decoded.slice(separator + 1) }).etag) {
             throw new S3ServiceError("PreconditionFailed", 412);
         }
         const bucket = this.bucket(input.Bucket);
@@ -192,7 +192,6 @@ export class MockS3Client {
             throw new S3ServiceError("PreconditionFailed", 412);
         if (input.IfMatch !== undefined && bucket.get(input.Key)?.etag !== input.IfMatch)
             throw new S3ServiceError("PreconditionFailed", 412);
-        const copy = this.store(source.body, input.MetadataDirective === "REPLACE" ? input.Metadata : source.metadata);
         bucket.set(input.Key, copy);
         return { CopyObjectResult: { ETag: copy.etag, LastModified: new Date(copy.modified) } };
     }

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

@@ -3,7 +3,7 @@ import { validatePath } from "../contracts/virtual-path.js";
 import { finishCleanup } from "../contracts/cleanup.js";
 import { registerEntryView } from "./mount/comparison.js";
 import { getScopedTransportBudget, runScopedTransportBudget, withScopedTransportBudget } from "#safe-fs-platform";
-import { hasRegisteredS3FileSystem } from "../platform/transport-budget.js";
+import { hasRegisteredS3FileSystem, scopeTransportOptions } from "../platform/transport-budget.js";
 import { openRetainedResizeFile, retainedResizeCapabilities, ownedMutationCapabilities, requireOwnedMutation } from "./capabilities.js";
 import { createStagingCleanup, snapshotStagingCreation } from "./staging-cleanup.js";
 import { inspectStagingBindings, runStagingGuard, snapshotDirectoryAncestry, snapshotStagingResolution } from "./staging-ancestry.js";
@@ -400,9 +400,16 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
                 const result = Reflect.apply(method, original, args);
                 return property === "readStream" ? wrapStream(result, args[1]) : result;
             };
-            const dispatch = (...args) => hasRegisteredS3FileSystem
-                ? runScopedTransportBudget(admit, () => executeDispatch(args), credit)
-                : executeDispatch(args);
+            const dispatch = (...args) => {
+                if (!hasRegisteredS3FileSystem)
+                    return executeDispatch(args);
+                if (operations.has(property)) {
+                    const optionIndex = ["compareEntry", "createStagedFile", "utimes"].includes(String(property)) ? 3
+                        : ["writeFile", "appendFile", "writeStream", "rename", "copyFile", "link", "symlink", "access", "chmod", "truncate", "resizeFile", "publishFileConditional", "writeFileConditional", "publishStagedFile"].includes(String(property)) ? 2 : 1;
+                    args[optionIndex] = scopeTransportOptions((args[optionIndex] ?? {}), admit, credit);
+                }
+                return runScopedTransportBudget(admit, () => executeDispatch(args), credit);
+            };
             const scoped = property === "prepareStagingResolution"
                 ? async (path, options = {}) => {
                     const controls = resizeOptions({ ...options });

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

@@ -2,6 +2,7 @@ import type { PlatformComparisonCallback } from "#safe-fs-platform";
 import type { ByteSource } from "../../contracts/io.js";
 import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 import type { FileDescriptor, OpenFileOptions } from "../../contracts/descriptor.js";
+import type { XmlLimits } from "./xml.js";
 export type WebDavFetch = (url: string, init: RequestInit) => Promise<Response>;
 export interface WebDavAtomicEmptyDirectoryRequest {
     readonly operation: "atomic-empty-rmdir/v1";
@@ -24,11 +25,13 @@ 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. */
+    /** Response ceiling; unlimited unless configured. */
     readonly maxResponseBytes?: number;
-    /** Metadata response ceiling; defaults to 1 MiB before decoding/parsing. */
+    /** Metadata response ceiling before decoding/parsing; unlimited unless configured. */
     readonly maxXmlBytes?: number;
     readonly maxEntries?: number;
+    /** XML structure ceilings; unlimited unless configured. */
+    readonly xmlLimits?: Pick<XmlLimits, "maxNodes" | "maxContentNodes" | "maxDepth" | "maxAttributes">;
     /** Per-request and aggregate stat/write-preflight walk timeout; unlimited unless configured. */
     readonly timeoutMs?: number;
     readonly overwritePolicy?: "lock" | "etag";
@@ -78,6 +81,7 @@ export declare class WebDavFileSystem implements FileSystem {
     private readonly maxResponseBytes;
     private readonly maxXmlBytes;
     private readonly maxEntries;
+    private readonly xmlLimits;
     private readonly timeoutMs;
     private readonly walkDeadlines;
     private readonly overwritePolicy;

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

@@ -234,6 +234,7 @@ export class WebDavFileSystem {
     maxResponseBytes;
     maxXmlBytes;
     maxEntries;
+    xmlLimits;
     timeoutMs;
     walkDeadlines = new WeakMap();
     overwritePolicy;
@@ -288,8 +289,11 @@ export class WebDavFileSystem {
             removeDirectory: this.atomicEmptyDirectory !== undefined,
             streamingAppend: this.requestStreamSupport !== false,
         });
-        this.maxResponseBytes = options.maxResponseBytes === undefined ? 16 * 1024 * 1024 : positive(options.maxResponseBytes, "maxResponseBytes", false, true);
-        this.maxXmlBytes = options.maxXmlBytes === undefined ? 1024 * 1024 : positive(options.maxXmlBytes, "maxXmlBytes", false, true);
+        this.maxResponseBytes = options.maxResponseBytes === undefined ? Infinity : positive(options.maxResponseBytes, "maxResponseBytes", false, true);
+        this.maxXmlBytes = options.maxXmlBytes === undefined ? Infinity : positive(options.maxXmlBytes, "maxXmlBytes", false, true);
+        this.xmlLimits = Object.freeze({ ...options.xmlLimits });
+        for (const [name, value] of Object.entries(this.xmlLimits))
+            positive(value, name, false, true);
         this.maxEntries = options.maxEntries === undefined ? Infinity : positive(options.maxEntries, "maxEntries", false, true);
         this.timeoutMs = options.timeoutMs === undefined ? undefined : positive(options.timeoutMs, "timeoutMs");
         this.overwritePolicy = options.overwritePolicy ?? "lock";
@@ -565,8 +569,7 @@ export class WebDavFileSystem {
             ? "utf-16le" : (data[0] === 0xfe && data[1] === 0xff) || (data[0] === 0 && data[1] === 0x3c) ? "utf-16be" : "utf-8";
         const parser = parseXmlSteps(new TextDecoder(encoding, { fatal: true }).decode(data), {
             ...(maxResponses === undefined ? {} : { maxResponses }),
-            maxNodes: 100_000, maxContentNodes: 100_000, maxDepth: 256,
-            maxAttributes: 100_000, maxTextLength: this.maxXmlBytes,
+            ...this.xmlLimits, maxTextLength: this.maxXmlBytes,
         });
         let work = 0;
         try {

package/dist/safe-fs/platform/browser.d.ts

@@ -1,3 +1,4 @@
+export { posixPath as posix } from "../contracts/portable-path.js";
 import type { FsOptions } from "../contracts/filesystem.js";
 import type { ScopedTransportBudgetFrame } from "./transport-budget.js";
 export type PlatformErrno = number | undefined;
@@ -23,4 +24,4 @@ export declare const comparisonContext: Readonly<{
 export declare function getScopedTransportBudget(): readonly ScopedTransportBudgetFrame[] | undefined;
 export declare function withScopedTransportBudget<Result>(frames: readonly ScopedTransportBudgetFrame[] | undefined, action: () => Result): Result;
 export declare function runScopedTransportBudget<Result>(_admit: (options?: FsOptions) => void, action: () => Result, _credit?: number): Result;
-export declare function chargeScopedTransportCall(options?: FsOptions): never;
+export declare function chargeScopedTransportCall(options?: FsOptions): void;

package/dist/safe-fs/platform/browser.js

@@ -1,7 +1,9 @@
 import { FsError } from "../contracts/errors.js";
+export { posixPath as posix } from "../contracts/portable-path.js";
+import { chargeTransportOptions } from "./transport-budget.js";
 export const platform = Object.freeze({
     nativeFileSystem: Object.freeze({ open: false, permissions: false, timestamps: false, conditionalChmod: false, trustedOwnedStaging: false, atomicRename: false }),
-    maxCollectionBytes: 32 * 1024 * 1024,
+    maxCollectionBytes: Infinity,
     errno(_code) {
         return undefined;
     },
@@ -39,8 +41,7 @@ export const comparisonContext = Object.freeze({
         }
     }
 });
-// Scoped browser filesystems charge logical operations directly. S3 remains
-// Node-only; never pretend to provide its async transport budget context here.
+// Browser operations carry request budgets in their options, including streams.
 export function getScopedTransportBudget() {
     return undefined;
 }
@@ -54,5 +55,5 @@ export function runScopedTransportBudget(_admit, action, _credit = 1) {
 }
 export function chargeScopedTransportCall(options) {
     options?.signal?.throwIfAborted();
-    throw new FsError("ENOTSUP", { message: "S3 transport budget contexts require Node" });
+    chargeTransportOptions(options);
 }

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

@@ -1,3 +1,4 @@
+export { posix } from "node:path";
 import type { FsOptions } from "../contracts/filesystem.js";
 import { type ScopedTransportBudgetFrame } from "./transport-budget.js";
 export type PlatformErrno = number;

package/dist/safe-fs/platform/node.js

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+export { posix } from "node:path";
 import { randomUUID } from "node:crypto";
 import * as util from "node:util";
 import { constants } from "node:os";

package/dist/safe-fs/platform/transport-budget.d.ts

@@ -5,3 +5,5 @@ export interface ScopedTransportBudgetFrame {
 }
 export declare let hasRegisteredS3FileSystem: boolean;
 export declare function enableS3TransportBudget(): void;
+export declare function scopeTransportOptions(options: FsOptions, admit: (options?: FsOptions) => void, credit: number): FsOptions;
+export declare function chargeTransportOptions(options?: FsOptions): void;

package/dist/safe-fs/platform/transport-budget.js

@@ -2,3 +2,16 @@ export let hasRegisteredS3FileSystem = false;
 export function enableS3TransportBudget() {
     hasRegisteredS3FileSystem = true;
 }
+const budgetKey = Symbol("scoped-transport-budget");
+export function scopeTransportOptions(options, admit, credit) {
+    const parent = options[budgetKey] ?? [];
+    return { ...options, [budgetKey]: [...parent, { credit, admit }] };
+}
+export function chargeTransportOptions(options) {
+    for (const frame of options?.[budgetKey] ?? []) {
+        if (frame.credit > 0)
+            frame.credit--;
+        else
+            frame.admit(options);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-fs",
-  "version": "0.1.735",
+  "version": "0.1.737",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",
@@ -13,17 +13,21 @@
   "exports": {
     ".": {
       "types": {
+        "workerd": "./dist/safe-fs/core.d.ts",
         "browser": "./dist/safe-fs/core.d.ts",
         "default": "./dist/safe-fs/index.d.ts"
       },
+      "workerd": "./dist/safe-fs/core.js",
       "browser": "./dist/safe-fs/core.js",
       "import": "./dist/safe-fs/index.js"
     },
     "./contracts": {
       "types": {
+        "workerd": "./dist/safe-fs/core.d.ts",
         "browser": "./dist/safe-fs/core.d.ts",
         "default": "./dist/safe-fs/contracts/index.d.ts"
       },
+      "workerd": "./dist/safe-fs/core.js",
       "browser": "./dist/safe-fs/core.js",
       "import": "./dist/safe-fs/contracts/index.js"
     },
@@ -86,11 +90,7 @@
       "import": "./dist/safe-fs/fs/s3/http/index.js"
     },
     "./fs/s3": {
-      "types": {
-        "browser": "./dist/safe-fs/node-unavailable.d.ts",
-        "default": "./dist/safe-fs/fs/s3/index.d.ts"
-      },
-      "browser": null,
+      "types": "./dist/safe-fs/fs/s3/index.d.ts",
       "import": "./dist/safe-fs/fs/s3/index.js"
     },
     "./fs/webdav": {