@poe-platform/safe-fs 0.1.728 → 0.1.730

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

@@ -3,20 +3,26 @@ export declare class MemoryLedger {
     readonly limits: Readonly<MemoryFileSystemLimits>;
     private retainedBytes;
     private metadataUnits;
+    readonly maxFileBytesSmi: number;
+    readonly maxRetainedBytesSmi: number;
+    readonly maxMetadataUnitsSmi: number;
+    readonly hasInfiniteRetained: boolean;
     constructor(limits: Readonly<MemoryFileSystemLimits>);
     get availableBytes(): number;
+    canPreallocate64(nameBytes: number): boolean;
     fileSize(length: number, syscall: string, path: string): void;
     check(bytes: number, units: number, syscall: string, path: string): void;
     reserve(bytes: number, units: number, syscall: string, path: string): void;
     release(bytes: number, units: number): void;
 }
 export declare class MemoryAllocation {
-    readonly data: Uint8Array;
-    private readonly ledger;
     private references;
+    readonly data: Uint8Array;
+    private ledger;
     constructor(data: Uint8Array, ledger: MemoryLedger);
     retain(): void;
     release(): void;
     isReleased64(): boolean;
-    reuse(): void;
+    detachLedger(dummyLedger: MemoryLedger): void;
+    reuse(ledger?: MemoryLedger): void;
 }

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

@@ -1,21 +1,41 @@
 import { FsError } from "../../contracts/errors.js";
