@poe-platform/safe-fs 0.1.804 → 0.1.806

package/dist/safe-fs/fs/object-publication/index.d.ts

@@ -15,6 +15,7 @@ export interface ObjectFilePublicationOptions extends FsOptions {
     readonly mode: number;
 }
 export interface ObjectFileAcquireOptions extends FsOptions {
+    readonly noFollow?: boolean;
     readonly access: OpenFileOptions["access"];
 }
 export interface ObjectFileStaging {
@@ -28,6 +29,8 @@ export interface ObjectFileStagingOptions extends FsOptions {
     readonly maxFileBytes: number;
 }
 export interface ObjectFilePublicationStore {
+    /** Certifies acquire can reject symbolic links when noFollow is requested. */
+    readonly noFollow?: boolean;
     acquire(path: string, options: ObjectFileAcquireOptions): Promise<ObjectFileVersion | undefined>;
     publish?(path: string, expectedRevision: string | null, source: ByteSource, options: ObjectFilePublicationOptions): Promise<ObjectFileVersion>;
     createStaging?(path: string, options: ObjectFileStagingOptions): Promise<ObjectFileStaging>;

package/dist/safe-fs/fs/object-publication/index.js

@@ -11,6 +11,7 @@ export function withObjectFileDescriptors(filesystem, store, options = {}) {
     const maxOpenFiles = options.maxOpenFiles ?? Infinity;
     if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1
         || ![maxStagedBytes, maxStagedPages, maxFileBytes, maxOpenFiles].every(value => value === Infinity || Number.isSafeInteger(value) && value > 0)
+        || store.noFollow !== undefined && typeof store.noFollow !== "boolean"
         || typeof store.acquire !== "function"
         || store.publish !== undefined && typeof store.publish !== "function"
         || store.createStaging !== undefined && typeof store.createStaging !== "function")
@@ -68,7 +69,7 @@ export function withObjectFileDescriptors(filesystem, store, options = {}) {
         state.pages.clear();
     };
     const open = (path, openOptions) => openFileDescriptor(path, openOptions, {
-        publication: "conditional", position: true, positionedRead: true, positionedWrite: true,
+        publication: "conditional", position: true, positionedRead: true, positionedWrite: true, noFollow: store.noFollow === true,
         truncate: true, synchronization: "storage",
     }, async (admitted) => {
         validatePath(path);
@@ -233,7 +234,7 @@ export function withObjectFileDescriptors(filesystem, store, options = {}) {
                 throw new FsError("ENOTSUP", { path, message: "Object writes require authoritative conditional publication" });
             if (admitted.access !== "write" && capabilities.read === false)
                 throw new FsError("EACCES", { path });
-            const acquired = await store.acquire(path, { access: admitted.access, ...(admitted.signal ? { signal: admitted.signal } : {}) });
+            const acquired = await store.acquire(path, { access: admitted.access, ...(admitted.noFollow ? { noFollow: true } : {}), ...(admitted.signal ? { signal: admitted.signal } : {}) });
             if (acquired) {
                 try {
                     state.head = version(acquired);

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

@@ -499,7 +499,7 @@ export function withFileSystemQuota(fs, options) {
     // capabilities and methods without violating invariants on own properties.
     return new Proxy(Object.create(fs), {
         get(_target, property) {
-            if (property === "prepareStagingResolution" || property === "prepareDirectoryAncestry" || property === "publishFileConditional" || property === "removeEntryConditional" || property === "writeFileConditional" || property === "removeFileConditional" || property === "resizeFile" || property === "canonicalizeMissingTarget" || property === "createStagedFile" || property === "publishStagedFile" || property === "removeStagedFile" || property === "prepareDirectory")
+            if (property === "publishStagedFileSet" || property === "prepareStagingResolution" || property === "prepareDirectoryAncestry" || property === "publishFileConditional" || property === "removeEntryConditional" || property === "writeFileConditional" || property === "removeFileConditional" || property === "resizeFile" || property === "canonicalizeMissingTarget" || property === "createStagedFile" || property === "publishStagedFile" || property === "removeStagedFile" || property === "prepareDirectory")
                 return undefined;
             if (property === "capabilities")
                 return quotaCapabilities({ ...retainedResizeCapabilities(fs, retainedReadCapabilities(fs)), ...(typeof fs.open === "function" ? {} : { open: false }) });

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

@@ -202,7 +202,7 @@ export class ReadOnlyFileSystem {
         readOnly("openResizeFile", path);
     }
 }
-const readOnlyImplementation = Object.getOwnPropertyDescriptors(ReadOnlyFileSystem.prototype);
+const readOnlyImplementation = /* @__PURE__ */ Object.getOwnPropertyDescriptors(ReadOnlyFileSystem.prototype);
 export function createReadOnlyFileSystem(filesystem) {
     return new ReadOnlyFileSystem(filesystem);
 }

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

@@ -1134,4 +1134,4 @@ export class S3FileSystem {
         }
     }
 }
-const s3Comparison = S3FileSystem.prototype.compareEntry;
+const s3Comparison = /* @__PURE__ */ (() => S3FileSystem.prototype.compareEntry)();

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

@@ -22,7 +22,7 @@ function utf8ByteLength(value) {
     return bytes;
 }
 function limit(value, fallback, name, maximum = Number.MAX_SAFE_INTEGER) {
-    if (value === undefined)
+    if (value === undefined || value === Infinity && fallback === Infinity)
         return fallback;
     const result = value;
     if (!Number.isSafeInteger(result) || result < 1 || result > maximum)

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

@@ -37,8 +37,8 @@ function decodeEntities(text) {
 }
 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");
+        if (limit !== undefined && limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 1))
+            throw new RangeError("XML limits must be positive safe integers or Infinity");
     }
     let xml;
     try {

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

@@ -18,7 +18,7 @@ export function retargetScopedFileSystem(scoped, charge, signal, cleanupCharge =
     return true;
 }
 const operations = new Set([
-    "prepareDirectoryAncestry", "prepareStagingResolution",
+    "prepareDirectoryAncestry", "prepareStagingResolution", "publishStagedFileSet",
     "publishFileConditional", "removeEntryConditional", "removeTreeConditional", "writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory",
     "confineExtraction", "access", "appendFile", "canonicalizeMissingTarget", "capabilitiesFor", "chmod", "compareEntry",
     "copyFile", "link", "lstat", "mkdir", "openReadFile", "openResizeFile", "readFile", "readStream", "readdir",
@@ -262,7 +262,7 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
                 if (property === "removeEntryConditional")
                     args[1] = resizeOptions({ ...args[1] });
                 let stagingSignal;
-                if (property === "createStagedFile" || property === "publishStagedFile") {
+                if (property === "createStagedFile" || property === "publishStagedFile" || property === "publishStagedFileSet") {
                     signal.throwIfAborted();
                     if (property === "createStagedFile")
                         args[3] = snapshotStagingCreation(args[3], args[0]);
@@ -281,6 +281,36 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
                     if (property === "symlink" && typeof args[1] === "string")
                         validatePath(args[1], maxPathComponents);
                 }
+                if (property === "publishStagedFileSet") {
+                    if (original.capabilities.readOnly === true)
+                        throw new FsError("EROFS", { path: args[1] });
+                    const supplied = args[2];
+                    const callerGuard = supplied.commitGuard;
+                    const entry = (value) => ({ path: value.path, stat: { ...value.stat } });
+                    const input = args[0];
+                    const staging = { ...input, parent: entry(input.parent), directory: entry(input.directory), file: entry(input.file) };
+                    const controls = {
+                        ...supplied,
+                        signal: stagingSignal,
+                        parent: { ...supplied.parent },
+                        destination: supplied.destination === null ? null : { ...supplied.destination },
+                        companions: supplied.companions.map(value => ({ ...value, expected: value.expected === null ? null : { ...value.expected } })),
+                        ...(supplied.ancestors === undefined ? {} : { ancestors: snapshotDirectoryAncestry(supplied.ancestors) }),
+                        commitGuard: () => {
+                            assertOpen({ signal: stagingSignal });
+                            if (callerGuard !== undefined)
+                                runStagingGuard(callerGuard);
+                            assertOpen({ signal: stagingSignal });
+                            return true;
+                        },
+                    };
+                    for (const path of [staging.parent.path, staging.directory.path, staging.file.path, args[1],
+                        ...controls.companions.map(value => value.path), ...(controls.ancestors ?? []).map(value => value.path)]) {
+                        validatePath(path, maxPathComponents);
+                    }
+                    assertOpen(controls);
+                    return Reflect.apply(method, original, [staging, args[1], controls]);
+                }
                 if (["writeFile", "appendFile", "writeStream", "mkdir"].includes(String(property))) {
                     const index = property === "mkdir" ? 1 : 2;
                     args[index] = creationOptions((args[index] ?? {}), property === "mkdir");

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

@@ -1374,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/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./contracts/index.js";
+export * from "./bridge/index.js";
 export { ObjectAuthority } from "./fs/object-authority.js";
 export * from "./python/index.js";
 export { openFileDescriptor } from "./fs/descriptor.js";
@@ -21,3 +22,4 @@ export * from "./node/index.js";
 export { createFileSystem, readConfigRecord, validateFileSystemConfig } from "./config.js";
 export type { FileSystemConfig, FileSystemAdapterDescriptor, FileSystemAdapterRegistry } from "./config.js";
 export { createNodeFileSystemAdapterRegistry } from "./config.node.js";
+export { createPortableFileSystemAdapterRegistry } from "./config.portable.js";

package/dist/safe-fs/index.js

@@ -1,4 +1,5 @@
 export * from "./contracts/index.js";
+export * from "./bridge/index.js";
 export { ObjectAuthority } from "./fs/object-authority.js";
 export * from "./python/index.js";
 export { openFileDescriptor } from "./fs/descriptor.js";
@@ -17,3 +18,4 @@ export { scopeFileSystem, retainFileSystemCleanup } from "./fs/scoped.js";
 export * from "./node/index.js";
 export { createFileSystem, readConfigRecord, validateFileSystemConfig } from "./config.js";
 export { createNodeFileSystemAdapterRegistry } from "./config.node.js";
+export { createPortableFileSystemAdapterRegistry } from "./config.portable.js";

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

@@ -1,5 +1,6 @@
 import type * as FsPromises from "node:fs/promises";
 import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
+import { FileSystemBridge } from "../bridge/filesystem.js";
 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;
@@ -14,5 +15,5 @@ export interface NodeFsBridgeOptions {
 export interface NodeFsBridgeFileSystem extends FileSystem {
     rmdir?(path: string, options?: FsOptions): Promise<void>;
 }
-export declare function getNodeFsBridgeProvider(bridge: object): FileSystem | undefined;
+export declare const getNodeFsBridgeProvider: typeof FileSystemBridge.getProvider;
 export declare function createNodeFsBridge(fs: FileSystem, options?: NodeFsBridgeOptions): NodeFsImplementation;

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

@@ -3,10 +3,7 @@ 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 const getNodeFsBridgeProvider = FileSystemBridge.getProvider;
 export function createNodeFsBridge(fs, options = {}) {
     const bridge = new FileSystemBridge(fs, options, {
         codec: {
@@ -29,6 +26,5 @@ 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/runtime-core.d.ts

@@ -0,0 +1,27 @@
+export * from "./contracts/errors.js";
+export * from "./contracts/filesystem.js";
+export * from "./contracts/io.js";
+export { compareIdentity, compareFileVersion } from "./fs/mount/identity.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,57 @@
+export * from "./contracts/errors.js";
+export * from "./contracts/filesystem.js";
+export * from "./contracts/io.js";
+export { compareIdentity, compareFileVersion } from "./fs/mount/identity.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.804",
+  "version": "0.1.806",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",
@@ -126,6 +126,14 @@
     "./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"
+    },
+    "./bridge": {
+      "types": "./dist/safe-fs/bridge/index.d.ts",
+      "import": "./dist/safe-fs/bridge/index.js"
     }
   },
   "repository": {