@poe-platform/safe-fs 0.1.734 → 0.1.736

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,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+export { posix } from "node:path";
 import type { FsOptions } from "../contracts/filesystem.js";
 import { type ScopedTransportBudgetFrame } from "./transport-budget.js";
 export type PlatformErrno = number;
@@ -15,7 +15,7 @@ export declare const platform: Readonly<{
     maxCollectionBytes: number;
     errno(code: string): PlatformErrno;
     callbackAuthorities: true;
-    randomUUID: typeof randomUUID;
+    randomUUID: () => string;
 }>;
 export declare const comparisonContext: Readonly<{
     active(_options: FsOptions): boolean;

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";
@@ -25,7 +26,7 @@ export const platform = Object.freeze({
         return errno;
     },
     callbackAuthorities: true,
-    randomUUID
+    randomUUID: randomUUID
 });
 export const comparisonContext = Object.freeze({
     active(_options) {

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/dist/safe-fs/xml.js

@@ -6,21 +6,16 @@ export class XmlLimitError extends SyntaxError {
     }
 }
 function* find(source, needle, start) {
-    let work = 0;
-    for (let offset = start; offset < source.length; offset++) {
-        if (source.startsWith(needle, offset)) {
-            if (work)
-                yield work;
-            return offset;
-        }
-        if (++work === 512) {
-            yield work;
-            work = 0;
-        }
+    const found = source.indexOf(needle, start);
+    const end = found < 0 ? source.length : found;
+    let remaining = end - start;
+    while (remaining >= 512) {
+        yield 512;
+        remaining -= 512;
     }
-    if (work)
-        yield work;
-    return -1;
+    if (remaining > 0)
+        yield remaining;
+    return found;
 }
 const xmlNamespace = "http://www.w3.org/XML/1998/namespace";
 const xmlnsNamespace = "http://www.w3.org/2000/xmlns/";
@@ -47,6 +42,30 @@ function namePart(point) {
         || (point >= 48 && point <= 57) || (point >= 0x300 && point <= 0x36f)
         || (point >= 0x203f && point <= 0x2040);
 }
+function qualifiedNameSync(name) {
+    let prefix = "";
+    let start = 0;
+    let first = true;
+    for (let offset = 0; offset < name.length;) {
+        const point = name.codePointAt(offset);
+        if (point === 58) {
+            if (start !== 0 || first)
+                invalid("invalid qualified name");
+            prefix = name.slice(0, offset);
+            start = offset + 1;
+            first = true;
+        }
+        else {
+            if (!(first ? nameStart(point) : namePart(point)))
+                invalid("invalid qualified name");
+            first = false;
+        }
+        offset += point > 0xffff ? 2 : 1;
+    }
+    if (first)
+        invalid("invalid qualified name");
+    return [prefix, name.slice(start)];
+}
 function* qualifiedName(name) {
     let prefix = "";
     let start = 0;
@@ -258,67 +277,81 @@ export function* parseXmlSteps(input, limits = {}) {
         if (++contentNodes > maxContentNodes)
             throw new XmlLimitError("maxContentNodes", "XML content node limit exceeded");
     };
-    const whitespace = function* () {
-        let work = 0;
-        while (offset < source.length && " \t\n\r".includes(source[offset])) {
+    let pendingWork = 0;
+    const skipWhitespace = () => {
+        const start = offset;
+        while (offset < source.length) {
+            const c = source.charCodeAt(offset);
+            if (c !== 32 && c !== 9 && c !== 10 && c !== 13)
+                break;
             offset++;
-            if (++work === 512) {
-                yield work;
-                work = 0;
-            }
         }
-        if (work)
-            yield work;
+        return offset - start;
     };
-    const readName = function* () {
+    const scanName = () => {
         const start = offset;
-        while (offset < source.length && !" \t\r\n/=>?".includes(source[offset])) {
+        while (offset < source.length) {
+            const c = source.charCodeAt(offset);
+            if (c === 32 || c === 9 || c === 13 || c === 10 || c === 47 || c === 61 || c === 62 || c === 63)
+                break;
             offset++;
-            if ((offset - start) % 512 === 0)
-                yield 512;
         }
-        if ((offset - start) % 512)
-            yield (offset - start) % 512;
         const name = source.slice(start, offset);
-        yield* qualifiedName(name);
-        return name;
+        const [prefix, localName] = qualifiedNameSync(name);
+        return [name, prefix, localName, (offset - start) * 2];
     };
-    const appendText = function* (text, kind = "text") {
-        admitText(text);
-        const parent = stack.at(-1);
-        if (parent) {
-            parent.element.text += text;
-            if (text.length || kind === "cdata") {
-                admitContent();
-                if (retainContent)
-                    parent.content.push({ kind, text });
+    while (offset < source.length) {
+        pendingWork += 1;
+        if (pendingWork >= 512) {
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
             }
         }
-        else {
-            for (let index = 0; index < text.length; index++) {
-                if (!" \t\r\n".includes(text[index]))
-                    invalid("text outside the root");
-                if ((index + 1) % 512 === 0)
-                    yield 512;
-            }
-            if (text.length % 512)
-                yield text.length % 512;
-            if (text.length) {
-                admitContent();
-                if (retainContent)
-                    (root ? epilog : prolog).push({ kind, text });
+        if (source.charCodeAt(offset) !== 60) {
+            const next = source.indexOf("<", offset);
+            const endPos = next < 0 ? source.length : next;
+            const text = source.slice(offset, endPos);
+            pendingWork += (endPos - offset) + text.length;
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
             }
-        }
-    };
-    while (offset < source.length) {
-        yield 1;
-        if (source[offset] !== "<") {
-            const next = yield* find(source, "<", offset);
-            const text = source.slice(offset, next < 0 ? source.length : next);
-            if ((yield* find(text, "]]>", 0)) >= 0)
+            if (text.indexOf("]]>") >= 0)
                 invalid("CDATA terminator in text");
-            yield* appendText(stack.length ? yield* entities(text) : text);
-            offset += text.length;
+            const resolved = stack.length ? (text.indexOf("&") < 0 ? (pendingWork += text.length, text) : yield* entities(text)) : text;
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
+            }
+            admitText(resolved);
+            const parent = stack.at(-1);
+            if (parent) {
+                parent.element.text += resolved;
+                if (resolved.length) {
+                    admitContent();
+                    if (retainContent)
+                        parent.content.push({ kind: "text", text: resolved });
+                }
+            }
+            else {
+                for (let index = 0; index < resolved.length; index++) {
+                    const c = resolved.charCodeAt(index);
+                    if (c !== 32 && c !== 9 && c !== 13 && c !== 10)
+                        invalid("text outside the root");
+                }
+                pendingWork += resolved.length;
+                while (pendingWork >= 512) {
+                    yield 512;
+                    pendingWork -= 512;
+                }
+                if (resolved.length) {
+                    admitContent();
+                    if (retainContent)
+                        (root ? epilog : prolog).push({ kind: "text", text: resolved });
+                }
+            }
+            offset = endPos;
         }
         else if (source.startsWith("<!--", offset)) {
             const end = yield* find(source, "-->", offset + 4);
@@ -340,13 +373,24 @@ export function* parseXmlSteps(input, limits = {}) {
             const end = yield* find(source, "]]>", offset + 9);
             if (end < 0)
                 invalid("unterminated CDATA");
-            yield* appendText(source.slice(offset + 9, end), "cdata");
+            const cdataText = source.slice(offset + 9, end);
+            admitText(cdataText);
+            const parent = stack.at(-1);
+            parent.element.text += cdataText;
+            admitContent();
+            if (retainContent)
+                parent.content.push({ kind: "cdata", text: cdataText });
             offset = end + 3;
         }
         else if (source.startsWith("<?", offset)) {
             const start = offset;
             offset += 2;
-            const target = yield* readName();
+            const [target, , , wName] = scanName();
+            pendingWork += wName;
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
+            }
             const end = yield* find(source, "?>", offset);
             if (end < 0)
                 invalid("unterminated processing instruction");
@@ -363,15 +407,15 @@ export function* parseXmlSteps(input, limits = {}) {
                 invalid("invalid processing instruction");
             if (!(target.length === 3 && target.toLowerCase() === "xml")) {
                 const parent = stack.at(-1);
-                let start = 0;
-                while (start < content.length && " \t\n\r".includes(content[start])) {
-                    start++;
-                    if (start % 512 === 0)
-                        yield 512;
+                let wsStart = 0;
+                while (wsStart < content.length && " \t\n\r".includes(content[wsStart]))
+                    wsStart++;
+                pendingWork += wsStart;
+                while (pendingWork >= 512) {
+                    yield 512;
+                    pendingWork -= 512;
                 }
-                if (start % 512)
-                    yield start % 512;
-                const text = content.slice(start);
+                const text = content.slice(wsStart);
                 admitText(text);
                 admitContent();
                 if (retainContent) {
@@ -383,92 +427,129 @@ export function* parseXmlSteps(input, limits = {}) {
         else if (source.startsWith("<!", offset)) {
             invalid("DTD and entity declarations are forbidden");
         }
-        else if (source.startsWith("</", offset)) {
+        else if (source.charCodeAt(offset + 1) === 47) {
             offset += 2;
-            const name = yield* readName();
-            yield* whitespace();
+            const [name, , , wName] = scanName();
+            pendingWork += wName + skipWhitespace();
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
+            }
             if (source[offset++] !== ">" || stack.pop()?.name !== name)
                 invalid("mismatched closing tag");
         }
         else {
             offset++;
-            const name = yield* readName();
+            const [name, prefix, localName, wName] = scanName();
+            pendingWork += wName;
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
+            }
             const attributes = new Map();
+            const attrMeta = [];
             let namespaces = stack.at(-1)?.namespaces ?? new Map([["xml", xmlNamespace]]);
             let ownsNamespaces = stack.length === 0;
             while (true) {
-                const beforeSpace = offset;
-                yield* whitespace();
-                if (source[offset] === "/" || source[offset] === ">")
+                const ws = skipWhitespace();
+                pendingWork += ws;
+                while (pendingWork >= 512) {
+                    yield 512;
+                    pendingWork -= 512;
+                }
+                const ch = source.charCodeAt(offset);
+                if (ch === 47 || ch === 62)
                     break;
-                if (offset === beforeSpace)
+                if (ws === 0)
                     invalid("attributes require whitespace");
-                const attribute = yield* readName();
+                const [attribute, attrPrefix, attrLocal, wAttr] = scanName();
+                pendingWork += wAttr;
+                while (pendingWork >= 512) {
+                    yield 512;
+                    pendingWork -= 512;
+                }
                 if (attributes.has(attribute))
                     invalid("duplicate attribute");
                 if (++attributeCount > maxAttributes)
                     throw new XmlLimitError("maxAttributes", "XML attribute limit exceeded");
                 if (attributes.size >= maxAttributesPerElement)
                     throw new XmlLimitError("maxAttributesPerElement", "XML attribute limit exceeded");
-                yield* whitespace();
+                pendingWork += skipWhitespace();
                 if (source[offset++] !== "=")
                     invalid("missing attribute equals");
-                yield* whitespace();
+                pendingWork += skipWhitespace();
                 const quote = source[offset++];
                 if (quote !== '"' && quote !== "'")
                     invalid("unquoted attribute");
-                const end = yield* find(source, quote, offset);
+                const end = source.indexOf(quote, offset);
+                const scanLen = (end < 0 ? source.length : end) - offset;
+                pendingWork += scanLen;
+                while (pendingWork >= 512) {
+                    yield 512;
+                    pendingWork -= 512;
+                }
                 if (end < 0)
                     invalid("unterminated attribute");
                 const raw = source.slice(offset, end);
-                if ((yield* find(raw, "<", 0)) >= 0)
+                pendingWork += raw.length * 2;
+                while (pendingWork >= 512) {
+                    yield 512;
+                    pendingWork -= 512;
+                }
+                if (raw.indexOf("<") >= 0)
                     invalid("less-than in attribute");
-                let normalized = "";
-                for (let index = 0; index < raw.length; index++) {
-                    const character = raw[index];
-                    normalized += character === "\t" || character === "\n" || character === "\r" ? " " : character;
-                    if ((index + 1) % 512 === 0)
-                        yield 512;
+                const normalized = /[\t\n\r]/.test(raw) ? raw.replace(/[\t\n\r]/g, " ") : raw;
+                const value = normalized.indexOf("&") < 0 ? (pendingWork += normalized.length, normalized) : yield* entities(normalized);
+                while (pendingWork >= 512) {
+                    yield 512;
+                    pendingWork -= 512;
                 }
-                if (raw.length % 512)
-                    yield raw.length % 512;
-                const value = yield* entities(normalized);
                 admitText(value);
                 attributes.set(attribute, value);
+                attrMeta.push([attribute, attrPrefix, attrLocal]);
                 offset = end + 1;
                 if (attribute === "xmlns" || attribute.startsWith("xmlns:")) {
-                    const prefix = attribute === "xmlns" ? "" : attribute.slice(6);
-                    if (prefix === "xmlns" || value === xmlnsNamespace
-                        || (prefix === "xml") !== (value === xmlNamespace)
-                        || (prefix !== "" && value === ""))
+                    const nsPrefix = attribute === "xmlns" ? "" : attribute.slice(6);
+                    if (nsPrefix === "xmlns" || value === xmlnsNamespace
+                        || (nsPrefix === "xml") !== (value === xmlNamespace)
+                        || (nsPrefix !== "" && value === ""))
                         invalid("invalid namespace binding");
                     if (!ownsNamespaces) {
                         const copy = new Map();
                         for (const [key, uri] of namespaces) {
                             copy.set(key, uri);
-                            yield 1;
+                            pendingWork += 1;
                         }
                         namespaces = copy;
                         ownsNamespaces = true;
                     }
-                    namespaces.set(prefix, value);
+                    namespaces.set(nsPrefix, value);
                     if (namespaces.size > maxNamespaces)
                         throw new XmlLimitError("maxNamespaces", "XML namespace scope limit exceeded");
                 }
             }
-            const expanded = new Set();
-            for (const attribute of attributes.keys()) {
-                if (attribute === "xmlns" || attribute.startsWith("xmlns:"))
-                    continue;
-                const [prefix, localName] = yield* qualifiedName(attribute);
-                if (prefix && !namespaces.has(prefix))
-                    invalid("unbound attribute prefix");
-                const key = JSON.stringify([prefix ? namespaces.get(prefix) : "", localName]);
-                if (expanded.has(key))
-                    invalid("duplicate expanded attribute");
-                expanded.add(key);
+            if (attrMeta.length > 0) {
+                const expanded = attrMeta.length > 1 ? new Set() : undefined;
+                for (let i = 0; i < attrMeta.length; i++) {
+                    const [attribute, attrPrefix, attrLocal] = attrMeta[i];
+                    if (attribute === "xmlns" || attribute.startsWith("xmlns:"))
+                        continue;
+                    pendingWork += attribute.length;
+                    if (attrPrefix && !namespaces.has(attrPrefix))
+                        invalid("unbound attribute prefix");
+                    if (expanded) {
+                        const key = `${attrPrefix ? namespaces.get(attrPrefix) : ""}\0${attrLocal}`;
+                        if (expanded.has(key))
+                            invalid("duplicate expanded attribute");
+                        expanded.add(key);
+                    }
+                }
+            }
+            pendingWork += name.length;
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
             }
-            const [prefix, localName] = yield* qualifiedName(name);
             if (prefix === "xmlns" || (prefix && !namespaces.has(prefix)))
                 invalid("unbound element prefix");
             if (++nodes > maxNodes)
@@ -479,12 +560,19 @@ export function* parseXmlSteps(input, limits = {}) {
             limits.onElement?.({ name, namespace, localName }, stack.at(-1)?.element, stack.length + 1);
             admitContent();
             const retainedAttributes = [];
-            for (const [attribute, value] of retainContent ? attributes : []) {
-                const [prefix, localName] = yield* qualifiedName(attribute);
-                admitContent();
-                retainedAttributes.push({ name: attribute, localName,
-                    namespace: attribute === "xmlns" || prefix === "xmlns" ? xmlnsNamespace : prefix ? namespaces.get(prefix) : "", value });
-                yield 1;
+            if (retainContent) {
+                for (let i = 0; i < attrMeta.length; i++) {
+                    const [attribute, attrPrefix, attrLocal] = attrMeta[i];
+                    const value = attributes.get(attribute);
+                    admitContent();
+                    retainedAttributes.push({ name: attribute, localName: attrLocal,
+                        namespace: attribute === "xmlns" || attrPrefix === "xmlns" ? xmlnsNamespace : attrPrefix ? namespaces.get(attrPrefix) : "", value });
+                    pendingWork += attribute.length + 1;
+                }
+            }
+            while (pendingWork >= 512) {
+                yield 512;
+                pendingWork -= 512;
             }
             const content = retainContent ? [] : undefined;
             const element = { kind: "element", name, namespace, localName, children: [], text: "", content: content ?? emptyContent, attributes: retainContent ? retainedAttributes : emptyAttributes, namespaces: retainContent ? namespaces : emptyNamespaces, ...(root === undefined && retainContent ? { prolog, epilog, ...(declaration === undefined ? {} : { declaration }) } : {}) };
@@ -506,6 +594,10 @@ export function* parseXmlSteps(input, limits = {}) {
                 stack.push({ element, content, name, namespaces });
         }
     }
+    if (pendingWork > 0) {
+        yield pendingWork;
+        pendingWork = 0;
+    }
     if (stack.length || !root)
         invalid("incomplete document");
     return root;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-fs",
-  "version": "0.1.734",
+  "version": "0.1.736",
   "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": {