@poe-platform/safe-fs 0.1.804 → 0.1.805

package/dist/safe-fs/contracts/errors.d.ts

@@ -40,6 +40,7 @@ export interface FsErrorOptions extends ErrorOptions {
     readonly message?: string;
 }
 export declare class FsError extends Error {
+    static [Symbol.hasInstance](value: unknown): boolean;
     readonly code: ErrnoCode;
     readonly errno: PlatformErrno;
     readonly syscall?: string;

package/dist/safe-fs/contracts/errors.js

@@ -31,7 +31,18 @@ const descriptions = {
     ETIMEDOUT: "operation timed out",
     EXDEV: "cross-device link not permitted",
 };
+const FS_ERROR_BRAND = Symbol.for("@poe-code/safe-fs.FsError");
 export class FsError extends Error {
+    static [Symbol.hasInstance](value) {
+        if (typeof value !== "object" || value === null)
+            return false;
+        if (this !== FsError)
+            return Function.prototype[Symbol.hasInstance].call(this, value);
+        if (Function.prototype[Symbol.hasInstance].call(FsError, value))
+            return true;
+        const record = value;
+        return record[FS_ERROR_BRAND] === true && isErrnoCode(record.code);
+    }
     code;
     errno;
     syscall;
@@ -53,6 +64,7 @@ export class FsError extends Error {
         finally {
             errorConstructor.stackTraceLimit = prevStackLimit;
         }
+        Object.defineProperty(this, FS_ERROR_BRAND, { value: true, enumerable: false, configurable: false, writable: false });
         this.name = "FsError";
         this.code = code;
         this.errno = errno;

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

@@ -1,28 +1,16 @@
-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";
-export * from "./fs/memory/index.js";
-export * from "./fs/devices/index.js";
+export * from "./runtime-core.js";
+export { MemoryFileSystem, MemoryRedirectHandle, createMemoryFileSystem, defaultMemoryFileSystemLimits, bindConditionalMutation, getLastReadMemoryFileSourceRef, isCleanAbsolutePath, tryGetMemoryDirectoryEntryNamesSync, tryMkdirMemorySync, tryOpenMemoryRedirectHandleSync, tryReadMemoryFileViewSync, tryResolveMemoryDevicePath, tryRmRfMemorySync, tryWriteMemoryFileInDirSync, tryWriteMemoryFileSync, utf8ByteLength } from "./fs/memory/index.js";
 export * from "./fs/readonly/index.js";
 export * from "./fs/mount/index.js";
 export * from "./fs/overlay/index.js";
 export * from "./fs/quota/index.js";
 export * from "./fs/object-publication/index.js";
-export { retargetScopedFileSystem, scopeFileSystem, retainFileSystemCleanup } from "./fs/scoped.js";
-export type { RetainedFileSystemCleanupView, RetainedFileSystemCleanupOptions } from "./fs/scoped.js";
 export * from "./fs/webdav/index.js";
 export * from "./bridge/index.js";
 export * from "./python/index.js";
-export { compareEntries, registerEntryView } from "./fs/mount/comparison.js";
-export type { EntryViewResolver } from "./fs/mount/comparison.js";
 export { parseXml, parseXmlSteps, XmlLimitError } from "./xml.js";
 export type { XmlName, XmlAttribute, XmlContent, XmlElement, XmlLimits } from "./xml.js";
 export * from "./contracts/object.js";
 export { ObjectAuthority } from "./fs/object-authority.js";
-export { bindConditionalMutation, type ConditionalMutationBinding } from "./fs/memory/index.js";
 export * from "./fs/s3/index.js";
 export * from "./fs/s3/http/index.js";

package/dist/safe-fs/core.js

@@ -1,24 +1,15 @@
-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";
-export * from "./fs/memory/index.js";
-export * from "./fs/devices/index.js";
+export * from "./runtime-core.js";
+export { MemoryFileSystem, MemoryRedirectHandle, createMemoryFileSystem, defaultMemoryFileSystemLimits, bindConditionalMutation, getLastReadMemoryFileSourceRef, isCleanAbsolutePath, tryGetMemoryDirectoryEntryNamesSync, tryMkdirMemorySync, tryOpenMemoryRedirectHandleSync, tryReadMemoryFileViewSync, tryResolveMemoryDevicePath, tryRmRfMemorySync, tryWriteMemoryFileInDirSync, tryWriteMemoryFileSync, utf8ByteLength } from "./fs/memory/index.js";
 export * from "./fs/readonly/index.js";
 export * from "./fs/mount/index.js";
 export * from "./fs/overlay/index.js";
 export * from "./fs/quota/index.js";
 export * from "./fs/object-publication/index.js";
-export { retargetScopedFileSystem, scopeFileSystem, retainFileSystemCleanup } from "./fs/scoped.js";
 export * from "./fs/webdav/index.js";
 export * from "./bridge/index.js";
 export * from "./python/index.js";
-export { compareEntries, registerEntryView } from "./fs/mount/comparison.js";
 export { parseXml, parseXmlSteps, XmlLimitError } from "./xml.js";
 export * from "./contracts/object.js";
 export { ObjectAuthority } from "./fs/object-authority.js";
-export { bindConditionalMutation } from "./fs/memory/index.js";
 export * from "./fs/s3/index.js";
 export * from "./fs/s3/http/index.js";

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

@@ -1,15 +1,20 @@
 import type { FileDescriptor, OpenFileOptions } from "../../contracts/descriptor.js";
 import type { AppendFileOptions, CapabilityQueryOptions, CopyFileOptions, DirectoryEntry, FileReadHandle, FileResizeHandle, FileResizeOperation, FileResizeOptions, FileStat, FileSystem, OpenReadFileOptions, OpenResizeFileOptions, FileSystemCapabilities, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions, ConditionalFilePublicationOptions, ConditionalWriteFileOptions, ConditionalRemoveFileOptions, ConditionalRemoveEntryOptions, ConditionalRemoveEntryReceiptOptions, CreateStagedFileOptions, FileStaging, FileStagingEntry, FileStagingResolution, PublishStagedFileOptions, PrepareDirectoryOptions, StagedFileContent } from "../../contracts/filesystem.js";
 import type { ByteSource } from "../../contracts/io.js";
+import { type EntryLocation } from "../mount/comparison.js";
+import { pathNamespace } from "../path-namespace.js";
 export declare class DeviceFileSystem implements FileSystem {
     #private;
     readonly capabilities: FileSystemCapabilities;
+    get [pathNamespace](): any;
+    _resolveEntryView: (path: string, options: FsOptions) => Promise<EntryLocation>;
+    _entryAuthority: () => Promise<"unknown">;
     constructor(filesystem: FileSystem);
     canonicalizeMissingTarget(path: string, options?: FsOptions): string | undefined;
     capabilitiesFor(path: string, options?: CapabilityQueryOptions): Promise<FileSystemCapabilities>;
     stat(path: string, options?: FsOptions): Promise<FileStat>;
     lstat(path: string, options?: FsOptions): Promise<FileStat>;
-    compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<import("../../contracts/filesystem.js").EntryComparison>;
+    compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<import("../../runtime-core.js").EntryComparison>;
     realpath(path: string, options?: FsOptions): Promise<string>;
     readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
     readStream(path: string, options?: ReadStreamOptions): ByteSource;

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

@@ -2,9 +2,9 @@ import { snapshotStagingCreation } from "../staging-cleanup.js";
 import { FsError, isFsError } from "../../contracts/errors.js";
 import { finishCleanup } from "../../contracts/cleanup.js";
 import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
-import { compareEntries, registerEntryAuthority, registerEntryView } from "../mount/comparison.js";
+import { compareEntries } from "../mount/comparison.js";
 import { deviceDirectory, lexicalDevicePath, nullPath, resolveDevicePath } from "./path.js";
-import { tryResolveMemoryDevicePath } from "../memory/index.js";
+import { tryResolveMemoryDevicePath } from "../../runtime-core.js";
 import { createDeviceYield, deviceReadStream, drainDeviceFile, drainDeviceInput } from "./stream.js";
 import { openRetainedReadFile, openRetainedResizeFile, retainedResizeCapabilities, ownedMutationCapabilities, requireOwnedMutation } from "../capabilities.js";
 import { pathNamespace } from "../path-namespace.js";
@@ -71,21 +71,46 @@ function nonnegative(value, path) {
     if (value !== undefined && (!Number.isSafeInteger(value) || value < 0))
         throw new FsError("EINVAL", { path });
 }
+const sharedUnknownEntryAuthority = async () => "unknown";
 export class DeviceFileSystem {
     #filesystem;
     capabilities;
-    #nullStat;
-    #directoryStat;
+    #identityScopeObj;
+    #nullStatObj;
+    #directoryStatObj;
+    get [pathNamespace]() {
+        return Reflect.get(this.#filesystem, pathNamespace);
+    }
+    get #nullStat() {
+        if (this.#nullStatObj)
+            return this.#nullStatObj;
+        const identityScope = (this.#identityScopeObj ??= Object.freeze({}));
+        return (this.#nullStatObj = Object.freeze({
+            type: "character", mode: 0o020666, size: 0, allocatedBytes: 0, uid: 0, gid: 0,
+            mtimeMs: 0, atimeMs: 0, ctimeMs: 0, birthtimeMs: 0, identityScope, ino: 1, dev: 0, nlink: 1, preferredIoBlockSize: 4096,
+        }));
+    }
+    get #directoryStat() {
+        if (this.#directoryStatObj)
+            return this.#directoryStatObj;
+        const identityScope = (this.#identityScopeObj ??= Object.freeze({}));
+        return (this.#directoryStatObj = Object.freeze({
+            type: "directory", mode: 0o040755, size: 0, allocatedBytes: 0, uid: 0, gid: 0,
+            mtimeMs: 0, atimeMs: 0, ctimeMs: 0, birthtimeMs: 0, identityScope, ino: 2, dev: 0, nlink: 1,
+        }));
+    }
+    _resolveEntryView = async (path, options) => {
+        const resolved = await this.#resolve(path, options);
+        if (resolved === nullPath || resolved === deviceDirectory) {
+            return { filesystem: this, path: resolved, stat: resolved === nullPath ? this.#nullStat : this.#directoryStat, readOnly: false };
+        }
+        return { filesystem: this.#filesystem, path };
+    };
+    _entryAuthority = sharedUnknownEntryAuthority;
     constructor(filesystem) {
         this.#filesystem = filesystem;
-        Object.defineProperty(this, pathNamespace, { get: () => Reflect.get(filesystem, pathNamespace) });
         this.capabilities = globalCapabilities(filesystem);
-        const identityScope = Object.freeze({});
-        const stat = { mode: 0o020666, size: 0, allocatedBytes: 0, uid: 0, gid: 0,
-            mtimeMs: 0, atimeMs: 0, ctimeMs: 0, birthtimeMs: 0, identityScope, ino: 1, dev: 0, nlink: 1 };
-        this.#nullStat = Object.freeze({ ...stat, type: "character", preferredIoBlockSize: 4096 });
-        this.#directoryStat = Object.freeze({ ...stat, type: "directory", mode: 0o040755, ino: 2 });
-        const methods = new Map();
+        let methods;
         const view = new Proxy(this, {
             set: (_target, property, value) => Reflect.set(filesystem, property, value, filesystem),
             get(target, property) {
@@ -93,24 +118,14 @@ export class DeviceFileSystem {
                 if (typeof value !== "function" || property === "constructor")
                     return value;
                 const backing = Reflect.get(filesystem, property, filesystem);
-                const cached = methods.get(property);
+                const cached = methods?.get(property);
                 if (cached && cached.backing === backing)
                     return cached.bound;
                 const bound = value.bind(target);
-                methods.set(property, { backing, bound });
+                (methods ??= new Map()).set(property, { backing, bound });
                 return bound;
             },
         });
-        for (const identity of [this, view])
-            registerEntryView(identity, async (path, options) => {
-                const resolved = await this.#resolve(path, options);
-                if (resolved === nullPath || resolved === deviceDirectory)
-                    return { filesystem: this, path: resolved,
-                        stat: resolved === nullPath ? this.#nullStat : this.#directoryStat, readOnly: false };
-                return { filesystem, path };
-            });
-        // This internal view has no identity proof beyond its synthetic stats.
-        registerEntryAuthority(this, async () => "unknown");
         return view;
     }
     #resolve(path, options, followFinal = true, resizeCreate, traversal) {

package/dist/safe-fs/fs/devices/path.js

@@ -1,7 +1,7 @@
 import { FsError, isFsError } from "../../contracts/errors.js";
 import { pathByteLength, validatePath } from "../../contracts/virtual-path.js";
 import { capturePathNamespace, pathNamespace } from "../path-namespace.js";
-import { isCleanAbsolutePath, tryResolveMemoryDevicePath } from "../memory/index.js";
+import { isCleanAbsolutePath, tryResolveMemoryDevicePath } from "../../runtime-core.js";
 export const nullPath = "/dev/null";
 export const deviceDirectory = "/dev";
 function isNullParts(parts) {

package/dist/safe-fs/fs/memory/atomic-view.d.ts

@@ -4,5 +4,8 @@ export interface MemoryAtomicView {
     stat(path: string): FileStat | undefined;
     names(path: string): readonly string[];
 }
+type LazyMemoryAtomicView = (this: FileSystem) => MemoryAtomicView | undefined;
 export declare function registerMemoryAtomicView(fs: FileSystem, view: MemoryAtomicView, intact: () => boolean): void;
+export declare function registerLazyMemoryAtomicView(fs: FileSystem, create: LazyMemoryAtomicView): void;
 export declare function memoryAtomicView(fs: FileSystem): MemoryAtomicView | undefined;
+export {};

package/dist/safe-fs/fs/memory/atomic-view.js

@@ -2,7 +2,12 @@ const views = new WeakMap();
 export function registerMemoryAtomicView(fs, view, intact) {
     views.set(fs, { view, intact });
 }
+export function registerLazyMemoryAtomicView(fs, create) {
+    views.set(fs, create);
+}
 export function memoryAtomicView(fs) {
     const registered = views.get(fs);
+    if (typeof registered === "function")
+        return registered.call(fs);
     return registered?.intact() ? registered.view : undefined;
 }

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

@@ -1,5 +1,6 @@
 import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileReadHandle, FileResizeHandle, FileStat, FileSystem, FileSystemCapabilities, FsOptions, ChmodOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, FileDescriptor, OpenFileOptions, OpenReadFileOptions, OpenResizeFileOptions, WriteFileOptions, ConditionalWriteFileOptions, ConditionalRemoveFileOptions, ConditionalRemoveEntryOptions, ConditionalRemoveEntryReceiptOptions, CreateStagedFileOptions, FileStaging, FileStagingEntry, FileStagingResolution, PublishStagedFileOptions, PrepareDirectoryOptions, StagedFileContent } from "../../contracts/filesystem.js";
 import type { ByteSource } from "../../contracts/io.js";
+import { type MemoryAtomicView } from "./atomic-view.js";
 import { MemoryAllocation, MemoryLedger } from "./ledger.js";
 import { type MemoryFileSystemOptions } from "./limits.js";
 export { defaultMemoryFileSystemLimits, type MemoryFileSystemLimits, type MemoryFileSystemOptions } from "./limits.js";
@@ -59,9 +60,10 @@ export interface ConditionalMutationBinding {
 }
 export declare function bindConditionalMutation<Result>(identityScope: object | symbol | undefined, binding: ConditionalMutationBinding, action: () => Promise<Result>): Promise<Result>;
 export declare class MemoryFileSystem implements FileSystem {
+    #private;
     capabilitiesFor?: NonNullable<FileSystem["capabilitiesFor"]>;
-    readonly capabilities: FileSystemCapabilities;
-    private readonly identityScope;
+    private get identityScope();
+    get capabilities(): FileSystemCapabilities;
     private nextInode;
     private readonly ledger;
     readonly _cache: MemoryCache;
@@ -70,6 +72,7 @@ export declare class MemoryFileSystem implements FileSystem {
     private readonly root;
     private totalBytes;
     symlinkCount: number;
+    _getAtomicView(): MemoryAtomicView | undefined;
     constructor(options?: MemoryFileSystemOptions);
     compareEntry(path: string, peer: FileSystem, peerPath: string, options?: FsOptions): Promise<EntryComparison>;
     canonicalizeMissingTarget(path: string, options?: FsOptions): string | undefined;

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

@@ -9,7 +9,7 @@ import { directoryAncestryPaths, runStagingGuard, snapshotDirectoryAncestry, sna
 import { compareIdentity } from "../mount/identity.js";
 import { createStagingCleanup, snapshotStagingCreation } from "../staging-cleanup.js";
 import { resolveMissingTarget } from "./missing-target.js";
-import { registerMemoryAtomicView } from "./atomic-view.js";
+import { registerLazyMemoryAtomicView } from "./atomic-view.js";
 import { snapshotConditionalChmod } from "../conditional-chmod.js";
 import { MemoryAllocation, MemoryLedger } from "./ledger.js";
 import { normalizeMemoryFileSystemLimits } from "./limits.js";
@@ -50,14 +50,17 @@ const DUMMY_POOL_LEDGER = new MemoryLedger(normalizeMemoryFileSystemLimits({}));
 const DUMMY_POOL_ALLOCATION = new MemoryAllocation(EMPTY_ALLOC_BYTES, DUMMY_POOL_LEDGER);
 const DUMMY_POOL_FILE_NODE = new MemoryFileNode(0, 0, null, 0, DUMMY_POOL_ALLOCATION, DUMMY_POOL_ALLOCATION.data);
 DUMMY_POOL_FILE_NODE.atimeMs = DUMMY_POOL_FILE_NODE.mtimeMs = DUMMY_POOL_FILE_NODE.ctimeMs = DUMMY_POOL_FILE_NODE.birthtimeMs = 1700000000000;
+const EMPTY_DIR_TABLE = new Int16Array(0);
+const EMPTY_DIR_KEYS = [];
+const EMPTY_DIR_VALS = [];
 class FastDirectoryEntriesMap {
     // Keep speculative slots local so a failed write cannot pin a tenant globally.
     _missKey = "";
     _missSlot = -1;
-    _table = new Int16Array(128).fill(-1);
-    _mask = 127;
-    _keys = new Array(64).fill("");
-    _vals = new Array(64).fill(DUMMY_POOL_FILE_NODE);
+    _table = EMPTY_DIR_TABLE;
+    _mask = 0;
+    _keys = EMPTY_DIR_KEYS;
+    _vals = EMPTY_DIR_VALS;
     _next = 0;
     size = 0;
     [Symbol.toStringTag] = "Map";
@@ -90,6 +93,11 @@ class FastDirectoryEntriesMap {
     getForWriteWithHash(k, h) {
         let slot = h & this._mask;
         if (this.size === 0) {
+            if (this._keys.length === 0) {
+                this._missKey = "";
+                this._missSlot = -1;
+                return undefined;
+            }
             this._missKey = k;
             this._missSlot = slot;
             return undefined;
@@ -205,7 +213,7 @@ class FastDirectoryEntriesMap {
             return this;
         }
         if (this._next >= this._keys.length) {
-            this._rebuild(this.size * 2 <= this._keys.length ? this._keys.length : this._keys.length * 2);
+            this._rebuild(this._keys.length === 0 ? 8 : (this.size * 2 <= this._keys.length ? this._keys.length : this._keys.length * 2));
         }
         let slot = this._hash(k);
         const mask = this._mask;
@@ -415,7 +423,6 @@ class MemoryCache {
 const typeModes = { file: 0o100000, directory: 0o040000, symlink: 0o120000 };
 const emptyResolveOptions = Object.freeze({});
 const noFollowResolveOptions = Object.freeze({ followFinal: false });
-const sharedMkdirResolveOptions = { createDirectories: 0o777 };
 const sharedAllowMissingNoFollowOptions = Object.freeze({ allowMissing: true, followFinal: false });
 const sharedFastLocation = { node: undefined, parent: DUMMY_POOL_DIR_NODE, name: "", path: "" };
 const resolvedVoid = Promise.resolve();
@@ -441,7 +448,7 @@ const compareOwnedMemory = async (own, peer, options) => {
     let answer = "unknown";
     const visited = new Set();
     for (const [left, right] of [[own, peer], [peer, own]]) {
-        if (!registeredAuthorities.has(left.filesystem) || visited.has(left.filesystem))
+        if ((!registeredAuthorities.has(left.filesystem) && !ownedStores.has(left.filesystem)) || visited.has(left.filesystem))
             continue;
         visited.add(left.filesystem);
         const comparison = left.filesystem.compareEntry;
@@ -590,32 +597,48 @@ class MemoryReadStream {
         return STREAM_RESOLVED_DONE;
     }
 }
+const SHARED_STOCK_MEMORY_CAPABILITIES = Object.freeze({
+    read: true, stat: true, readdir: true, realpath: true, access: true, open: true,
+    write: true, append: true, exclusiveCreate: true, explicitDirectories: true, implicitDirectories: false,
+    mkdir: true, recursiveMkdir: true, remove: true, removeDirectory: true, recursiveRemove: true,
+    rename: true, atomicRenameNoReplace: true, copy: true, exclusiveCopy: true, readlink: true, truncate: true,
+    streamingAppend: true, randomAccessWrite: true,
+    readOnly: false,
+    symlinks: true, conditionalChmod: true,
+    hardlinks: true,
+    permissions: true,
+    timestamps: true,
+    atomicRename: true,
+    atomicFileStaging: true, retainedStagingCleanup: true, retainedStagingWrite: true, atomicStagingAncestry: true, atomicFileMutation: true, atomicEntryRemoval: true, atomicEntryRemovalReceipt: true, atomicTreeRemoval: true,
+    synchronousDirectoryValidation: true, synchronousStagingResolution: true, guardedStagingPublication: true,
+    atomicDirectoryMetadata: true,
+    streamingRead: true,
+    retainedRead: true,
+    retainedResize: true,
+    streamingWrite: true,
+    descriptorWriteStream: true,
+});
+function customMemoryCapabilities(filesystem) {
+    return Object.freeze({
+        ...SHARED_STOCK_MEMORY_CAPABILITIES,
+        get retainedResize() { return stockRetainedResize(filesystem); },
+        get descriptorWriteStream() { return stockDescriptorWrite(filesystem); },
+    });
+}
 export class MemoryFileSystem {
     capabilitiesFor;
-    capabilities = ((filesystem) => {
-        return Object.freeze({
-            read: true, stat: true, readdir: true, realpath: true, access: true, open: true,
-            write: true, append: true, exclusiveCreate: true, explicitDirectories: true, implicitDirectories: false,
-            mkdir: true, recursiveMkdir: true, remove: true, removeDirectory: true, recursiveRemove: true,
-            rename: true, atomicRenameNoReplace: true, copy: true, exclusiveCopy: true, readlink: true, truncate: true,
-            streamingAppend: true, randomAccessWrite: true,
-            readOnly: false,
-            symlinks: true, conditionalChmod: true,
-            hardlinks: true,
-            permissions: true,
-            timestamps: true,
-            atomicRename: true,
-            atomicFileStaging: true, retainedStagingCleanup: true, retainedStagingWrite: true, atomicStagingAncestry: true, atomicFileMutation: true, atomicEntryRemoval: true, atomicEntryRemovalReceipt: true, atomicTreeRemoval: true,
-            synchronousDirectoryValidation: true, synchronousStagingResolution: true, guardedStagingPublication: true,
-            atomicDirectoryMetadata: true,
-            streamingRead: true,
-            retainedRead: true,
-            get retainedResize() { return stockRetainedResize(filesystem); },
-            streamingWrite: true,
-            get descriptorWriteStream() { return stockDescriptorWrite(filesystem); },
-        });
-    })(this);
-    identityScope = Symbol();
+    #customCapabilities;
+    #identityScopeSym;
+    get identityScope() {
+        return (this.#identityScopeSym ??= Symbol());
+    }
+    get capabilities() {
+        if (!this.#customCapabilities) {
+            this.#customCapabilities = customMemoryCapabilities(this);
+            this._owner.capabilities = this.#customCapabilities;
+        }
+        return this.#customCapabilities;
+    }
     nextInode = 1;
     ledger;
     _cache;
@@ -624,26 +647,34 @@ export class MemoryFileSystem {
     root;
     totalBytes = 0;
     symlinkCount = 0;
-    constructor(options = {}) {
-        this.ledger = new MemoryLedger(normalizeMemoryFileSystemLimits(options));
-        if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes) {
-            replenishSharedMemoryPools();
+    #atomicView;
+    _getAtomicView() {
+        const owner = ownedStores.get(this);
+        if (!owner ||
+            Object.getPrototypeOf(this) !== MemoryFileSystem.prototype ||
+            this.root !== owner.root ||
+            this.ledger !== owner.ledger ||
+            this.capabilities !== owner.capabilities) {
+            return undefined;
         }
-        const cache = new MemoryCache();
-        this._cache = cache;
-        memoryCaches.set(this.ledger, cache);
-        this.ledger.reserve(0, 1, "mkdir", "/");
-        this.root = this.directory(0o755);
-        const root = this.root;
-        const owner = {
-            root,
-            ledger: this.ledger,
-            capabilities: this.capabilities,
-            intact: () => this.root === root,
-        };
-        this._owner = owner;
-        ownedStores.set(this, owner);
-        registerMemoryAtomicView(this, {
+        const proto = MemoryFileSystem.prototype;
+        for (let i = 0; i < memoryImplementationKeys.length; i++) {
+            const name = memoryImplementationKeys[i];
+            const expected = memoryImplementationDescriptors[i];
+            if (name === "capabilities")
+                continue;
+            if (Object.prototype.hasOwnProperty.call(this, name)) {
+                const actual = Object.getOwnPropertyDescriptor(this, name);
+                if (!actual || actual.value !== expected.value || actual.get !== expected.get || actual.set !== expected.set)
+                    return undefined;
+            }
+            else if (expected.get !== undefined || expected.set !== undefined || proto[name] !== expected.value) {
+                const actual = Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, name);
+                if (!actual || actual.value !== expected.value || actual.get !== expected.get || actual.set !== expected.set)
+                    return undefined;
+            }
+        }
+        return this.#atomicView ??= {
             stat: (path) => {
                 this.validatePath(path, "overlayAtomicView");
                 let node = this.root;
@@ -665,30 +696,28 @@ export class MemoryFileSystem {
                     this.fail("ENOTDIR", "overlayAtomicView", path);
                 return [...node.entries.keys()];
             },
-        }, () => {
-            if (Object.getPrototypeOf(this) !== MemoryFileSystem.prototype ||
-                this.root !== root ||
-                this.ledger !== ownedStores.get(this)?.ledger ||
-                this.capabilities !== ownedStores.get(this)?.capabilities) {
-                return false;
-            }
-            const proto = MemoryFileSystem.prototype;
-            for (let i = 0; i < memoryImplementationKeys.length; i++) {
-                const name = memoryImplementationKeys[i];
-                const expected = memoryImplementationDescriptors[i];
-                if (Object.prototype.hasOwnProperty.call(this, name)) {
-                    const actual = Object.getOwnPropertyDescriptor(this, name);
-                    if (!actual || actual.value !== expected.value || actual.get !== expected.get || actual.set !== expected.set)
-                        return false;
-                }
-                else if (expected.get !== undefined || expected.set !== undefined || proto[name] !== expected.value) {
-                    const actual = Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, name);
-                    if (!actual || actual.value !== expected.value || actual.get !== expected.get || actual.set !== expected.set)
-                        return false;
-                }
-            }
-            return true;
-        });
+        };
+    }
+    constructor(options = {}) {
+        this.ledger = new MemoryLedger(normalizeMemoryFileSystemLimits(options));
+        if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes) {
+            replenishSharedMemoryPools();
+        }
+        const cache = new MemoryCache();
+        this._cache = cache;
+        memoryCaches.set(this.ledger, cache);
+        this.ledger.reserve(0, 1, "mkdir", "/");
+        this.root = this.directory(0o755);
+        const root = this.root;
+        const owner = {
+            root,
+            ledger: this.ledger,
+            capabilities: SHARED_STOCK_MEMORY_CAPABILITIES,
+            intact: () => this.root === root,
+        };
+        this._owner = owner;
+        ownedStores.set(this, owner);
+        registerLazyMemoryAtomicView(this, memoryImplementation._getAtomicView.value);
         if (this.compareEntry === memoryImplementation.compareEntry?.value) {
             registeredAuthorities.add(this);
             registerEntryAuthority(this, compareOwnedMemory);
@@ -2896,7 +2925,10 @@ export class MemoryFileSystem {
             if (!descriptor || !("value" in descriptor) || descriptor.value !== memoryImplementation[name]?.value)
                 unsupported();
         }
-        const retainedRead = Object.getOwnPropertyDescriptor(this, "capabilities")?.value?.retainedRead;
+        const capabilities = Object.getOwnPropertyDescriptor(this, "capabilities");
+        const retainedRead = capabilities === undefined
+            ? Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, "capabilities")?.get === memoryImplementation.capabilities?.get
+            : capabilities.value?.retainedRead;
         signal?.throwIfAborted();
         if (retainedRead !== true)
             unsupported();
@@ -3036,7 +3068,7 @@ function stockDescriptorWrite(filesystem) {
         return false;
     const owner = ownedStores.get(filesystem);
     const capDesc = Object.getOwnPropertyDescriptor(filesystem, "capabilities");
-    return !!capDesc && "value" in capDesc && capDesc.value === owner.capabilities;
+    return (capDesc === undefined && Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, "capabilities")?.get === memoryImplementation.capabilities?.get) || (!!capDesc && "value" in capDesc && capDesc.value === owner.capabilities);
 }
 function stockRetainedResize(filesystem) {
     if (!stockDescriptorWrite(filesystem) || !isStockMemoryMethods(filesystem, stockRetainedResizeMethodNames, false))
@@ -3395,7 +3427,7 @@ export function tryResolveMemoryDevicePath(filesystem, path, resizeCreate) {
         start = slash + 1;
     }
 }
-const cachedMethodValuesMap = new WeakMap();
+const cachedMethodValuesMap = /* @__PURE__ */ new WeakMap();
 function getExpectedMethodValues(names) {
     let vals = cachedMethodValuesMap.get(names);
     if (!vals) {
@@ -3718,3 +3750,17 @@ export function tryWriteMemoryFileInDirSync(filesystem, dirPrefix, name, data, a
     mem.writeMemoryFileInDirFast(dirPrefix, name, data, append, mode);
     return true;
 }
+const _memHooks = (globalThis.__safeBashMemHooks ??= { protos: new Set(), byProto: new Map() });
+_memHooks.protos.add(MemoryFileSystem.prototype);
+_memHooks.byProto.set(MemoryFileSystem.prototype, {
+    tryGetMemoryDirectoryEntryNamesSync,
+    tryReadMemoryFileViewSync,
+    tryResolveMemoryDevicePath,
+    tryOpenMemoryRedirectHandleSync,
+    tryWriteMemoryFileSync,
+    tryMkdirMemorySync,
+    tryRmRfMemorySync,
+    tryWriteMemoryFileInDirSync,
+});
+_memHooks.isCleanAbsolutePath = isCleanAbsolutePath;
+_memHooks.bindConditionalMutation = bindConditionalMutation;

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

@@ -7,6 +7,9 @@ export const defaultMemoryFileSystemLimits = Object.freeze({
     maxMetadataUnits: Infinity,
 });
 export function normalizeMemoryFileSystemLimits(options) {
+    if (options === undefined || (typeof options === "object" && options !== null && Object.getPrototypeOf(options) === Object.prototype && Reflect.ownKeys(options).length === 0)) {
+        return defaultMemoryFileSystemLimits;
+    }
     const keys = ["maxPathBytes", "maxPathComponents", "maxFileBytes", "maxRetainedBytes", "maxMetadataUnits"];
     const record = readConfigRecord(options, "memory option", [...keys, "maxBytes"]);
     const limits = { ...defaultMemoryFileSystemLimits };

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

@@ -29,7 +29,7 @@ export async function resolveEntryView(filesystem, path, options = {}) {
         readOnly ||= location.readOnly === true || location.filesystem.capabilities.readOnly === true;
         if (location.stat)
             return { filesystem: location.filesystem, path: location.path, stat: location.stat, readOnly };
-        const resolve = resolvers.get(location.filesystem);
+        const resolve = resolvers.get(location.filesystem) ?? location.filesystem._resolveEntryView;
         if (!resolve) {
             let stat;
             let followedPath;
@@ -49,7 +49,7 @@ export async function resolveEntryView(filesystem, path, options = {}) {
         }
         let next;
         try {
-            next = await resolve(location.path, options);
+            next = await resolve.call(location.filesystem, location.path, options);
         }
         catch (error) {
             options.signal?.throwIfAborted();
@@ -74,7 +74,7 @@ export async function compareResolvedEntries(own, peer, options = {}) {
         let result = "unknown";
         for (const [left, right] of [[own, peer], [peer, own]]) {
             options.signal?.throwIfAborted();
-            const authority = authorities.get(left.filesystem);
+            const authority = authorities.get(left.filesystem) ?? left.filesystem._entryAuthority;
             const key = authority ?? left.filesystem;
             if (queried.has(key))
                 continue;

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/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/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.804",
+  "version": "0.1.805",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",
@@ -126,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": {