@poe-platform/safe-fs 0.1.803 → 0.1.805

package/dist/safe-fs/fs/s3/http/request-node.d.ts

@@ -1,4 +1,4 @@
-import type { RequestOptions } from "node:http";
-import type { S3HttpRequestFactory } from "./types.js";
+import type { ClientRequest, IncomingMessage, RequestOptions } from "node:http";
 import type { RequestScope, WireResponse } from "./request.js";
+export type S3HttpRequestFactory = (options: RequestOptions, onResponse: (response: IncomingMessage) => void) => ClientRequest;
 export declare function sendRequest(options: RequestOptions, body: Uint8Array, scope: RequestScope, factory?: S3HttpRequestFactory): Promise<WireResponse>;

package/dist/safe-fs/fs/s3/http/types.d.ts

@@ -1,4 +1,5 @@
-import type { ClientRequest, IncomingMessage, RequestOptions } from "node:http";
+import type { S3HttpRequestFactory } from "#safe-fs-s3-request";
+export type { S3HttpRequestFactory } from "#safe-fs-s3-request";
 export interface S3HttpCredentials {
     readonly accessKeyId: string;
     readonly secretAccessKey: string;
@@ -7,7 +8,6 @@ export interface S3HttpCredentials {
 export type S3HttpCredentialProvider = (options: {
     readonly signal: AbortSignal;
 }) => Promise<S3HttpCredentials>;
-export type S3HttpRequestFactory = (options: RequestOptions, onResponse: (response: IncomingMessage) => void) => ClientRequest;
 export interface S3HttpTransportOptions {
     readonly endpoint: string;
     readonly region: string;

package/dist/safe-fs/fs/s3/manifest-admission.js

@@ -41,8 +41,6 @@ export async function* admitManifest(source, options) {
                 invalid();
             const key = value;
             if (frame.shape === 'nodes') {
-                if (key.length > 4096)
-                    invalid();
                 if (++entries > options.maxEntries)
                     throw new FsError('ENOSPC');
             }
@@ -83,8 +81,6 @@ export async function* admitManifest(source, options) {
             if (token) {
                 if (quoted) {
                     token += character;
-                    if (token.length > 4096 * 6 + 2)
-                        invalid();
                     if (escaped)
                         escaped = false;
                     else if (character === '\\')

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

@@ -4,7 +4,7 @@ import { dirname, normalizePath, validatePath } from '../../contracts/virtual-pa
 import { withObjectFileDescriptors } from '../object-publication/index.js';
 import { admitManifest } from './manifest-admission.js';
 function limit(value) {
-    if (value === undefined)
+    if (value === undefined || value === Infinity)
         return Infinity;
     if (!Number.isSafeInteger(value) || value < 1)
         throw new RangeError('Invalid S3 namespace limit');
@@ -18,7 +18,7 @@ export async function createS3NamespaceFileSystem(options) {
         throw new TypeError('An explicit S3 bucket and manifest key are required');
     const maxBytes = limit(options.maxBytes);
     const maxEntries = limit(options.maxEntries);
-    const maxManifestBytes = options.maxManifestBytes === Infinity ? Infinity : limit(options.maxManifestBytes);
+    const maxManifestBytes = limit(options.maxManifestBytes);
     const maxAttempts = limit(options.maxAttempts);
     const descriptorOptions = options;
     for (const key of ['chunkBytes', 'maxStagedBytes', 'maxStagedPages', 'maxFileBytes', 'maxOpenFiles']) {
@@ -32,8 +32,6 @@ export async function createS3NamespaceFileSystem(options) {
         validatePath(value);
         if (!value)
             throw new FsError('ENOENT');
-        if (value.length > 4096)
-            throw new FsError('ENAMETOOLONG');
         return normalizePath(value);
     };
     const entryPath = (value) => {

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

@@ -1,6 +1,7 @@
 import { FsError, isErrnoCode, isFsError } from "../../contracts/errors.js";
 import { composeAbortSignals } from "../../contracts/abort.js";
 import { readBytes } from "../../contracts/io.js";
+import { validatePath } from "../../contracts/virtual-path.js";
 import { davChild, davChildren, parseXmlSteps, scalar, XmlResponseLimitError, XmlResourceLimitError } from "./xml.js";
 import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
 import { assertCallbackAuthorityAllowed, compareEntries, registerEntryAuthority } from "../mount/comparison.js";
@@ -159,28 +160,6 @@ function normalize(path) {
     }
     return `/${segments.join("/")}`;
 }
-function validateDirectoryWalkPath(path, syscall = "access") {
-    if (typeof path !== "string")
-        fail("EINVAL", "resolve", String(path), "invalid WebDAV path");
-    let bytes = 0;
-    let components = 0;
-    let inComponent = false;
-    for (let offset = 0; offset < path.length; offset++) {
-        const point = path.codePointAt(offset);
-        if (point === 47)
-            inComponent = false;
-        else if (!inComponent) {
-            components++;
-            inComponent = true;
-        }
-        bytes += point <= 0x7f ? 1 : point <= 0x7ff ? 2 : point <= 0xffff ? 3 : 4;
-        if (point > 0xffff)
-            offset++;
-        if (bytes > 65_536 || components > 256) {
-            fail("ENAMETOOLONG", syscall, path, "directory access exceeds the 64KiB path or 256 component limit");
-        }
-    }
-}
 function requiresCollection(path) {
     const last = path.split("/").at(-1);
     return last === "" || last === "." || last === "..";
@@ -826,7 +805,7 @@ export class WebDavFileSystem {
         }
     }
     async stat(path, options = {}) {
-        validateDirectoryWalkPath(path, "stat");
+        validatePath(path, options.pathLimits);
         return this.statWithAncestors(path, options);
     }
     async statWithAncestors(path, options) {
@@ -909,7 +888,7 @@ export class WebDavFileSystem {
         }.bind(this));
     }
     async prepareWrite(path, options) {
-        validateDirectoryWalkPath(path, "writeFile");
+        validatePath(path, options.pathLimits);
         const normalized = normalize(path);
         if (options.mode !== undefined)
             this.unsupported("writeFile mode", path);
@@ -1329,10 +1308,7 @@ export class WebDavFileSystem {
             fail("ECANCELED", "access", path);
         if (mode & 2)
             this.unsupported("access write/execute permission checks", path);
-        if (mode & 1)
-            validateDirectoryWalkPath(path);
-        // Non-execute probes do not inherit stat's raw-path limits.
-        const stat = await (mode & 1 ? this.stat(path, options) : this.statWithAncestors(path, options));
+        const stat = await this.stat(path, options);
         if (options.signal?.aborted)
             fail("ECANCELED", "access", path);
         if ((mode & 1) && stat.type !== "directory")
@@ -1398,4 +1374,4 @@ export class WebDavFileSystem {
     }
     async truncate(path, _length, _options = {}) { this.unsupported("truncate", path); }
 }
-const originalWebDavComparison = WebDavFileSystem.prototype.compareEntry;
+const originalWebDavComparison = /* @__PURE__ */ (() => WebDavFileSystem.prototype.compareEntry)();

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

@@ -20,8 +20,8 @@ export function parseXml(input, limits = {}) {
 }
 export function* parseXmlSteps(input, limits = {}) {
     const { maxResponses, ...documentLimits } = limits;
-    if (maxResponses !== undefined && (!Number.isSafeInteger(maxResponses) || maxResponses < 1)) {
-        throw new RangeError("XML limits must be positive integers");
+    if (maxResponses !== undefined && maxResponses !== Infinity && (!Number.isSafeInteger(maxResponses) || maxResponses < 1)) {
+        throw new RangeError("XML limits must be positive integers or Infinity");
     }
     let responses = 0;
     try {

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

@@ -332,8 +332,8 @@ export function writePythonStat(heap, pointer, stat) {
     return 0;
 }
 /** Runtime storage and application storage occupy disjoint guest device ranges. */
-export function createPythonRuntimeStatMapper(maxDevices = 1024) {
-    if (!Number.isSafeInteger(maxDevices) || maxDevices < 1 || maxDevices > 1024)
+export function createPythonRuntimeStatMapper(maxDevices = Infinity) {
+    if (maxDevices !== Infinity && (!Number.isSafeInteger(maxDevices) || maxDevices < 1))
         throw new RangeError('Invalid runtime device limit');
     const mapped = Symbol('mapped Python runtime device');
     const devices = new Map();
@@ -346,6 +346,9 @@ export function createPythonRuntimeStatMapper(maxDevices = 1024) {
         if (device === undefined) {
             if (devices.size >= maxDevices)
                 throw new Error('EOVERFLOW');
+            // Preserve the uint32 guest ABI even when the resource budget is unlimited.
+            if (devices.size >= 0x80000000)
+                throw new Error('EOVERFLOW');
             device = 0x80000000 + devices.size;
             devices.set(stat.dev, device);
         }

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

@@ -23,11 +23,11 @@ export class PythonFileSystem {
         if (!options.cwd.startsWith("/"))
             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.#transfer = options.maxTransferBytes ?? Infinity;
         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))
+            if (limit !== undefined && limit !== Infinity && (!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]);

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

@@ -10,7 +10,7 @@ const errno = {
 };
 export function createPythonNativeSyscalls(options) {
     const { runtime, signal, maxTransferBytes, runtimeMount } = options;
-    if (!Number.isSafeInteger(maxTransferBytes) || maxTransferBytes < 1)
+    if (maxTransferBytes !== Infinity && (!Number.isSafeInteger(maxTransferBytes) || maxTransferBytes < 1))
         throw new RangeError('Invalid native transfer limit');
     const descriptors = new Map();
     const closedStdio = new Set();

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

@@ -4,8 +4,8 @@ export class PythonStatTranslator {
     #devices = new Map();
     #maxDevices;
     #next = 1;
-    constructor(maxDevices = 1024) {
-        if (!Number.isSafeInteger(maxDevices) || maxDevices < 1)
+    constructor(maxDevices = Infinity) {
+        if (maxDevices !== Infinity && (!Number.isSafeInteger(maxDevices) || maxDevices < 1))
             throw new FsError("EINVAL");
         this.#maxDevices = maxDevices;
     }
@@ -19,6 +19,9 @@ export class PythonStatTranslator {
         if (guestDevice === undefined) {
             if (this.#next > this.#maxDevices)
                 throw new FsError("EFBIG", { syscall: "stat", message: "Python device identity limit exceeded" });
+            // The upper half of the uint32 guest ABI is reserved for runtime devices.
+            if (this.#next >= 0x80000000)
+                throw new FsError("EFBIG", { syscall: "stat", message: "Python device identity exceeds guest ABI range" });
             if (!devices) {
                 devices = new Map();
                 this.#devices.set(identityScope, devices);

package/dist/safe-fs/runtime-core.d.ts

@@ -0,0 +1,26 @@
+export * from "./contracts/errors.js";
+export * from "./contracts/filesystem.js";
+export * from "./contracts/io.js";
+export { openFileDescriptor } from "./fs/descriptor.js";
+export type { DescriptorBackend, DescriptorOpenOptions } from "./fs/descriptor.js";
+export { assertPathWithin, isPathWithin, normalizePath, relativePath, resolvePath, validatePath } from "./contracts/virtual-path.js";
+export { basename, dirname, extname, isAbsolutePath, joinPath, posixPath } from "./contracts/portable-path.js";
+import type { FileSystem } from "./contracts/filesystem.js";
+export type { MemoryFileSystem, MemoryFileSystemLimits, MemoryFileSystemOptions, MemoryRedirectHandle } from "./fs/memory/index.js";
+export declare function isUnmodifiedMemoryFileSystem(fs: FileSystem): boolean;
+export declare function isCleanAbsolutePath(p: string): boolean;
+export declare function tryGetMemoryDirectoryEntryNamesSync(fs: FileSystem, path: string): any;
+export declare function tryReadMemoryFileViewSync(fs: FileSystem, path: string, maxBytes?: number, signal?: AbortSignal, captureSourceRef?: boolean, beforeRead?: () => void): Uint8Array | undefined;
+export declare function tryResolveMemoryDevicePath(fs: FileSystem, path: string, followFinal?: boolean): string | undefined;
+export * from "./fs/devices/index.js";
+export { retargetScopedFileSystem, scopeFileSystem, retainFileSystemCleanup } from "./fs/scoped.js";
+export type { RetainedFileSystemCleanupView, RetainedFileSystemCleanupOptions } from "./fs/scoped.js";
+export { compareEntries, registerEntryView } from "./fs/mount/comparison.js";
+export type { EntryViewResolver } from "./fs/mount/comparison.js";
+export type { ConditionalMutationBinding } from "./fs/memory/index.js";
+export declare function bindConditionalMutation<Result>(identityScope: object | symbol | undefined, binding: any, action: () => Promise<Result>): Promise<Result>;
+export declare function tryOpenMemoryRedirectHandleSync(fs: FileSystem, path: string, append: boolean, mode: number, signal?: AbortSignal): any;
+export declare function tryWriteMemoryFileSync(fs: FileSystem, path: string, data: Uint8Array, append: boolean, mode: number, signal?: AbortSignal): boolean;
+export declare function tryMkdirMemorySync(fs: FileSystem, path: string, recursive: boolean, mode: number, signal?: AbortSignal, dirPrefixHint?: string): boolean;
+export declare function tryRmRfMemorySync(fs: FileSystem, path: string, signal?: AbortSignal): boolean;
+export declare function tryWriteMemoryFileInDirSync(fs: FileSystem, dirPrefix: string, name: string, data: Uint8Array, append: boolean, mode: number, signal?: AbortSignal): boolean;

package/dist/safe-fs/runtime-core.js

@@ -0,0 +1,56 @@
+export * from "./contracts/errors.js";
+export * from "./contracts/filesystem.js";
+export * from "./contracts/io.js";
+export { openFileDescriptor } from "./fs/descriptor.js";
+export { assertPathWithin, isPathWithin, normalizePath, relativePath, resolvePath, validatePath } from "./contracts/virtual-path.js";
+export { basename, dirname, extname, isAbsolutePath, joinPath, posixPath } from "./contracts/portable-path.js";
+const _getMemHooks = () => globalThis.__safeBashMemHooks;
+export function isUnmodifiedMemoryFileSystem(fs) {
+    const proto = Object.getPrototypeOf(fs);
+    if (!proto || !_getMemHooks()?.protos?.has(proto))
+        return false;
+    return Object.getOwnPropertyNames(fs).every(name => {
+        const method = Object.getOwnPropertyDescriptor(proto, name)?.value;
+        return typeof method !== "function" || Object.getOwnPropertyDescriptor(fs, name)?.value === method;
+    }) && Object.getOwnPropertyNames(proto).every(name => {
+        const method = Object.getOwnPropertyDescriptor(proto, name)?.value;
+        return typeof method !== "function" || Reflect.get(fs, name) === method;
+    });
+}
+export function isCleanAbsolutePath(p) {
+    const fn = _getMemHooks()?.isCleanAbsolutePath;
+    if (fn)
+        return fn(p);
+    return p.length > 0 && p.charCodeAt(0) === 47 && !p.includes("//") && !p.includes("/.") && (p.length === 1 || p.charCodeAt(p.length - 1) !== 47);
+}
+export function tryGetMemoryDirectoryEntryNamesSync(fs, path) {
+    return (fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryGetMemoryDirectoryEntryNamesSync)?.(fs, path);
+}
+export function tryReadMemoryFileViewSync(fs, path, maxBytes, signal, captureSourceRef, beforeRead) {
+    return (fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryReadMemoryFileViewSync)?.(fs, path, maxBytes, signal, captureSourceRef, beforeRead);
+}
+export function tryResolveMemoryDevicePath(fs, path, followFinal) {
+    return (fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryResolveMemoryDevicePath)?.(fs, path, followFinal);
+}
+export * from "./fs/devices/index.js";
+export { retargetScopedFileSystem, scopeFileSystem, retainFileSystemCleanup } from "./fs/scoped.js";
+export { compareEntries, registerEntryView } from "./fs/mount/comparison.js";
+export async function bindConditionalMutation(identityScope, binding, action) {
+    const fn = _getMemHooks()?.bindConditionalMutation;
+    return fn ? fn(identityScope, binding, action) : action();
+}
+export function tryOpenMemoryRedirectHandleSync(fs, path, append, mode, signal) {
+    return (fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryOpenMemoryRedirectHandleSync)?.(fs, path, append, mode, signal);
+}
+export function tryWriteMemoryFileSync(fs, path, data, append, mode, signal) {
+    return Boolean((fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryWriteMemoryFileSync)?.(fs, path, data, append, mode, signal));
+}
+export function tryMkdirMemorySync(fs, path, recursive, mode, signal, dirPrefixHint) {
+    return Boolean((fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryMkdirMemorySync)?.(fs, path, recursive, mode, signal, dirPrefixHint));
+}
+export function tryRmRfMemorySync(fs, path, signal) {
+    return Boolean((fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryRmRfMemorySync)?.(fs, path, signal));
+}
+export function tryWriteMemoryFileInDirSync(fs, dirPrefix, name, data, append, mode, signal) {
+    return Boolean((fs && _getMemHooks()?.byProto?.get(Object.getPrototypeOf(fs))?.tryWriteMemoryFileInDirSync)?.(fs, dirPrefix, name, data, append, mode, signal));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-fs",
-  "version": "0.1.803",
+  "version": "0.1.805",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",
@@ -43,12 +43,14 @@
       "types": "./dist/safe-fs/testing/atomic-filesystem.d.ts",
       "workerd": "./dist/safe-fs/testing/atomic-filesystem.js",
       "browser": "./dist/safe-fs/testing/atomic-filesystem.js",
+      "worker": "./dist/safe-fs/testing/atomic-filesystem.js",
       "import": "./dist/safe-fs/testing/atomic-filesystem.js"
     },
     "./testing/object-publication": {
       "types": "./dist/safe-fs/testing/object-publication.d.ts",
       "workerd": "./dist/safe-fs/testing/object-publication.js",
       "browser": "./dist/safe-fs/testing/object-publication.js",
+      "worker": "./dist/safe-fs/testing/object-publication.js",
       "import": "./dist/safe-fs/testing/object-publication.js"
     },
     "./node": {
@@ -63,10 +65,12 @@
       "types": {
         "workerd": "./dist/safe-fs/node-unavailable.d.ts",
         "browser": "./dist/safe-fs/node-unavailable.d.ts",
+        "worker": "./dist/safe-fs/node-unavailable.d.ts",
         "default": "./dist/safe-fs/node/filesystem.d.ts"
       },
       "workerd": null,
       "browser": null,
+      "worker": null,
       "import": "./dist/safe-fs/node/filesystem.js"
     },
     "./fs/memory": {
@@ -122,6 +126,10 @@
     "./contracts/errors": {
       "types": "./dist/safe-fs/contracts/errors.d.ts",
       "import": "./dist/safe-fs/contracts/errors.js"
+    },
+    "./runtime-core": {
+      "types": "./dist/safe-fs/runtime-core.d.ts",
+      "import": "./dist/safe-fs/runtime-core.js"
     }
   },
   "repository": {
@@ -138,9 +146,15 @@
   },
   "imports": {
     "#safe-fs-s3-request": {
-      "types": "./dist/safe-fs/fs/s3/http/request-node.d.ts",
+      "types": {
+        "workerd": "./dist/safe-fs/fs/s3/http/request-fetch.d.ts",
+        "browser": "./dist/safe-fs/fs/s3/http/request-fetch.d.ts",
+        "worker": "./dist/safe-fs/fs/s3/http/request-fetch.d.ts",
+        "default": "./dist/safe-fs/fs/s3/http/request-node.d.ts"
+      },
       "workerd": "./dist/safe-fs/fs/s3/http/request-fetch.js",
       "browser": "./dist/safe-fs/fs/s3/http/request-fetch.js",
+      "worker": "./dist/safe-fs/fs/s3/http/request-fetch.js",
       "default": "./dist/safe-fs/fs/s3/http/request-node.js"
     },
     "#safe-fs-platform": {