@poe-platform/safe-fs 0.1.804 → 0.1.806

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;
@@ -316,13 +324,6 @@ class FastDirectoryEntriesMap {
 }
 const SHARED_POOL_CAPACITY = 256;
 const SHARED_DIR_POOL_CAPACITY = 64;
-const sharedAllocationPool = new Array(SHARED_POOL_CAPACITY).fill(DUMMY_POOL_ALLOCATION);
-let sharedAllocationPoolLen = 0;
-const SHARED_LARGE_POOL_CAPACITY = 8;
-const sharedLargeAllocationPool = new Array(SHARED_LARGE_POOL_CAPACITY).fill(DUMMY_POOL_ALLOCATION);
-let sharedLargeAllocationPoolLen = 0;
-const sharedMediumAllocationPool = new Array(SHARED_LARGE_POOL_CAPACITY).fill(DUMMY_POOL_ALLOCATION);
-let sharedMediumAllocationPoolLen = 0;
 const sharedFileNodePool = new Array(SHARED_POOL_CAPACITY).fill(DUMMY_POOL_FILE_NODE);
 let sharedFileNodePoolLen = 0;
 const sharedDirectoryNodePool = new Array(SHARED_DIR_POOL_CAPACITY);
@@ -343,27 +344,9 @@ function collectRemovedChild(child, name) {
     sharedRemovedKeyEntries++;
 }
 function replenishSharedMemoryPools() {
-    while (sharedAllocationPoolLen < 112) {
-        DUMMY_POOL_LEDGER.reserve(64, 0, "init", "/");
-        const alloc = new MemoryAllocation(new Uint8Array(64), DUMMY_POOL_LEDGER);
-        alloc.release();
-        sharedAllocationPool[sharedAllocationPoolLen++] = alloc;
-    }
     while (sharedFileNodePoolLen < 112) {
         sharedFileNodePool[sharedFileNodePoolLen++] = new MemoryFileNode(0, 0, 0, 0, DUMMY_POOL_ALLOCATION, undefined);
     }
-    while (sharedLargeAllocationPoolLen < 4) {
-        DUMMY_POOL_LEDGER.reserve(65536, 0, "init", "/");
-        const alloc = new MemoryAllocation(new Uint8Array(65536), DUMMY_POOL_LEDGER);
-        alloc.release();
-        sharedLargeAllocationPool[sharedLargeAllocationPoolLen++] = alloc;
-    }
-    while (sharedMediumAllocationPoolLen < 4) {
-        DUMMY_POOL_LEDGER.reserve(16384, 0, "init", "/");
-        const alloc = new MemoryAllocation(new Uint8Array(16384), DUMMY_POOL_LEDGER);
-        alloc.release();
-        sharedMediumAllocationPool[sharedMediumAllocationPoolLen++] = alloc;
-    }
     while (sharedDirectoryNodePoolLen < 16) {
         sharedDirectoryNodePool[sharedDirectoryNodePoolLen++] = new MemoryDirectoryNode(0, 0, 0);
     }
@@ -395,7 +378,6 @@ Object.assign(MemoryDirectoryNode.prototype, {
 const DUMMY_POOL_DIR_NODE = new MemoryDirectoryNode(0, 0, null);
 DUMMY_POOL_DIR_NODE.atimeMs = DUMMY_POOL_DIR_NODE.mtimeMs = DUMMY_POOL_DIR_NODE.ctimeMs = DUMMY_POOL_DIR_NODE.birthtimeMs = 1700000000000;
 class MemoryCache {
-    allocations = [];
     files = [];
     directories = [];
     removedScratch = [];
@@ -415,7 +397,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();
@@ -590,32 +571,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 +621,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 +670,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);
@@ -882,21 +885,6 @@ export class MemoryFileSystem {
             node.sourceRef = undefined;
             node.allocation = DUMMY_POOL_ALLOCATION;
             alloc.release();
-            if (alloc.isReleased64()) {
-                alloc.detachLedger(DUMMY_POOL_LEDGER);
-                if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedAllocationPoolLen < SHARED_POOL_CAPACITY) {
-                    sharedAllocationPool[sharedAllocationPoolLen++] = alloc;
-                }
-                else if (cache.allocations.length < 128) {
-                    cache.allocations.push(alloc);
-                }
-            }
-            else if (alloc.isReleased65536()) {
-                alloc.detachLedger(DUMMY_POOL_LEDGER);
-                if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedLargeAllocationPoolLen < SHARED_LARGE_POOL_CAPACITY) {
-                    sharedLargeAllocationPool[sharedLargeAllocationPoolLen++] = alloc;
-                }
-            }
             if (sharedFileNodePoolLen < SHARED_POOL_CAPACITY) {
                 sharedFileNodePool[sharedFileNodePoolLen++] = node;
             }
@@ -936,18 +924,6 @@ export class MemoryFileSystem {
         node.view = length === allocation.data.byteLength ? allocation.data : undefined;
         node.allocation = allocation;
         previous.release();
-        if (previous.isReleased64()) {
-            previous.detachLedger(DUMMY_POOL_LEDGER);
-            if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedAllocationPoolLen < SHARED_POOL_CAPACITY) {
-                sharedAllocationPool[sharedAllocationPoolLen++] = previous;
-            }
-        }
-        else if (previous.isReleased65536()) {
-            previous.detachLedger(DUMMY_POOL_LEDGER);
-            if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedLargeAllocationPoolLen < SHARED_LARGE_POOL_CAPACITY) {
-                sharedLargeAllocationPool[sharedLargeAllocationPoolLen++] = previous;
-            }
-        }
     }
     admitSize(node, length, syscall, path) {
         this.ledger.fileSize(length, syscall, path);
@@ -1325,36 +1301,7 @@ export class MemoryFileSystem {
         if (length === 0) {
             return DUMMY_POOL_ALLOCATION;
         }
-        if (length === 16384) {
-            if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedMediumAllocationPoolLen > 0) {
-                const pooled = sharedMediumAllocationPool[--sharedMediumAllocationPoolLen];
-                sharedMediumAllocationPool[sharedMediumAllocationPoolLen] = DUMMY_POOL_ALLOCATION;
-                pooled.reuse(this.ledger);
-                return pooled;
-            }
-        }
-        if (length === 65536) {
-            if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedLargeAllocationPoolLen > 0) {
-                const pooled = sharedLargeAllocationPool[--sharedLargeAllocationPoolLen];
-                sharedLargeAllocationPool[sharedLargeAllocationPoolLen] = DUMMY_POOL_ALLOCATION;
-                pooled.reuse(this.ledger);
-                return pooled;
-            }
-        }
-        if (length === 64) {
-            let pooled;
-            if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedAllocationPoolLen > 0) {
-                pooled = sharedAllocationPool[--sharedAllocationPoolLen];
-                sharedAllocationPool[sharedAllocationPoolLen] = DUMMY_POOL_ALLOCATION;
-            }
-            else {
-                pooled = memoryCaches.get(this.ledger).allocations.pop();
-            }
-            if (pooled) {
-                pooled.reuse(this.ledger);
-                return pooled;
-            }
-        }
+        // Views can outlive files: never recycle their backing buffers across owners.
         try {
             return new MemoryAllocation(new Uint8Array(length), this.ledger);
         }
