@poe-platform/safe-fs 0.1.720 → 0.1.722

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

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

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

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

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

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

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

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

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

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

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

@@ -24,7 +24,7 @@ function positive(value, name, zero = false) {
 }
 function createRequestTimeout(timeoutMs) {
     const controller = new AbortController();
-    const timer = setTimeout(() => {
+    const timer = timeoutMs === undefined ? undefined : setTimeout(() => {
         controller.abort(new DOMException("The operation was aborted due to timeout", "TimeoutError"));
     }, timeoutMs);
     if (typeof timer === "object" && timer !== null) {
@@ -216,15 +216,15 @@ export class WebDavFileSystem {
             removeDirectory: this.atomicEmptyDirectory !== undefined,
             streamingAppend: this.requestStreamSupport !== false,
         });
-        this.maxResponseBytes = positive(options.maxResponseBytes ?? 64 * 1024 * 1024, "maxResponseBytes");
-        this.maxXmlBytes = positive(options.maxXmlBytes ?? 2 * 1024 * 1024, "maxXmlBytes");
-        this.maxEntries = positive(options.maxEntries ?? 10_000, "maxEntries");
-        this.timeoutMs = positive(options.timeoutMs ?? 30_000, "timeoutMs");
+        this.maxResponseBytes = options.maxResponseBytes === undefined ? 16 * 1024 * 1024 : positive(options.maxResponseBytes, "maxResponseBytes");
+        this.maxXmlBytes = options.maxXmlBytes === undefined ? 1024 * 1024 : positive(options.maxXmlBytes, "maxXmlBytes");
+        this.maxEntries = options.maxEntries === undefined ? Infinity : positive(options.maxEntries, "maxEntries");
+        this.timeoutMs = options.timeoutMs === undefined ? undefined : positive(options.timeoutMs, "timeoutMs");
         this.overwritePolicy = options.overwritePolicy ?? "lock";
         this.configuredComparison = options.compareEntry !== undefined;
         if (!["lock", "etag"].includes(this.overwritePolicy))
             throw new FsError("EINVAL", { message: "invalid overwritePolicy" });
-        if (this.timeoutMs > 2_147_483_647)
+        if (this.timeoutMs !== undefined && this.timeoutMs > 2_147_483_647)
             throw new FsError("EINVAL", { message: "timeoutMs exceeds timer range" });
         registerResourceQuery(this, (path, settings) => this.resourceId(path, settings), originalWebDavComparison, options.compareEntry);
         registerEntryAuthority(this, compareWebDavResources);
@@ -424,29 +424,37 @@ export class WebDavFileSystem {
         }
     }
     async bytes(response, limit, signal) {
-        const chunks = [];
+        const expected = this.responseLength(response, limit);
+        let data = new Uint8Array(expected ?? 0);
         let size = 0;
-        for await (const chunk of this.bodyChunks(response, limit, signal)) {
-            chunks.push(chunk);
-            size += chunk.byteLength;
-        }
-        const data = new Uint8Array(size);
-        let offset = 0;
-        for (const chunk of chunks) {
-            data.set(chunk, offset);
-            offset += chunk.byteLength;
+        // Consume borrowed chunks immediately; only streaming callers need owned copies.
+        for await (const chunk of this.bodyChunks(response, limit, signal, false)) {
+            const nextSize = size + chunk.byteLength;
+            if (nextSize > data.byteLength) {
+                const grown = new Uint8Array(Math.min(limit, Math.max(nextSize, data.byteLength * 2)));
+                grown.set(data);
+                data = grown;
+            }
+            data.set(chunk, size);
+            size = nextSize;
         }
-        return data;
+        // A view avoids a second full allocation when the length was unknown.
+        return data.subarray(0, size);
     }
-    async *bodyChunks(response, limit, signal) {
+    responseLength(response, limit) {
         const length = response.headers.get("content-length");
-        if (length !== null && (!/^\d+$/.test(length) || !Number.isSafeInteger(Number(length)))) {
+        if (length !== null && (!length.length || [...length].some(char => char < "0" || char > "9")
+            || !Number.isSafeInteger(Number(length)))) {
             fail("EIO", "webdav", "", "invalid response Content-Length");
         }
         const encoding = response.headers.get("content-encoding");
         const expected = length !== null && (!encoding || encoding.toLowerCase() === "identity") ? Number(length) : undefined;
         if (expected !== undefined && expected > limit)
             fail("EFBIG", "webdav", "", "response exceeds byte limit");
+        return expected;
+    }
+    async *bodyChunks(response, limit, signal, copy = true) {
+        const expected = this.responseLength(response, limit);
         if (!response.body) {
             if (expected !== undefined && expected !== 0)
                 fail("EIO", "webdav", "", "response body length differs from Content-Length");
@@ -468,7 +476,7 @@ export class WebDavFileSystem {
                     fail("EFBIG", "webdav", "", "response exceeds byte limit");
                 if (expected !== undefined && size > expected)
                     fail("EIO", "webdav", "", "response body length differs from Content-Length");
-                yield new Uint8Array(result.value);
+                yield copy ? new Uint8Array(result.value) : result.value;
             }
             if (expected !== undefined && size !== expected)
                 fail("EIO", "webdav", "", "response body length differs from Content-Length");
@@ -492,7 +500,7 @@ export class WebDavFileSystem {
         }
         let root;
         try {
-            root = await this.xml(response, signal, this.maxEntries);
+            root = await this.xml(response, signal, this.maxEntries === Infinity ? undefined : this.maxEntries);
         }
         catch (error) {
             if (error instanceof XmlResponseLimitError)
@@ -762,7 +770,7 @@ export class WebDavFileSystem {
     }
     async readFile(path, options = {}) {
         const normalized = normalize(path);
-        const limit = Math.min(this.maxResponseBytes, positive(options.maxBytes ?? this.maxResponseBytes, "maxBytes", true));
+        const limit = Math.min(this.maxResponseBytes, options.maxBytes === undefined ? this.maxResponseBytes : positive(options.maxBytes, "maxBytes", true));
         if ((await this.stat(path, options)).type === "directory")
             fail("EISDIR", "readFile", path);
         return this.request("GET", normalized, options, { headers: { "Accept-Encoding": "identity" } }, async (response, signal) => {

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

@@ -1,11 +1,14 @@
 import type * as FsPromises from "node:fs/promises";
 import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
-export type NodeFsImplementation = Pick<typeof FsPromises, "access" | "appendFile" | "chmod" | "copyFile" | "cp" | "link" | "lstat" | "mkdir" | "mkdtemp" | "readFile" | "readdir" | "readlink" | "realpath" | "rename" | "rm" | "rmdir" | "stat" | "symlink" | "truncate" | "utimes" | "writeFile">;
+export type NodeFsImplementation = Pick<typeof FsPromises, "access" | "appendFile" | "chmod" | "copyFile" | "cp" | "link" | "lstat" | "mkdir" | "mkdtemp" | "readFile" | "readdir" | "readlink" | "realpath" | "unlink" | "rename" | "rm" | "rmdir" | "stat" | "symlink" | "truncate" | "utimes" | "writeFile">;
 export interface NodeFsBridgeOptions {
     readonly cwd?: string;
+    /** Optional confinement boundary; defaults to cwd. */
+    readonly root?: string;
     readonly signal?: AbortSignal;
 }
 export interface NodeFsBridgeFileSystem extends FileSystem {
     rmdir?(path: string, options?: FsOptions): Promise<void>;
 }
+export declare function getNodeFsBridgeProvider(bridge: object): FileSystem | undefined;
 export declare function createNodeFsBridge(fs: FileSystem, options?: NodeFsBridgeOptions): NodeFsImplementation;

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

@@ -3,8 +3,12 @@ import { randomBytes } from "node:crypto";
 import { posix } from "node:path";
 import { fileURLToPath } from "node:url";
 import { FileSystemBridge } from "../bridge/filesystem.js";
+const providers = new WeakMap();
+export function getNodeFsBridgeProvider(bridge) {
+    return providers.get(bridge);
+}
 export function createNodeFsBridge(fs, options = {}) {
-    return new FileSystemBridge(fs, options, {
+    const bridge = new FileSystemBridge(fs, options, {
         codec: {
             isEncoding: Buffer.isEncoding,
             encode(text, encoding) {
@@ -25,4 +29,6 @@ export function createNodeFsBridge(fs, options = {}) {
         randomSuffix() { return randomBytes(6).toString("hex").slice(0, 6); },
         paths: posix
     });
+    providers.set(bridge, fs);
+    return bridge;
 }

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

@@ -0,0 +1,3 @@
+import type { FileSystem } from "../contracts/filesystem.js";
+/** Trusted host access with native paths and symlink semantics; this is not a rooted sandbox. */
+export declare function createHostFileSystem(): FileSystem;

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

@@ -0,0 +1,78 @@
+import * as fs from "node:fs/promises";
+function snapshot(stat) {
+    return {
+        type: stat.isDirectory()
+            ? "directory"
+            : stat.isSymbolicLink()
+                ? "symlink"
+                : stat.isFile()
+                    ? "file"
+                    : "character",
+        size: stat.size,
+        mode: stat.mode,
+        mtimeMs: stat.mtimeMs,
+        atimeMs: stat.atimeMs,
+        ctimeMs: stat.ctimeMs,
+        birthtimeMs: stat.birthtimeMs
+    };
+}
+/** Trusted host access with native paths and symlink semantics; this is not a rooted sandbox. */
+export function createHostFileSystem() {
+    async function perform(options, action) {
+        options?.signal?.throwIfAborted();
+        const result = await action();
+        options?.signal?.throwIfAborted();
+        return result;
+    }
+    return {
+        capabilities: {
+            read: true,
+            write: true,
+            append: true,
+            stat: true,
+            readdir: true,
+            mkdir: true,
+            recursiveMkdir: true,
+            rename: true,
+            remove: true,
+            removeDirectory: true,
+            recursiveRemove: true,
+            symlinks: true,
+            hardlinks: true,
+            permissions: true,
+            timestamps: true,
+            exclusiveCreate: true
+        },
+        readFile: (path, options) => perform(options, () => fs.readFile(path, options?.signal ? { signal: options.signal } : undefined)),
+        writeFile: (path, data, options) => perform(options, () => fs.writeFile(path, data, options)),
+        appendFile: (path, data, options) => perform(options, () => fs.appendFile(path, data, options)),
+        stat: (path, options) => perform(options, async () => snapshot(await fs.stat(path))),
+        lstat: (path, options) => perform(options, async () => snapshot(await fs.lstat(path))),
+        readdir: (path, options) => perform(options, async () => (await fs.readdir(path, { withFileTypes: true })).map((entry) => ({
+            name: entry.name,
+            type: entry.isDirectory()
+                ? "directory"
+                : entry.isSymbolicLink()
+                    ? "symlink"
+                    : entry.isFile()
+                        ? "file"
+                        : "character"
+        }))),
+        mkdir: (path, options) => perform(options, async () => {
+            await fs.mkdir(path, options);
+        }),
+        rm: (path, options) => perform(options, () => fs.rm(path, options)),
+        unlink: (path, options) => perform(options, () => fs.unlink(path)),
+        rmdir: (path, options) => perform(options, () => fs.rmdir(path)),
+        rename: (source, destination, options) => perform(options, () => fs.rename(source, destination)),
+        copyFile: (source, destination, options) => perform(options, () => fs.copyFile(source, destination, options?.exclusive ? fs.constants.COPYFILE_EXCL : 0)),
+        realpath: (path, options) => perform(options, () => fs.realpath(path)),
+        access: (path, mode, options) => perform(options, () => fs.access(path, mode)),
+        readlink: (path, options) => perform(options, () => fs.readlink(path)),
+        symlink: (target, path, options) => perform(options, () => fs.symlink(target, path)),
+        link: (source, destination, options) => perform(options, () => fs.link(source, destination)),
+        chmod: (path, mode, options) => perform(options, () => fs.chmod(path, mode)),
+        utimes: (path, atimeMs, mtimeMs, options) => perform(options, () => fs.utimes(path, atimeMs / 1000, mtimeMs / 1000)),
+        truncate: (path, length, options) => perform(options, () => fs.truncate(path, length))
+    };
+}

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

@@ -1,2 +1,3 @@
-export { createNodeFsBridge } from "./filesystem.js";
+export { createNodeFsBridge, getNodeFsBridgeProvider } from "./filesystem.js";
 export type { NodeFsBridgeOptions, NodeFsBridgeFileSystem, NodeFsImplementation } from "./filesystem.js";
+export { createHostFileSystem } from "./host.js";

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

@@ -1 +1,2 @@
-export { createNodeFsBridge } from "./filesystem.js";
+export { createNodeFsBridge, getNodeFsBridgeProvider } from "./filesystem.js";
+export { createHostFileSystem } from "./host.js";

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

@@ -2,6 +2,7 @@ import type { FsOptions } from "../contracts/filesystem.js";
 export type PlatformErrno = number | undefined;
 export type PlatformComparisonCallback<Callback> = Callback & never;
 export declare const platform: Readonly<{
+    maxCollectionBytes: number;
     errno(_code: string): PlatformErrno;
     callbackAuthorities: false;
     randomUUID(): string;

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

@@ -1,5 +1,6 @@
 import { FsError } from "../contracts/errors.js";
 export const platform = Object.freeze({
+    maxCollectionBytes: 32 * 1024 * 1024,
     errno(_code) {
         return undefined;
     },

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

@@ -3,6 +3,7 @@ import type { FsOptions } from "../contracts/filesystem.js";
 export type PlatformErrno = number;
 export type PlatformComparisonCallback<Callback> = Callback;
 export declare const platform: Readonly<{
+    maxCollectionBytes: number;
     errno(code: string): PlatformErrno;
     callbackAuthorities: true;
     randomUUID: typeof randomUUID;

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

@@ -15,6 +15,7 @@ const systemErrnos = (() => {
 })();
 const negotiating = new AsyncLocalStorage();
 export const platform = Object.freeze({
+    maxCollectionBytes: Infinity,
     errno(code) {
         const errno = systemErrnos.get(code === "EOPNOTSUPP" ? "ENOTSUP" : code);
         if (errno === undefined)

package/dist/safe-fs/python/emscripten.d.ts

@@ -6,6 +6,7 @@ export interface PythonMountOptions {
     errno: Record<string, number>;
     synchronizationFlags: number;
     runtimeModule: any;
+    getUmask?: () => number;
 }
 export declare function mountPythonFileSystem(FS: any, options: PythonMountOptions): void;
 /** Encode the pinned wasm32 musl stat layout without truncating canonical values. */

package/dist/safe-fs/python/emscripten.js

@@ -59,9 +59,9 @@ export function mountPythonFileSystem(FS, options) {
         mknod(parent, name, mode) {
             const target = `${path(parent)}/${name}`;
             if (FS.isDir(mode))
-                rpc('mkdir', target, { mode: mode & 4095 });
+                rpc('mkdir', target, { mode: mode & 4095 & ~(options.getUmask?.() ?? 0), exactMode: true });
             else {
-                const handle = rpc('open', target, { access: 'write', creation: 'exclusive', mode: mode & 4095 });
+                const handle = rpc('open', target, { access: 'write', creation: 'exclusive', mode: mode & 4095 & ~(options.getUmask?.() ?? 0), exactMode: true });
                 rpc('close', handle);
             }
             return node(parent, name, rpc('lstat', target));
@@ -145,7 +145,7 @@ export function mountPythonFileSystem(FS, options) {
             throw new FS.ErrnoError(54);
         let openOptions;
         try {
-            openOptions = translatePythonOpenFlags(flags, mode);
+            openOptions = { ...translatePythonOpenFlags(flags, mode & ~(options.getUmask?.() ?? 0)), exactMode: true };
         }
         catch (error) {
             throw new FS.ErrnoError(errno[error.code] ?? errno.EIO);
@@ -199,7 +199,7 @@ export function mountPythonFileSystem(FS, options) {
         if (bootstrapPath(target))
             return originalMkdir(target, mode);
         const absolute = absolutePath(target);
-        rpc('mkdir', absolute, { mode });
+        rpc('mkdir', absolute, { mode: mode & ~(options.getUmask?.() ?? 0), exactMode: true });
         return node(FS.root, absolute.slice(1), rpc('lstat', absolute));
     };
     const originalRename = FS.rename.bind(FS);
@@ -238,7 +238,7 @@ export function mountPythonFileSystem(FS, options) {
             return originalMknod(target, mode, device);
         if (!FS.isFile(mode))
             throw new FS.ErrnoError(errno.ENOTSUP);
-        const handle = rpc('open', absolutePath(target), { access: 'write', creation: 'exclusive', mode: mode & 4095 });
+        const handle = rpc('open', absolutePath(target), { access: 'write', creation: 'exclusive', mode: mode & 4095 & ~(options.getUmask?.() ?? 0), exactMode: true });
         rpc('close', handle);
         return node(FS.root, absolutePath(target).slice(1), rpc('lstat', absolutePath(target)));
     };

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

@@ -24,10 +24,10 @@ export class PythonFileSystem {
             throw new FsError("EINVAL", { syscall: "python filesystem", path: options.cwd, message: "cwd must be absolute" });
         this.#cwd = options.cwd;
         this.#transfer = options.maxTransferBytes ?? 65536;
-        this.#limit = options.maxOpenFiles ?? 256;
-        this.#directoryLimit = options.maxDirectoryEntries ?? 65536;
-        for (const limit of [this.#transfer, this.#limit, this.#directoryLimit])
-            if (!Number.isSafeInteger(limit) || limit < 1)
+        this.#limit = options.maxOpenFiles ?? Infinity;
+        this.#directoryLimit = options.maxDirectoryEntries ?? Infinity;
+        for (const limit of [this.#transfer, options.maxOpenFiles, options.maxDirectoryEntries])
+            if (limit !== undefined && (!Number.isSafeInteger(limit) || limit < 1))
                 throw new FsError("EINVAL", { syscall: "python filesystem" });
         this.#open = options.open;
         this.#scope = composeAbortSignals([...(options.signal === undefined ? [] : [options.signal]), this.#abort.signal]);
@@ -153,7 +153,7 @@ export class PythonFileSystem {
             case "realpath": return fs.realpath(this.#path(request.args[0]), options);
             case "readdir": {
                 const path = this.#path(request.args[0]);
-                const entries = await fs.readdir(path, { ...options, maxEntries: this.#directoryLimit });
+                const entries = await fs.readdir(path, { ...options, ...(this.#directoryLimit === Infinity ? {} : { maxEntries: this.#directoryLimit }) });
                 signal.throwIfAborted();
                 if (entries.length > this.#directoryLimit)
                     throw new FsError("EFBIG", { syscall: "readdir", path, message: "Python directory listing exceeds configured limit" });

package/dist/safe-fs/python/native.d.ts

@@ -8,6 +8,7 @@ export interface PythonNativeSyscallOptions {
     readonly cwd: string;
     readonly runtimeMount: string;
     readonly maxTransferBytes: number;
+    readonly getUmask?: () => number;
     readonly original?: (name: string, args: readonly (number | bigint)[]) => number;
 }
 export declare function createPythonNativeSyscalls(options: PythonNativeSyscallOptions): {

package/dist/safe-fs/python/native.js

@@ -195,7 +195,8 @@ export function createPythonNativeSyscalls(options) {
                 }
                 if (fourth)
                     range(fourth, 4);
-                const openOptions = translatePythonOpenFlags(third, fourth ? view().getUint32(fourth, true) : 0o666);
+                const mode = (fourth ? view().getUint32(fourth, true) : 0o666) & ~(options.getUmask?.() ?? 0);
+                const openOptions = { ...translatePythonOpenFlags(third, mode), exactMode: true };
                 const handle = await options.dispatch({ op: 'open', args: [path, openOptions] });
                 try {
                     signal.throwIfAborted();
@@ -338,7 +339,7 @@ export function createPythonNativeSyscalls(options) {
                 if (privatePath(path))
                     fail('EROFS');
                 if (name === '__syscall_mkdirat')
-                    await request('mkdir', path, { mode: third & 0o7777 });
+                    await request('mkdir', path, { mode: third & 0o7777 & ~(options.getUmask?.() ?? 0), exactMode: true });
                 else {
                     if (third !== 0 && third !== 512)
                         fail('EINVAL');