@poe-platform/safe-fs 0.1.803 → 0.1.805

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";
@@ -46,24 +46,21 @@ Object.assign(MemoryFileNode.prototype, {
     sourceRef: undefined,
 });
 const EMPTY_ALLOC_BYTES = new Uint8Array(0);
-const SMALL_ALLOC_SLAB_SIZE = 8192;
-let smallAllocSlab = new Uint8Array(SMALL_ALLOC_SLAB_SIZE);
-let smallAllocOffset = 0;
 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 defaultDateNow = Date.now;
-let fastWriteCachedNow = Date.now();
-let fastWriteNowTick = 0;
+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";
@@ -96,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;
@@ -211,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;
@@ -350,19 +352,13 @@ function collectRemovedChild(child, name) {
 }
 function replenishSharedMemoryPools() {
     while (sharedAllocationPoolLen < 112) {
-        if (smallAllocOffset + 64 > SMALL_ALLOC_SLAB_SIZE) {
-            smallAllocSlab = new Uint8Array(SMALL_ALLOC_SLAB_SIZE);
-            smallAllocOffset = 0;
-        }
-        const slice = smallAllocSlab.subarray(smallAllocOffset, smallAllocOffset + 64);
-        smallAllocOffset += 64;
         DUMMY_POOL_LEDGER.reserve(64, 0, "init", "/");
-        const alloc = new MemoryAllocation(slice, DUMMY_POOL_LEDGER);
+        const alloc = new MemoryAllocation(new Uint8Array(64), DUMMY_POOL_LEDGER);
         alloc.release();
         sharedAllocationPool[sharedAllocationPoolLen++] = alloc;
     }
     while (sharedFileNodePoolLen < 112) {
-        sharedFileNodePool[sharedFileNodePoolLen++] = new MemoryFileNode(0, 0, fastWriteCachedNow, 0, DUMMY_POOL_ALLOCATION, undefined);
+        sharedFileNodePool[sharedFileNodePoolLen++] = new MemoryFileNode(0, 0, 0, 0, DUMMY_POOL_ALLOCATION, undefined);
     }
     while (sharedLargeAllocationPoolLen < 4) {
         DUMMY_POOL_LEDGER.reserve(65536, 0, "init", "/");
@@ -377,7 +373,7 @@ function replenishSharedMemoryPools() {
         sharedMediumAllocationPool[sharedMediumAllocationPoolLen++] = alloc;
     }
     while (sharedDirectoryNodePoolLen < 16) {
-        sharedDirectoryNodePool[sharedDirectoryNodePoolLen++] = new MemoryDirectoryNode(0, 0, fastWriteCachedNow);
+        sharedDirectoryNodePool[sharedDirectoryNodePoolLen++] = new MemoryDirectoryNode(0, 0, 0);
     }
 }
 class MemoryDirectoryNode {
@@ -427,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();
@@ -453,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;
@@ -602,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;
@@ -636,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;
@@ -677,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);
@@ -897,7 +914,6 @@ export class MemoryFileSystem {
             if (alloc.isReleased64()) {
                 alloc.detachLedger(DUMMY_POOL_LEDGER);
                 if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedAllocationPoolLen < SHARED_POOL_CAPACITY) {
-                    alloc.data.fill(0);
                     sharedAllocationPool[sharedAllocationPoolLen++] = alloc;
                 }
                 else if (cache.allocations.length < 128) {
@@ -907,7 +923,6 @@ export class MemoryFileSystem {
             else if (alloc.isReleased65536()) {
                 alloc.detachLedger(DUMMY_POOL_LEDGER);
                 if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedLargeAllocationPoolLen < SHARED_LARGE_POOL_CAPACITY) {
-                    alloc.data.fill(0);
                     sharedLargeAllocationPool[sharedLargeAllocationPoolLen++] = alloc;
                 }
             }
@@ -953,14 +968,12 @@ export class MemoryFileSystem {
         if (previous.isReleased64()) {
             previous.detachLedger(DUMMY_POOL_LEDGER);
             if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedAllocationPoolLen < SHARED_POOL_CAPACITY) {
-                previous.data.fill(0);
                 sharedAllocationPool[sharedAllocationPoolLen++] = previous;
             }
         }
         else if (previous.isReleased65536()) {
             previous.detachLedger(DUMMY_POOL_LEDGER);
             if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedLargeAllocationPoolLen < SHARED_LARGE_POOL_CAPACITY) {
-                previous.data.fill(0);
                 sharedLargeAllocationPool[sharedLargeAllocationPoolLen++] = previous;
             }
         }
@@ -1372,17 +1385,6 @@ export class MemoryFileSystem {
             }
         }
         try {
-            // A shared slab's backing buffer exceeds the admitted slice capacity.
-            // Finite file/storage ceilings require independently owned exact buffers.
-            if (length <= 64 && this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes) {
-                if (smallAllocOffset + length > SMALL_ALLOC_SLAB_SIZE) {
-                    smallAllocSlab = new Uint8Array(SMALL_ALLOC_SLAB_SIZE);
-                    smallAllocOffset = 0;
-                }
-                const slice = smallAllocSlab.subarray(smallAllocOffset, smallAllocOffset + length);
-                smallAllocOffset += length;
-                return new MemoryAllocation(slice, this.ledger);
-            }
             return new MemoryAllocation(new Uint8Array(length), this.ledger);
         }
         catch (cause) {
@@ -1568,11 +1570,12 @@ export class MemoryFileSystem {
             }
             if (position > curLen)
                 storage.fill(0, curLen, position);
+            const source = data;
             if (dataLen === data.byteLength) {
                 storage.set(data, position);
             }
-            else if (typeof data.copy === "function") {
-                data.copy(storage, position, 0, dataLen);
+            else if (typeof source.copy === "function") {
+                source.copy(storage, position, 0, dataLen);
             }
             else {
                 for (let i = 0; i < dataLen; i++)
@@ -1771,7 +1774,7 @@ export class MemoryFileSystem {
                 1 + batchCount <= entries._keys.length) {
                 this.ledger.reserve(totalNameBytes, 2 * batchCount, "writeFile", fileNames[batchCount - 1]);
                 this.totalBytes += payloadBytesSum;
-                const now = fastWriteCachedNow;
+                const now = Date.now();
                 const fileMode = typeModes.file | mode;
                 let ino = this.nextInode;
                 this.nextInode = ino + batchCount;
@@ -1844,7 +1847,7 @@ export class MemoryFileSystem {
             const existing = nameHash !== undefined ? entries.getForWriteWithHash(name, nameHash) : entries.getForWrite(name);
             if (existing === undefined && entries._next < entries._keys.length) {
                 this.ledger.reserve(name.length * 2, 2, "writeFile", name);
-                const now = fastWriteCachedNow;
+                const now = Date.now();
                 const length = data.byteLength;
                 const node = sharedFileNodePool[--sharedFileNodePoolLen];
                 sharedFileNodePool[sharedFileNodePoolLen] = DUMMY_POOL_FILE_NODE;
@@ -1966,7 +1969,7 @@ export class MemoryFileSystem {
                         allocation.data.set(data);
                     this.ledger.reserve(nameBytes, 2, syscall, name);
                     try {
-                        const now = fastWriteCachedNow;
+                        const now = Date.now();
                         const fileMode = typeModes.file | mode;
                         const view = zeroCopyConst ? new Uint8Array(data) : (capacity === length ? allocation.data : undefined);
                         let node;
@@ -2047,7 +2050,7 @@ export class MemoryFileSystem {
     }
     async readFile(path, options = {}) {
         options.signal?.throwIfAborted();
-        if (options.maxBytes !== undefined)
+        if (options.maxBytes !== undefined && options.maxBytes !== Infinity)
             this.integer(options.maxBytes, "readFile", path);
         const node = this.file(path, "readFile");
         this.permission(node, 4, "readFile", path);
@@ -2922,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();
@@ -3062,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))
@@ -3120,7 +3126,7 @@ export class MemoryRedirectHandle {
         if (len === 0)
             return;
         const pos = this.append ? this.node.byteLength : this.position;
-        const now = Date.now === defaultDateNow ? fastWriteCachedNow : Date.now();
+        const now = Date.now();
         this.fs.writeAtRange(this.node, src, len, pos, "write", this.path, now);
         if (!this.append)
             this.position = pos + len;
@@ -3140,7 +3146,7 @@ export class MemoryRedirectHandle {
             mem.ledger.hasInfiniteRetained &&
             mem.ledger.hasInfiniteFileBytes &&
             mem.ledger.limits.maxBytes === undefined) {
-            const now = Date.now === defaultDateNow ? fastWriteCachedNow : Date.now();
+            const now = Date.now();
             this.node.byteLength = len;
             this.node.view = immutableData;
             this.node.sourceRef = immutableData;
@@ -3266,7 +3272,7 @@ export function tryOpenMemoryRedirectHandleSync(filesystem, path, append, mode,
         }
         const cache = mem._cache;
         cache.clearWrites();
-        const now = Date.now === defaultDateNow ? ((++fastWriteNowTick & 63) === 0 ? (fastWriteCachedNow = Date.now()) : fastWriteCachedNow) : Date.now();
+        const now = Date.now();
         const fileMode = typeModes.file | validMode;
         let newNode;
         if (sharedFileNodePoolLen > 0) {
@@ -3421,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) {
@@ -3467,7 +3473,7 @@ export function getLastReadMemoryFileSourceRef(view) {
     lastReadViewSourceRef = undefined;
     return ref;
 }
-export function tryReadMemoryFileViewSync(filesystem, path, maxBytes, signal, captureSourceRef = false) {
+export function tryReadMemoryFileViewSync(filesystem, path, maxBytes, signal, captureSourceRef = false, beforeRead) {
     // A capture belongs only to the most recent read, including failed/fallback reads.
     lastReadViewData = undefined;
     lastReadViewSourceRef = undefined;
@@ -3475,19 +3481,15 @@ export function tryReadMemoryFileViewSync(filesystem, path, maxBytes, signal, ca
     if (mem._owner === undefined || !isStockMemoryMethods(mem, readFileFastMethodNames, false))
         return undefined;
     signal?.throwIfAborted();
-    if (maxBytes !== undefined)
+    beforeRead?.();
+    if (maxBytes !== undefined && maxBytes !== Infinity)
         mem.integer(maxBytes, "readFile", path);
     const node = mem.file(path, "readFile");
     mem.permission(node, 4, "readFile", path);
     const data = node.data;
     if (maxBytes !== undefined && data.byteLength > maxBytes)
         mem.fail("EFBIG", "readFile", path);
-    if (Date.now !== defaultDateNow)
-        node.atimeMs = Date.now();
-    else if ((++fastWriteNowTick & 63) === 0)
-        node.atimeMs = fastWriteCachedNow = Date.now();
-    else
-        node.atimeMs = fastWriteCachedNow;
+    node.atimeMs = Date.now();
     if (captureSourceRef && node.revision === 0) {
         lastReadViewData = new WeakRef(data);
         lastReadViewSourceRef = node.sourceRef === undefined ? undefined : new WeakRef(node.sourceRef);
@@ -3570,7 +3572,7 @@ export function tryGetMemoryDirectoryEntryNamesSync(filesystem, path) {
     validatePath(path, owner.ledger.limits);
     const root = mem.root;
     if (path === "/") {
-        if (((root.mode >> 6) & 4) !== 4)
+        if (((root.mode >> 6) & 5) !== 5)
             return undefined;
         return root.entries;
     }
@@ -3581,7 +3583,7 @@ export function tryGetMemoryDirectoryEntryNamesSync(filesystem, path) {
     const fastPrefix = cache?.lastFastDirPrefix;
     if (fastDir !== undefined &&
         fastDir.nlink !== 0 &&
-        ((fastDir.mode >> 6) & 4) === 4 &&
+        ((fastDir.mode >> 6) & 5) === 5 &&
         fastPrefix !== undefined &&
         (fastPrefix === path || (fastPrefix.length === path.length + 1 && fastPrefix.charCodeAt(path.length) === 47 && fastPrefix.startsWith(path)))) {
         return fastDir.entries;
@@ -3594,7 +3596,7 @@ export function tryGetMemoryDirectoryEntryNamesSync(filesystem, path) {
         const slash = path.indexOf("/", start);
         if (slash === -1) {
             const next = current.entries.getSubstr(path, start, path.length);
-            if (!next || next.type !== "directory" || ((next.mode >> 6) & 4) !== 4)
+            if (!next || next.type !== "directory" || ((next.mode >> 6) & 5) !== 5)
                 return undefined;
             return next.entries;
         }
@@ -3648,7 +3650,7 @@ export function tryMkdirMemorySync(filesystem, path, recursive, mode, signal, di
             let next = current.entries.get(seg);
             if (!next) {
                 mem.permission(current, 3, "mkdir", path);
-                next = mem.addDirectoryNode(current, seg, validMode, "mkdir", path, fastWriteCachedNow);
+                next = mem.addDirectoryNode(current, seg, validMode, "mkdir", path, Date.now());
             }
             else if (next.type !== "directory") {
                 mem.fail(slash === -1 ? "EEXIST" : "ENOTDIR", "mkdir", path);
@@ -3669,7 +3671,7 @@ export function tryMkdirMemorySync(filesystem, path, recursive, mode, signal, di
     if (location.node)
         mem.fail("EEXIST", "mkdir", path);
     mem.permission(location.parent, 3, "mkdir", path);
-    mem.addDirectoryNode(location.parent, location.name, validMode, "mkdir", path, fastWriteCachedNow);
+    mem.addDirectoryNode(location.parent, location.name, validMode, "mkdir", path, Date.now());
     return true;
 }
 export function tryRmRfMemorySync(filesystem, path, signal) {
@@ -3719,7 +3721,7 @@ export function tryRmRfMemorySync(filesystem, path, signal) {
     sharedFastLocation.name = targetName;
     sharedFastLocation.path = path;
     try {
-        mem.removeLocation(sharedFastLocation, path, "rm", true, fastWriteCachedNow);
+        mem.removeLocation(sharedFastLocation, path, "rm", true, Date.now());
     }
     finally {
         sharedFastLocation.node = undefined;
@@ -3748,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/ledger.js

@@ -84,8 +84,10 @@ export class MemoryAllocation {
             return;
         if (this.references <= 0)
             throw new Error("Memory allocation already released");
-        if (--this.references === 0)
+        if (--this.references === 0) {
+            this.data.fill(0);
             this.ledger.release(this.data.byteLength, 0);
+        }
     }
     isReleased64() {
         return this.references === 0 && this.data.byteLength === 64;

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/object-publication/index.js

@@ -9,7 +9,8 @@ export function withObjectFileDescriptors(filesystem, store, options = {}) {
     const maxStagedPages = options.maxStagedPages ?? Infinity;
     const maxFileBytes = options.maxFileBytes ?? Infinity;
     const maxOpenFiles = options.maxOpenFiles ?? Infinity;
-    if (![chunkBytes, options.maxStagedBytes, options.maxStagedPages, options.maxFileBytes, options.maxOpenFiles].every(value => value === undefined || Number.isSafeInteger(value) && value > 0)
+    if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1
+        || ![maxStagedBytes, maxStagedPages, maxFileBytes, maxOpenFiles].every(value => value === Infinity || Number.isSafeInteger(value) && value > 0)
         || typeof store.acquire !== "function"
         || store.publish !== undefined && typeof store.publish !== "function"
         || store.createStaging !== undefined && typeof store.createStaging !== "function")

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/real/index.js

@@ -608,8 +608,9 @@ export class RealFileSystem {
     }
     async readFile(path, options = {}) {
         return this.operation("readFile", path, options, async () => {
-            const maxBytes = options.maxBytes ?? Number.MAX_SAFE_INTEGER;
-            integer(maxBytes);
+            const maxBytes = options.maxBytes ?? Infinity;
+            if (maxBytes !== Infinity)
+                integer(maxBytes);
             return collectBytes(this.readStream(path, options), { maxBytes, ...options });
         });
     }

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/request-fetch.d.ts

@@ -1,4 +1,15 @@
-import type { RequestOptions } from "node:http";
 import type { RequestScope, WireResponse } from "./request.js";
-import type { S3HttpRequestFactory } from "./types.js";
-export declare function sendRequest(options: RequestOptions, body: Uint8Array, scope: RequestScope, factory?: S3HttpRequestFactory): Promise<WireResponse>;
+export type S3HttpRequestFactory = never;
+interface FetchRequestOptions {
+    readonly protocol?: string | undefined;
+    readonly hostname?: string | undefined;
+    readonly port?: string | number | undefined;
+    readonly path?: string | undefined;
+    readonly method?: string | undefined;
+    readonly headers?: Record<string, string> | undefined;
+    readonly agent?: false;
+    readonly maxHeaderSize?: number;
+    readonly rejectUnauthorized?: true;
+}
+export declare function sendRequest(options: FetchRequestOptions, body: Uint8Array, scope: RequestScope, factory?: S3HttpRequestFactory): Promise<WireResponse>;
+export {};