@@ -2300,6 +2247,93 @@ export class MemoryFileSystem {
             this.fail("EAGAIN", "publishStagedFile", destination);
         return MemoryFileSystem.prototype.rename.call(this, staging.file.path, destination, { ...controls, noReplace: expected === null });
     }
+    async publishStagedFileSet(receipt, destination, options) {
+        const signal = options.signal;
+        const guard = options.commitGuard;
+        const ancestors = options.ancestors === undefined ? undefined : snapshotDirectoryAncestry(options.ancestors);
+        const snapshot = (entry) => ({ path: entry.path, stat: { ...entry.stat } });
+        const staging = { parent: snapshot(receipt.parent), directory: snapshot(receipt.directory), file: snapshot(receipt.file) };
+        const parent = { ...options.parent };
+        const expected = options.destination === null ? null : { ...options.destination };
+        const companions = options.companions.map(entry => ({ path: entry.path, expected: entry.expected === null ? null : { ...entry.expected }, remove: entry.remove }));
+        const syscall = "publishStagedFileSet";
+        const parentPath = destination.slice(0, destination.lastIndexOf("/")) || "/";
+        const paths = new Set([destination]);
+        const canonical = (path) => path.startsWith("/") && path.slice(1).split("/").every(part => part !== "" && part !== "." && part !== "..");
+        if (!canonical(destination) || ancestors && ancestors.at(-1)?.path !== parentPath)
+            this.fail("EINVAL", syscall, destination);
+        for (const entry of companions) {
+            if (!canonical(entry.path) || paths.has(entry.path) || (entry.path.slice(0, entry.path.lastIndexOf("/")) || "/") !== parentPath)
+                this.fail("EINVAL", syscall, entry.path);
+            paths.add(entry.path);
+        }
+        signal?.throwIfAborted();
+        if (guard !== undefined)
+            runStagingGuard(guard);
+        signal?.throwIfAborted();
+        if (ancestors)
+            this.verifyDirectoryAncestry(ancestors, signal === undefined ? {} : { signal });
+        const { directory, file } = this.stagingLocations(staging);
+        this.expectEntry(file.node, staging.file.stat, staging.file.path);
+        const target = this.entry(destination, syscall, true);
+        this.expectEntry(target.parent, parent, destination, false);
+        this.expectEntry(target.node, expected, destination);
+        const node = file.node;
+        if (node.type !== "file" || target.parent === directory.node || target.node === node)
+            this.fail("EINVAL", syscall, destination);
+        if (target.node && target.node.type !== "file")
+            this.fail("EAGAIN", syscall, destination);
+        this.permission(file.parent, 3, syscall, staging.file.path);
+        this.permission(target.parent, 3, syscall, destination);
+        const retired = [];
+        for (const companion of companions) {
+            const location = this.entry(companion.path, syscall, true);
+            if (location.parent !== target.parent || location.node === node)
+                this.fail("EINVAL", syscall, companion.path);
+            this.expectEntry(location.node, companion.expected, companion.path);
+            if (location.node && location.node.type !== "file")
+                this.fail("EAGAIN", syscall, companion.path);
+            if (companion.remove && location.node)
+                retired.push(location);
+        }
+        const now = Date.now();
+        const published = { ...this.snapshot(node), ctimeMs: now, revision: Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1) };
+        // Admission and all source-set checks precede the single synchronous commit.
+        // No calls to overridable async mutations can interleave a partial result.
+        const nameGrowth = target.node ? 0 : (target.name.length - file.name.length) * 2;
+        this.ledger.reserve(Math.max(0, nameGrowth), 0, syscall, destination);
+        try {
+            target.parent.entries.set(target.name, node);
+        }
+        catch (error) {
+            this.ledger.release(Math.max(0, nameGrowth), 0);
+            throw error;
+        }
+        memoryCaches.get(this.ledger).clearWrites();
+        file.parent.entries.delete(file.name);
+        const unlink = (entry) => {
+            entry.node.nlink--;
+            entry.node.ctimeMs = now;
+            entry.node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, entry.node.revision + 1);
+            this.releaseNode(entry.node);
+        };
+        if (target.node) {
+            this.ledger.release(file.name.length * 2, 1);
+            unlink(target);
+        }
+        else if (nameGrowth < 0)
+            this.ledger.release(-nameGrowth, 0);
+        for (const entry of retired) {
+            entry.parent.entries.delete(entry.name);
+            this.ledger.release(entry.name.length * 2, 1);
+            unlink(entry);
+        }
+        this.changed(file.parent, now);
+        this.changed(target.parent, now);
+        node.ctimeMs = now;
+        node.revision = published.revision;
+        return published;
+    }
     async removeStagedFile(staging, options = {}) {
         options.signal?.throwIfAborted();
         const { directory, file } = this.stagingLocations(staging);
@@ -2896,7 +2930,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 +3073,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 +3432,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 +3755,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/ledger.d.ts

@@ -23,8 +23,4 @@ export declare class MemoryAllocation {
     constructor(data: Uint8Array, ledger: MemoryLedger);
     retain(): void;
     release(): void;
-    isReleased64(): boolean;
-    isReleased65536(): boolean;
-    detachLedger(dummyLedger: MemoryLedger): void;
-    reuse(ledger?: MemoryLedger): void;
 }

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

@@ -89,21 +89,6 @@ export class MemoryAllocation {
             this.ledger.release(this.data.byteLength, 0);
         }
     }