+const MAX_SMI = 1073741823;
 export class MemoryLedger {
     limits;
     retainedBytes = 0;
     metadataUnits = 0;
+    maxFileBytesSmi;
+    maxRetainedBytesSmi;
+    maxMetadataUnitsSmi;
+    hasInfiniteRetained;
     constructor(limits) {
         this.limits = limits;
+        this.maxFileBytesSmi = limits.maxFileBytes >= MAX_SMI ? MAX_SMI : (limits.maxFileBytes | 0);
+        this.maxRetainedBytesSmi = limits.maxRetainedBytes >= MAX_SMI ? MAX_SMI : (limits.maxRetainedBytes | 0);
+        this.maxMetadataUnitsSmi = limits.maxMetadataUnits >= MAX_SMI ? MAX_SMI : (limits.maxMetadataUnits | 0);
+        this.hasInfiniteRetained = limits.maxRetainedBytes === Infinity;
     }
     get availableBytes() {
         const max = this.limits.maxRetainedBytes;
         return max === Infinity ? Infinity : max - this.retainedBytes;
     }
+    canPreallocate64(nameBytes) {
+        return this.maxFileBytesSmi >= 64 && (this.hasInfiniteRetained || this.maxRetainedBytesSmi - this.retainedBytes > 65536 + nameBytes);
+    }
     fileSize(length, syscall, path) {
+        if ((length | 0) === length && length >= 0 && length <= this.maxFileBytesSmi)
+            return;
         if (!Number.isSafeInteger(length) || length < 0 || length > this.limits.maxFileBytes) {
             throw new FsError("EFBIG", { syscall, path });
         }
     }
     check(bytes, units, syscall, path) {
+        if ((bytes | 0) === bytes && bytes >= 0 &&
+            (units | 0) === units && units >= 0 &&
+            this.retainedBytes <= this.maxRetainedBytesSmi - bytes &&
+            this.metadataUnits <= this.maxMetadataUnitsSmi - units) {
+            return;
+        }
         const maxRetained = this.limits.maxRetainedBytes;
         const maxUnits = this.limits.maxMetadataUnits;
         if (!Number.isSafeInteger(bytes) || bytes < 0 ||
@@ -26,6 +46,14 @@ export class MemoryLedger {
         }
     }
     reserve(bytes, units, syscall, path) {
+        if ((bytes | 0) === bytes && bytes >= 0 &&
+            (units | 0) === units && units >= 0 &&
+            this.retainedBytes <= this.maxRetainedBytesSmi - bytes &&
+            this.metadataUnits <= this.maxMetadataUnitsSmi - units) {
+            this.retainedBytes = (this.retainedBytes + bytes) | 0;
+            this.metadataUnits = (this.metadataUnits + units) | 0;
+            return;
+        }
         this.check(bytes, units, syscall, path);
         this.retainedBytes += bytes;
         this.metadataUnits += units;
@@ -39,9 +67,6 @@ export class MemoryLedger {
     }
 }
 export class MemoryAllocation {
-    data;
-    ledger;
-    references = 1;
     constructor(data, ledger) {
         this.data = data;
         this.ledger = ledger;
@@ -58,8 +83,16 @@ export class MemoryAllocation {
     isReleased64() {
         return this.references === 0 && this.data.byteLength === 64;
     }
-    reuse() {
+    detachLedger(dummyLedger) {
+        this.ledger = dummyLedger;
+    }
+    reuse(ledger) {
         this.references = 1;
+        if (ledger !== undefined)
+            this.ledger = ledger;
         this.data.fill(0);
     }
 }
+Object.assign(MemoryAllocation.prototype, {
+    references: 1,
+});

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

@@ -188,7 +188,7 @@ export class MountFileSystem {
                     && await this.supportsDirectoryValidation(location.path.slice(0, location.path.lastIndexOf("/")) || "/", options, true)
                 : this.capabilities.conditionalChmod;
             const { synchronousDirectoryValidation: ignoredValidation, synchronousStagingResolution: ignoredResolution, ...ordinary } = resize;
-            const withOpen = { ...ordinary, ...(conditionalChmod === undefined ? {} : { conditionalChmod }), ...(resolution === undefined ? {} : { synchronousStagingResolution: resolution }), ...(validation === undefined ? {} : { synchronousDirectoryValidation: validation }), atomicStagingAncestry: ancestry, ...(typeof location.mount.backend.open === "function" ? {} : { open: false }) };
+            const withOpen = { ...ordinary, retainedStagingWrite: false, ...(conditionalChmod === undefined ? {} : { conditionalChmod }), ...(resolution === undefined ? {} : { synchronousStagingResolution: resolution }), ...(validation === undefined ? {} : { synchronousDirectoryValidation: validation }), atomicStagingAncestry: ancestry, ...(typeof location.mount.backend.open === "function" ? {} : { open: false }) };
             const capabilities = location.synthetic ? { ...withOpen, open: false, retainedRead: false }
                 : retainedResizeCapabilities(location.mount.backend, retainedReadCapabilities(location.mount.backend, withOpen));
             if (location.synthetic)

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

@@ -36,7 +36,9 @@ function hasCode(error, code) {
 function fail(code, path, message) {
     throw new FsError(code, { syscall: "overlay", path, ...(message === undefined ? {} : { message }) });
 }
-function integer(value, path) {
+function integer(value, path, unlimited = false) {
+    if (unlimited && value === Infinity)
+        return;
     if (!Number.isSafeInteger(value) || value < 0)
         fail("EINVAL", path);
 }
@@ -86,7 +88,7 @@ export class OverlayFileSystem {
         }, false));
         this.maxBufferBytes = options.maxBufferBytes ?? Infinity;
         if (options.maxBufferBytes !== undefined)
-            integer(options.maxBufferBytes, "/");
+            integer(options.maxBufferBytes, "/", true);
         const writable = !this.#upper.capabilities.readOnly && this.#upper.capabilities.atomicRename === true;
         const readable = [this.#upper, this.#lower].map((backend) => retainedReadCapabilities(backend).retainedRead);
         const streamingRead = readable.every((capability) => capability === true) ? true
@@ -520,7 +522,7 @@ export class OverlayFileSystem {
             fail("EISDIR", entry.path);
         this.permission(entry, 4);
         if (options.maxBytes !== undefined)
-            integer(options.maxBytes, entry.path);
+            integer(options.maxBytes, entry.path, true);
         const limit = Math.min(options.maxBytes ?? this.maxBufferBytes, this.maxBufferBytes);
         if (entry.stat.size > limit)
             fail("EFBIG", entry.path);

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

@@ -153,15 +153,15 @@ async function existingBytes(fs, path, options) {
     }
 }
 export function withFileSystemQuota(fs, options) {
-    if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0)
-        throw new RangeError("maxBytes must be a nonnegative safe integer");
+    if (options.maxBytes !== Infinity && (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0))
+        throw new RangeError("maxBytes must be a nonnegative safe integer or Infinity");
     const scanLimits = {
         maxScanEntries: options.maxScanEntries ?? Infinity,
         maxScanDepth: options.maxScanDepth ?? Infinity,
     };
     for (const [name, value] of Object.entries({ maxScanEntries: options.maxScanEntries, maxScanDepth: options.maxScanDepth })) {
-        if (value !== undefined && (!Number.isSafeInteger(value) || value < 0))
-            throw new RangeError(`${name} must be a nonnegative safe integer`);
+        if (value !== undefined && value !== Infinity && (!Number.isSafeInteger(value) || value < 0))
+            throw new RangeError(`${name} must be a nonnegative safe integer or Infinity`);
     }
     let queue = Promise.resolve();
     let reservedBytes = 0;

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

@@ -1,3 +1,4 @@
+import { platform } from "#safe-fs-platform";
 import { snapshotStagingCreation } from "../staging-cleanup.js";
 import { snapshotConditionalChmod } from "../conditional-chmod.js";
 import { runStagingGuard, snapshotDirectoryAncestry } from "../staging-ancestry.js";
@@ -7,6 +8,7 @@ import * as native from "node:fs/promises";
 import { dirname, basename, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { nativeAllocatedBytes } from "./allocation.js";
 import { openFileDescriptor } from "../descriptor.js";
+import { compareIdentity } from "../mount/identity.js";
 import { finishCleanup } from "../../contracts/cleanup.js";
 import { callNativeSeekEnd, loadNativeSeekBinding } from "../../node/native-seek.js";
 import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
@@ -32,11 +34,11 @@ function fileStat(stats) {
         mtimeMs: "mtimeNs" in stats ? Number(stats.mtimeNs / 1000000n) + Number(stats.mtimeNs % 1000000n) / 1e6 : stats.mtimeMs,
         ctimeMs: "ctimeNs" in stats ? Number(stats.ctimeNs / 1000000n) + Number(stats.ctimeNs % 1000000n) / 1e6 : stats.ctimeMs,
         birthtimeMs: "birthtimeNs" in stats ? Number(stats.birthtimeNs / 1000000n) + Number(stats.birthtimeNs % 1000000n) / 1e6 : stats.birthtimeMs, ino, dev,
-        ...(Number.isSafeInteger(dev) && dev >= 0 && Number.isSafeInteger(ino) && ino >= 0
+        ...(Number.isSafeInteger(dev) && dev >= 0 && Number.isSafeInteger(ino) && ino > 0
             ? { identityScope: Symbol.for("virtual-bash.fs.native") } : {}),
         nlink: Number(stats.nlink), uid: Number(stats.uid), gid: Number(stats.gid),
     };
-    if ("ctimeNs" in stats && !stats.isDirectory())
+    if (snapshot.identityScope !== undefined && "ctimeNs" in stats && (stats.ctimeNs !== 0n || stats.mtimeNs !== 0n) && !stats.isDirectory())
         Object.defineProperty(snapshot, "opaqueVersion", { value: `${stats.ctimeNs}:${stats.mtimeNs}`, enumerable: true });
     return snapshot;
 }
@@ -98,14 +100,13 @@ function nativeError(error) {
  */
 export class RealFileSystem {
     capabilities = Object.freeze({
-        read: true, stat: true, readdir: true, realpath: true, access: true, open: true,
+        read: true, stat: true, readdir: true, realpath: true, access: true,
         write: true, append: true, exclusiveCreate: true, explicitDirectories: true, implicitDirectories: false,
         mkdir: true, recursiveMkdir: true, remove: true, removeDirectory: true, recursiveRemove: true,
         rename: true, atomicRenameNoReplace: false, copy: true, exclusiveCopy: true, readlink: true, truncate: true,
         streamingAppend: true, randomAccessWrite: true,
-        readOnly: false, symlinks: true, hardlinks: true, permissions: true,
-        conditionalChmod: true,
-        timestamps: true, atomicRename: true, streamingRead: true, streamingWrite: true, retainedRead: true, retainedResize: true, trustedOwnedStaging: true,
+        readOnly: false, symlinks: true, hardlinks: true, streamingRead: true, streamingWrite: true, retainedRead: true, retainedResize: true,
+        ...platform.nativeFileSystem,
     });
     configuredRoot;
     renameNoReplace;
@@ -122,6 +123,8 @@ export class RealFileSystem {
         this.configuredRoot = root;
         this.renameNoReplace = typeof options === "string" ? undefined : options.renameNoReplace;
         if (this.renameNoReplace !== undefined) {
+            if (!platform.nativeFileSystem.atomicRename)
+                throw new FsError("ENOTSUP", { syscall: "root", message: "atomic rename is unavailable on this host" });
             if (typeof this.renameNoReplace !== "function")
                 throw new FsError("EINVAL", { syscall: "root", message: "renameNoReplace must be a function" });
             this.capabilities = Object.freeze({ ...this.capabilities, atomicRenameNoReplace: true });
@@ -291,10 +294,15 @@ export class RealFileSystem {
         }
     }
     expectStaging(path, expected, identityOnly = false) {
+        if (!platform.nativeFileSystem.trustedOwnedStaging)
+            throw new FsError("ENOTSUP");
         if (expected && (expected.identityScope !== Symbol.for("virtual-bash.fs.native")
             || expected.dev === undefined || expected.ino === undefined || !identityOnly && expected.opaqueVersion === undefined))
             throw new FsError("ENOTSUP");
         const current = this.stagingSnapshot(path);
+        if (expected && current && (current.identityScope !== Symbol.for("virtual-bash.fs.native")
+            || current.dev === undefined || current.ino === undefined || !identityOnly && current.opaqueVersion === undefined))
+            throw new FsError("ENOTSUP");
         if (expected === null ? current !== null : !current || current.dev !== expected.dev || current.ino !== expected.ino || current.type !== expected.type
             || !identityOnly && (current.opaqueVersion !== expected.opaqueVersion || current.size !== expected.size || current.mode !== expected.mode || current.nlink !== expected.nlink))
             throw new FsError("EAGAIN");
@@ -521,6 +529,8 @@ export class RealFileSystem {
         }
     }
     open(path, options) {
+        if (!platform.nativeFileSystem.open)
+            return this.operation("open", path, options, async () => { throw new FsError("ENOTSUP"); });
         return openFileDescriptor(path, options, {
             noFollow: true, positionedRead: true, positionedWrite: true, truncate: true, synchronization: "storage",
         }, async (admitted) => {
@@ -663,7 +673,7 @@ export class RealFileSystem {
         return this.operation("mkdir", path, options, async () => {
             if (options.mode !== undefined)
                 integer(options.mode);
-            if (options.exactMode && options.recursive)
+            if (options.exactMode && (!platform.nativeFileSystem.permissions || options.recursive))
                 throw new FsError("ENOTSUP");
             const target = await this.path(path, {
                 ...options,
@@ -746,8 +756,13 @@ export class RealFileSystem {
                 }
                 if (target && options.exclusive)
                     throw new FsError("EEXIST");
-                if (target && origin.isFile() && origin.dev === target.dev && origin.ino === target.ino)
-                    throw new FsError("EINVAL");
+                if (target && origin.isFile()) {
+                    const identity = compareIdentity(fileStat(origin), fileStat(target));
+                    if (identity === "same")
+                        throw new FsError("EINVAL");
+                    if (identity === "unknown")
+                        throw new FsError("ENOTSUP");
+                }
                 if (!target)
                     flags |= constants.COPYFILE_EXCL;
             }
@@ -813,6 +828,8 @@ export class RealFileSystem {
     }
     async chmod(path, mode, options = {}) {
         return this.operation("chmod", path, options, async () => {
+            if (!platform.nativeFileSystem.permissions)
+                throw new FsError("ENOTSUP");
             integer(mode);
             const conditional = snapshotConditionalChmod(path, options);
             if (conditional) {
@@ -846,6 +863,8 @@ export class RealFileSystem {
     }
     async utimes(path, atimeMs, mtimeMs, options = {}) {
         return this.operation("utimes", path, options, async () => {
+            if (!platform.nativeFileSystem.timestamps)
+                throw new FsError("ENOTSUP");
             if (!Number.isFinite(atimeMs) || !Number.isFinite(mtimeMs)
                 || Math.abs(atimeMs) > 8.64e15 || Math.abs(mtimeMs) > 8.64e15)
                 throw new FsError("EINVAL");

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

@@ -59,7 +59,7 @@ function fail(code, syscall, path, message) {
     throw new FsError(code, { syscall, path, ...(message === undefined ? {} : { message }) });
 }
 function validateLimit(value, name, minimum, maximum = Number.MAX_SAFE_INTEGER) {
-    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+    if ((value !== Infinity || maximum !== Infinity) && (!Number.isSafeInteger(value) || value < minimum || value > maximum)) {
         throw new FsError("EINVAL", { message: `${name} must be an integer from ${minimum} to ${maximum}` });
     }
     return value;
@@ -130,14 +130,14 @@ export class S3FileSystem {
         this.bucket = options.bucket;
         this.allowRename = options.allowNonAtomicRename ?? true;
         this.pageSize = validateLimit(options.pageSize ?? 1000, "pageSize", 1, 1000);
-        this.maxReadBytes = options.maxReadBytes === undefined ? Infinity : validateLimit(options.maxReadBytes, "maxReadBytes", 0);
-        this.maxStreamBytes = options.maxStreamBytes === undefined ? Infinity : validateLimit(options.maxStreamBytes, "maxStreamBytes", 0);
-        this.maxListEntries = options.maxListEntries === undefined ? Infinity : validateLimit(options.maxListEntries, "maxListEntries", 1);
-        this.maxRequests = options.maxRequests === undefined ? Infinity : validateLimit(options.maxRequests, "maxRequests", 1);
+        this.maxReadBytes = options.maxReadBytes === undefined ? Infinity : validateLimit(options.maxReadBytes, "maxReadBytes", 0, Infinity);
+        this.maxStreamBytes = options.maxStreamBytes === undefined ? Infinity : validateLimit(options.maxStreamBytes, "maxStreamBytes", 0, Infinity);
+        this.maxListEntries = options.maxListEntries === undefined ? Infinity : validateLimit(options.maxListEntries, "maxListEntries", 1, Infinity);
+        this.maxRequests = options.maxRequests === undefined ? Infinity : validateLimit(options.maxRequests, "maxRequests", 1, Infinity);
         this.removalLimits = {
-            maxRequests: validateLimit(options.removalLimits?.maxRequests ?? 32, "removalLimits.maxRequests", 1),
-            maxListEntries: validateLimit(options.removalLimits?.maxListEntries ?? 32, "removalLimits.maxListEntries", 1),
-            maxDeleteObjects: validateLimit(options.removalLimits?.maxDeleteObjects ?? 16, "removalLimits.maxDeleteObjects", 1),
+            maxRequests: validateLimit(options.removalLimits?.maxRequests ?? Infinity, "removalLimits.maxRequests", 1, Infinity),
+            maxListEntries: validateLimit(options.removalLimits?.maxListEntries ?? Infinity, "removalLimits.maxListEntries", 1, Infinity),
+            maxDeleteObjects: validateLimit(options.removalLimits?.maxDeleteObjects ?? Infinity, "removalLimits.maxDeleteObjects", 1, Infinity),
         };
         this.capabilities = Object.freeze({
             open: false,
@@ -427,7 +427,7 @@ export class S3FileSystem {
         return this.stat(path, options);
     }
     async body(output, path, options) {
-        const limit = Math.min(this.maxReadBytes, options.maxBytes === undefined ? this.maxReadBytes : validateLimit(options.maxBytes, "maxBytes", 0));
+        const limit = Math.min(this.maxReadBytes, options.maxBytes === undefined ? this.maxReadBytes : validateLimit(options.maxBytes, "maxBytes", 0, Infinity));
         let iterator;
         return this.call("readFile", path, options, async () => {
             if (output.Body && Symbol.asyncIterator in output.Body)
@@ -473,7 +473,7 @@ export class S3FileSystem {
     async readFile(input, options = {}) {
         const path = this.path(input);
         if (options.maxBytes !== undefined)
-            validateLimit(options.maxBytes, "maxBytes", 0);
+            validateLimit(options.maxBytes, "maxBytes", 0, Infinity);
         const info = await this.stat(input, options);
         if (info.type === "directory")
             fail("EISDIR", "readFile", path);

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

@@ -1,4 +1,5 @@
 import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
+export declare function retargetScopedFileSystem(scoped: FileSystem, charge: () => void, signal: AbortSignal, cleanupCharge?: () => void, maxPathComponents?: number): boolean;
 export declare function scopeFileSystem(filesystem: FileSystem, charge: () => void, signal: AbortSignal, cleanupCharge?: () => void, options?: {
     readonly preserveDescriptorWriteReceipt?: boolean;
     readonly creationMask?: number;

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

@@ -8,6 +8,14 @@ import { openRetainedResizeFile, retainedResizeCapabilities, ownedMutationCapabi
 import { createStagingCleanup, snapshotStagingCreation } from "./staging-cleanup.js";
 import { inspectStagingBindings, runStagingGuard, snapshotDirectoryAncestry, snapshotStagingResolution } from "./staging-ancestry.js";
 const originals = new WeakMap();
+const retargeters = new WeakMap();
+export function retargetScopedFileSystem(scoped, charge, signal, cleanupCharge = charge, maxPathComponents) {
+    const fn = retargeters.get(scoped);
+    if (!fn)
+        return false;
+    fn(charge, signal, cleanupCharge, maxPathComponents);
+    return true;
+}
 const operations = new Set([
     "prepareDirectoryAncestry", "prepareStagingResolution",
     "publishFileConditional", "removeEntryConditional", "removeTreeConditional", "writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory",
@@ -19,7 +27,7 @@ const operations = new Set([
 export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = charge, options = {}) {
     const original = originals.get(filesystem)?.filesystem ?? filesystem;
     const creationMask = options.creationMask ?? originals.get(filesystem)?.creationMask;
-    const maxPathComponents = options.maxPathComponents ?? originals.get(filesystem)?.maxPathComponents;
+    let maxPathComponents = options.maxPathComponents ?? originals.get(filesystem)?.maxPathComponents;
     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) => {
@@ -343,7 +351,20 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
                                 controls.signal?.throwIfAborted();
                                 return backendCleanup.remove(controls);
                             }, () => backendCleanup.close());
-                            return Object.freeze({ ...staging, cleanup });
+                            const backendWriter = staging.writer;
+                            const writer = backendWriter && Object.freeze({
+                                write: async (bytes, settings = {}) => {
+                                    const controls = resizeOptions(settings);
+                                    admit(controls);
+                                    await backendWriter.write(bytes, controls);
+                                },
+                                finish: async (settings = {}) => {
+                                    const controls = resizeOptions(settings);
+                                    admit(controls);
+                                    return backendWriter.finish(controls);
+                                },
+                            });
+                            return Object.freeze({ ...staging, cleanup, ...(writer ? { writer } : {}) });
                         }
                         catch (error) {
                             await finishCleanup(() => backendCleanup.close(), true);
@@ -471,7 +492,17 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
             return scoped;
         },
     });
-    originals.set(view, { filesystem: original, signal, cleanupCharge, creationMask, maxPathComponents });
+    const originalRecord = { filesystem: original, signal, cleanupCharge, creationMask, maxPathComponents };
+    originals.set(view, originalRecord);
+    retargeters.set(view, (nextCharge, nextSignal, nextCleanupCharge, nextMaxPathComponents) => {
+        charge = nextCharge;
+        signal = nextSignal;
+        cleanupCharge = nextCleanupCharge;
+        maxPathComponents = nextMaxPathComponents ?? originals.get(filesystem)?.maxPathComponents;
+        originalRecord.signal = nextSignal;
+        originalRecord.cleanupCharge = nextCleanupCharge;
+        originalRecord.maxPathComponents = maxPathComponents;
+    });
     registerEntryView(view, async (path, options) => {
         assertOpen(options);
         return { filesystem: original, path };

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

@@ -86,7 +86,9 @@ const resourceIdBody = '<?xml version="1.0" encoding="utf-8"?>'
 function fail(code, syscall, path, message) {
     throw new FsError(code, { syscall, path, ...(message === undefined ? {} : { message }) });
 }
-function positive(value, name, zero = false) {
+function positive(value, name, zero = false, unlimited = false) {
+    if (unlimited && value === Infinity)
+        return value;
     if (!Number.isSafeInteger(value) || value < (zero ? 0 : 1)) {
         throw new FsError("EINVAL", { message: `${name} must be a ${zero ? "nonnegative" : "positive"} safe integer` });
     }
@@ -286,9 +288,9 @@ export class WebDavFileSystem {
             removeDirectory: this.atomicEmptyDirectory !== undefined,
             streamingAppend: this.requestStreamSupport !== false,
         });
-        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.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.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";
         this.configuredComparison = options.compareEntry !== undefined;
@@ -867,7 +869,7 @@ export class WebDavFileSystem {
     }
     async readFile(path, options = {}) {
         const normalized = normalize(path);
-        const limit = Math.min(this.maxResponseBytes, options.maxBytes === undefined ? this.maxResponseBytes : positive(options.maxBytes, "maxBytes", true));
+        const limit = Math.min(this.maxResponseBytes, options.maxBytes === undefined ? this.maxResponseBytes : positive(options.maxBytes, "maxBytes", true, 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/native-seek-unavailable.d.ts

@@ -0,0 +1 @@
+export declare function loadBinding(): Promise<never>;

package/dist/safe-fs/node/native-seek-unavailable.js

@@ -0,0 +1,5 @@
+import { FsError } from "../contracts/errors.js";
+// Workers support native file reads, but cannot load the optional Node addon.
+export async function loadBinding() {
+    throw new FsError("ENOTSUP", { message: "Native seek is unavailable in Workers" });
+}

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

@@ -3,6 +3,14 @@ import type { ScopedTransportBudgetFrame } from "./transport-budget.js";
 export type PlatformErrno = number | undefined;
 export type PlatformComparisonCallback<Callback> = Callback & never;
 export declare const platform: Readonly<{
+    nativeFileSystem: Readonly<{
+        open: false;
+        permissions: false;
+        timestamps: false;
+        conditionalChmod: false;
+        trustedOwnedStaging: false;
+        atomicRename: false;
+    }>;
     maxCollectionBytes: number;
     errno(_code: string): PlatformErrno;
     callbackAuthorities: false;

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

@@ -1,5 +1,6 @@
 import { FsError } from "../contracts/errors.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,
     errno(_code) {
         return undefined;

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

@@ -4,6 +4,14 @@ import { type ScopedTransportBudgetFrame } from "./transport-budget.js";
 export type PlatformErrno = number;
 export type PlatformComparisonCallback<Callback> = Callback;
 export declare const platform: Readonly<{
+    nativeFileSystem: Readonly<{
+        open: true;
+        permissions: true;
+        timestamps: true;
+        conditionalChmod: true;
+        trustedOwnedStaging: true;
+        atomicRename: true;
+    }>;
     maxCollectionBytes: number;
     errno(code: string): PlatformErrno;
     callbackAuthorities: true;

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

@@ -16,6 +16,7 @@ const systemErrnos = (() => {
 })();
 const negotiating = new AsyncLocalStorage();
 export const platform = Object.freeze({
+    nativeFileSystem: Object.freeze({ open: true, permissions: true, timestamps: true, conditionalChmod: true, trustedOwnedStaging: true, atomicRename: true }),
     maxCollectionBytes: Infinity,
     errno(code) {
         const errno = systemErrnos.get(code === "EOPNOTSUPP" ? "ENOTSUP" : code);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-fs",
-  "version": "0.1.728",
+  "version": "0.1.730",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",
@@ -69,9 +69,11 @@
     },
     "./fs/real": {
       "types": {
+        "workerd": "./dist/safe-fs/fs/real/index.d.ts",
         "browser": "./dist/safe-fs/node-unavailable.d.ts",
         "default": "./dist/safe-fs/fs/real/index.d.ts"
       },
+      "workerd": "./dist/safe-fs/fs/real/index.js",
       "browser": null,
       "import": "./dist/safe-fs/fs/real/index.js"
     },
@@ -134,15 +136,17 @@
   "imports": {
     "#safe-fs-platform": {
       "types": {
+        "workerd": "./dist/safe-fs/platform/browser.d.ts",
         "browser": "./dist/safe-fs/platform/browser.d.ts",
         "default": "./dist/safe-fs/platform/node.d.ts"
       },
+      "workerd": "./dist/safe-fs/platform/browser.js",
       "browser": "./dist/safe-fs/platform/browser.js",
       "default": "./dist/safe-fs/platform/node.js"
     },
     "#safe-fs-native-seek": {
       "types": "./dist/safe-fs/native/fs-seek/loader.d.ts",
-      "workerd": null,
+      "workerd": "./dist/safe-fs/node/native-seek-unavailable.js",
       "browser": null,
       "default": "./dist/safe-fs/native/fs-seek/loader.mjs"
     }