@poe-platform/safe-fs 0.1.721 → 0.1.723

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');

package/dist/safe-fs/xml.js

@@ -185,22 +185,22 @@ function* validDeclaration(content, expectedEncoding) {
     return offset === content.length;
 }
 export function* parseXmlSteps(input, limits = {}) {
-    const maxDepth = limits.maxDepth ?? 64;
-    const maxNodes = limits.maxNodes ?? 100_000;
-    const maxAttributes = limits.maxAttributes ?? 10_000;
+    const maxDepth = limits.maxDepth ?? Infinity;
+    const maxNodes = limits.maxNodes ?? Infinity;
+    const maxAttributes = limits.maxAttributes ?? Infinity;
     const retainContent = limits.retainContent !== false;
-    const maxContentNodes = limits.maxContentNodes ?? (retainContent ? 100_000 : maxNodes);
+    const maxContentNodes = limits.maxContentNodes ?? Infinity;
     const emptyContent = Object.freeze([]);
     const emptyAttributes = Object.freeze([]);
     const emptyNamespaces = new Map();
-    const maxAttributesPerElement = limits.maxAttributesPerElement ?? 128;
-    const maxNamespaces = limits.maxNamespaces ?? 256;
-    for (const limit of [maxDepth, maxNodes, maxAttributes, maxContentNodes, maxAttributesPerElement, maxNamespaces]) {
-        if (!Number.isSafeInteger(limit) || limit < 1)
+    const maxAttributesPerElement = limits.maxAttributesPerElement ?? Infinity;
+    const maxNamespaces = limits.maxNamespaces ?? Infinity;
+    for (const limit of [limits.maxDepth, limits.maxNodes, limits.maxAttributes, limits.maxContentNodes, limits.maxAttributesPerElement, limits.maxNamespaces]) {
+        if (limit !== undefined && ((limit !== Infinity && !Number.isSafeInteger(limit)) || limit < 1))
             throw new RangeError("XML limits must be positive integers");
     }
-    const maxTextLength = limits.maxTextLength ?? Number.MAX_SAFE_INTEGER;
-    if (!Number.isSafeInteger(maxTextLength) || maxTextLength < 1)
+    const maxTextLength = limits.maxTextLength ?? Infinity;
+    if (limits.maxTextLength !== undefined && ((maxTextLength !== Infinity && !Number.isSafeInteger(maxTextLength)) || maxTextLength < 1))
         throw new RangeError("XML limits must be positive integers");
     let textLength = 0;
     const admitText = (text) => {
@@ -209,31 +209,42 @@ export function* parseXmlSteps(input, limits = {}) {
         textLength += text.length;
     };
     const chunks = [];
-    let chunk = "";
-    for (let index = input.charCodeAt(0) === 0xfeff ? 1 : 0; index < input.length; index++) {
+    const start = input.charCodeAt(0) === 0xfeff ? 1 : 0;
+    let chunkStart = start;
+    let chunkLength = 0;
+    let normalizedChunk = "";
+    // Keep validated spans intact; only changed line endings need new strings.
+    for (let index = start; index < input.length; index++) {
         const point = input.codePointAt(index);
         if (!validCharacter(point))
             invalid("invalid character");
         if (point === 13) {
-            chunk += "\n";
+            normalizedChunk += input.slice(chunkStart, index) + "\n";
             if (input.charCodeAt(index + 1) === 10)
                 index++;
+            chunkStart = index + 1;
+            chunkLength++;
         }
         else {
-            chunk += String.fromCodePoint(point);
+            chunkLength += point > 0xffff ? 2 : 1;
             if (point > 0xffff)
                 index++;
         }
-        if (chunk.length >= 512) {
-            chunks.push(chunk);
-            chunk = "";
+        if (chunkLength >= 512) {
+            if (normalizedChunk) {
+                chunks.push(normalizedChunk + input.slice(chunkStart, index + 1));
+                normalizedChunk = "";
+                chunkStart = index + 1;
+            }
+            chunkLength = 0;
             yield 512;
         }
     }
-    chunks.push(chunk);
-    if (chunk.length)
-        yield chunk.length;
-    const source = chunks.join("");
+    if (chunkLength)
+        yield chunkLength;
+    if (chunks.length || normalizedChunk)
+        chunks.push(normalizedChunk + input.slice(chunkStart));
+    const source = chunks.length ? chunks.join("") : input.slice(start);
     const stack = [];
     let root;
     const prolog = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-fs",
-  "version": "0.1.721",
+  "version": "0.1.723",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",