-    isReleased64() {
-        return this.references === 0 && this.data.byteLength === 64;
-    }
-    isReleased65536() {
-        return this.references === 0 && this.data.byteLength === 65536;
-    }
-    detachLedger(dummyLedger) {
-        this.ledger = dummyLedger;
-    }
-    reuse(ledger) {
-        this.references = 1;
-        if (ledger !== undefined)
-            this.ledger = ledger;
-        this.data.fill(0);
-    }
 }
 Object.assign(MemoryAllocation.prototype, {
     references: 1,

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/mount/identity.d.ts

@@ -1,2 +1,6 @@
 import type { FileStat } from "../../contracts/filesystem.js";
 export declare function compareIdentity(left: FileStat | undefined, right: FileStat | undefined): "same" | "distinct" | "unknown";
+/** Compare content snapshots, including adapter generations when supplied.
+ * Identity is checked separately so identityless streaming adapters remain usable.
+ */
+export declare function compareFileVersion(left: FileStat, right: FileStat): boolean;

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

@@ -19,3 +19,11 @@ export function compareIdentity(left, right) {
         return "distinct";
     return "unknown";
 }
+/** Compare content snapshots, including adapter generations when supplied.
+ * Identity is checked separately so identityless streaming adapters remain usable.
+ */
+export function compareFileVersion(left, right) {
+    return left.type === right.type && left.size === right.size
+        && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs
+        && left.revision === right.revision && left.opaqueVersion === right.opaqueVersion;
+}

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

@@ -12,6 +12,7 @@ export declare class MountFileSystem implements FileSystem {
     private namespaceMutation;
     private readonly namespaceWaiters;
     constructor(options: MountFileSystemOptions);
+    confineExtraction(roots: readonly string[], options?: FsOptions): Promise<FileSystem>;
     private select;
     capabilitiesFor(path: string, options?: CapabilityQueryOptions): Promise<FileSystemCapabilities>;
     private supportsStagingAncestry;

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

@@ -9,6 +9,7 @@ import { pathNamespace } from "../path-namespace.js";
 import { createStagingCleanup, snapshotStagingCreation } from "../staging-cleanup.js";
 import { directoryAncestryPaths, inspectStagingBindings, runStagingGuard, snapshotDirectoryAncestry, snapshotStagingResolution } from "../staging-ancestry.js";
 import { compareIdentity } from "./identity.js";
+import { createReadOnlyFileSystem } from "../readonly/index.js";
 import { snapshotConditionalChmod } from "../conditional-chmod.js";
 import { compareEntries, registerEntryAuthority, registerEntryView } from "./comparison.js";
 const syntheticStat = Object.freeze({
@@ -150,6 +151,36 @@ export class MountFileSystem {
             ...(retainedRead === undefined ? {} : { retainedRead }),
         });
     }
+    async confineExtraction(roots, options = {}) {
+        options.signal?.throwIfAborted();
+        const root = this.select("/").backend;
+        const captured = [...roots];
+        for (const path of captured) {
+            validatePath(path);
+            if (normalizePath(globalPath(path)) !== path)
+                fail("EINVAL");
+            // A backing confinement retains its own root-to-destination ancestry.
+            // It cannot retain directories belonging to another mounted backend.
+            if (this.select(path).path !== "/")
+                fail("ENOTSUP");
+        }
+        if (!root.confineExtraction)
+            fail("ENOTSUP");
+        const confined = await root.confineExtraction(captured, options);
+        options.signal?.throwIfAborted();
+        const observations = new Set(["prepareDirectoryAncestry", "prepareStagingResolution"]);
+        const backing = new Proxy(confined, {
+            get(target, key) {
+                // These only capture/validate bindings. Mutations must always use the
+                // backend's confined view, including creation, metadata and hardlinks.
+                const owner = observations.has(key) ? root : target;
+                const value = Reflect.get(owner, key);
+                return typeof value === "function" ? value.bind(owner) : value;
+            },
+        });
+        return new MountFileSystem({ root: backing, mounts: Object.fromEntries(this.mounts.filter(mount => mount.path !== "/").map(mount => [mount.path,
+                mount.backend.capabilities.readOnly === true ? mount.backend : createReadOnlyFileSystem(mount.backend)])) });
+    }
     select(path) {
         return this.mounts.find((mount) => within(mount.path, path));
     }