@poe-platform/safe-fs 0.1.729 → 0.1.731

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

@@ -16,12 +16,15 @@ import { normalizeMemoryFileSystemLimits } from "./limits.js";
 export { defaultMemoryFileSystemLimits } from "./limits.js";
 class MemoryFileNode {
     constructor(mode, ino, now, byteLength, allocation, view) {
+        this.revision = 0;
         this.mode = mode;
         this.ino = ino;
+        this.nlink = 1;
         this.atimeMs = now;
         this.mtimeMs = now;
         this.ctimeMs = now;
         this.birthtimeMs = now;
+        this.references = 0;
         this.byteLength = byteLength;
         this.allocation = allocation;
         this.view = view;
@@ -44,15 +47,250 @@ 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;
+class FastDirectoryEntriesMap {
+    _table = new Int16Array(128).fill(-1);
+    _mask = 127;
+    _keys = new Array(64).fill("");
+    _vals = new Array(64).fill(DUMMY_POOL_FILE_NODE);
+    _next = 0;
+    size = 0;
+    [Symbol.toStringTag] = "Map";
+    _hash(k) {
+        let h = 5381;
+        for (let i = 0; i < k.length; i++) {
+            h = (((h & 0x1fffff) * 33) ^ k.charCodeAt(i)) & 0x3fffffff;
+        }
+        return h & this._mask;
+    }
+    get(k) {
+        if (this.size === 0)
+            return undefined;
+        let slot = this._hash(k);
+        const mask = this._mask;
+        const table = this._table;
+        const keys = this._keys;
+        while (true) {
+            const idx = table[slot];
+            if (idx === -1)
+                return undefined;
+            if (idx >= 0 && keys[idx] === k)
+                return this._vals[idx];
+            slot = (slot + 1) & mask;
+        }
+    }
+    has(k) {
+        return this.get(k) !== undefined;
+    }
+    _rebuild(newCap) {
+        const newTableLen = newCap * 2;
+        const newMask = newTableLen - 1;
+        const newTable = newCap <= 16384 ? new Int16Array(newTableLen).fill(-1) : new Int32Array(newTableLen).fill(-1);
+        const oldKeys = this._keys;
+        const oldVals = this._vals;
+        const oldNext = this._next;
+        const newKeys = newCap === oldKeys.length ? oldKeys : new Array(newCap).fill("");
+        const newVals = newCap === oldVals.length ? oldVals : new Array(newCap).fill(DUMMY_POOL_FILE_NODE);
+        let writeIdx = 0;
+        for (let i = 0; i < oldNext; i++) {
+            const v = oldVals[i];
+            if (v === DUMMY_POOL_FILE_NODE)
+                continue;
+            const k = oldKeys[i];
+            newKeys[writeIdx] = k;
+            newVals[writeIdx] = v;
+            let h = 5381;
+            for (let c = 0; c < k.length; c++) {
+                h = (((h & 0x1fffff) * 33) ^ k.charCodeAt(c)) & 0x3fffffff;
+            }
+            let slot = h & newMask;
+            while (newTable[slot] !== -1) {
+                slot = (slot + 1) & newMask;
+            }
+            newTable[slot] = writeIdx++;
+        }
+        if (newKeys === oldKeys) {
+            for (let i = writeIdx; i < oldNext; i++) {
+                newKeys[i] = "";
+                newVals[i] = DUMMY_POOL_FILE_NODE;
+            }
+        }
+        this._table = newTable;
+        this._mask = newMask;
+        this._keys = newKeys;
+        this._vals = newVals;
+        this._next = writeIdx;
+    }
+    set(k, v) {
+        if (this._next >= this._keys.length) {
+            this._rebuild(this.size * 2 <= this._keys.length ? this._keys.length : this._keys.length * 2);
+        }
+        let slot = this._hash(k);
+        const mask = this._mask;
+        const table = this._table;
+        const keys = this._keys;
+        let firstDeleted = -1;
+        while (true) {
+            const idx = table[slot];
+            if (idx === -1) {
+                const targetSlot = firstDeleted !== -1 ? firstDeleted : slot;
+                const entryIdx = this._next++;
+                table[targetSlot] = entryIdx;
+                keys[entryIdx] = k;
+                this._vals[entryIdx] = v;
+                this.size++;
+                return this;
+            }
+            if (idx === -2) {
+                if (firstDeleted === -1)
+                    firstDeleted = slot;
+            }
+            else if (keys[idx] === k) {
+                this._vals[idx] = v;
+                return this;
+            }
+            slot = (slot + 1) & mask;
+        }
+    }
+    delete(k) {
+        if (this.size === 0)
+            return false;
+        let slot = this._hash(k);
+        const mask = this._mask;
+        const table = this._table;
+        const keys = this._keys;
+        while (true) {
+            const idx = table[slot];
+            if (idx === -1)
+                return false;
+            if (idx >= 0 && keys[idx] === k) {
+                if (this.size === 1) {
+                    this.clear();
+                    return true;
+                }
+                table[slot] = -2;
+                keys[idx] = "";
+                this._vals[idx] = DUMMY_POOL_FILE_NODE;
+                if (idx === this._next - 1)
+                    this._next--;
+                this.size--;
+                return true;
+            }
+            slot = (slot + 1) & mask;
+        }
+    }
+    clear() {
+        if (this._next > 0) {
+            this._table.fill(-1);
+            for (let i = 0; i < this._next; i++) {
+                this._keys[i] = "";
+                this._vals[i] = DUMMY_POOL_FILE_NODE;
+            }
+            this._next = 0;
+            this.size = 0;
+        }
+    }
+    forEach(callbackfn, thisArg) {
+        const next = this._next;
+        const keys = this._keys;
+        const vals = this._vals;
+        for (let i = 0; i < next; i++) {
+            const v = vals[i];
+            if (v !== DUMMY_POOL_FILE_NODE) {
+                if (thisArg !== undefined)
+                    callbackfn.call(thisArg, v, keys[i], this);
+                else
+                    callbackfn(v, keys[i], this);
+            }
+        }
+    }
+    *keys() {
+        for (let i = 0; i < this._next; i++) {
+            if (this._vals[i] !== DUMMY_POOL_FILE_NODE)
+                yield this._keys[i];
+        }
+    }
+    *values() {
+        for (let i = 0; i < this._next; i++) {
+            const v = this._vals[i];
+            if (v !== DUMMY_POOL_FILE_NODE)
+                yield v;
+        }
+    }
+    *entries() {
+        for (let i = 0; i < this._next; i++) {
+            const v = this._vals[i];
+            if (v !== DUMMY_POOL_FILE_NODE)
+                yield [this._keys[i], v];
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+}
+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 sharedFileNodePool = new Array(SHARED_POOL_CAPACITY).fill(DUMMY_POOL_FILE_NODE);
+let sharedFileNodePoolLen = 0;
+const sharedDirectoryNodePool = new Array(SHARED_DIR_POOL_CAPACITY);
+let sharedDirectoryNodePoolLen = 0;
+const sharedRemovedScratch = new Array(SHARED_POOL_CAPACITY).fill(DUMMY_POOL_FILE_NODE);
+let sharedRemovedLen = 0;
+let sharedRemovedKeyChars = 0;
+let sharedRemovedKeyEntries = 0;
+function collectRemovedChild(child, name) {
+    if (sharedRemovedLen < sharedRemovedScratch.length) {
+        sharedRemovedScratch[sharedRemovedLen++] = child;
+    }
+    else {
+        sharedRemovedScratch.push(child);
+        sharedRemovedLen++;
+    }
+    sharedRemovedKeyChars += name.length;
+    sharedRemovedKeyEntries++;
+}
+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);
+        alloc.release();
+        sharedAllocationPool[sharedAllocationPoolLen++] = alloc;
+    }
+    while (sharedFileNodePoolLen < 112) {
+        sharedFileNodePool[sharedFileNodePoolLen++] = new MemoryFileNode(0, 0, fastWriteCachedNow, 0, DUMMY_POOL_ALLOCATION, undefined);
+    }
+    while (sharedDirectoryNodePoolLen < 16) {
+        sharedDirectoryNodePool[sharedDirectoryNodePoolLen++] = new MemoryDirectoryNode(0, 0, fastWriteCachedNow);
+    }
+}
 class MemoryDirectoryNode {
     constructor(mode, ino, now) {
+        this.revision = 0;
         this.mode = mode;
         this.ino = ino;
+        this.nlink = 1;
+        this.references = 0;
         this.atimeMs = now;
         this.mtimeMs = now;
         this.ctimeMs = now;
         this.birthtimeMs = now;
-        this.entries = new Map();
+        this.entries = new FastDirectoryEntriesMap();
+        this.cachedNlink = 2;
+        this.cachedNlinkRev = 0;
     }
 }
 Object.assign(MemoryDirectoryNode.prototype, {
@@ -63,6 +301,8 @@ Object.assign(MemoryDirectoryNode.prototype, {
     cachedNlink: 2,
     cachedNlinkRev: 0,
 });
+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 = [];
@@ -84,6 +324,9 @@ 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();
 const preferredIoBlockSize = 64 * 1024;
 const ext4HtreeEof64 = (1n << 63n) - 1n;
@@ -271,7 +514,7 @@ export class MemoryFileSystem {
             permissions: true,
             timestamps: true,
             atomicRename: true,
-            atomicFileStaging: true, retainedStagingCleanup: true, atomicStagingAncestry: true, atomicFileMutation: true, atomicEntryRemoval: true, atomicEntryRemovalReceipt: true, atomicTreeRemoval: 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,
@@ -289,6 +532,9 @@ export class MemoryFileSystem {
     symlinkCount = 0;
     constructor(options = {}) {
         this.ledger = new MemoryLedger(normalizeMemoryFileSystemLimits(options));
+        if (this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity) {
+            replenishSharedMemoryPools();
+        }
         memoryCaches.set(this.ledger, new MemoryCache());
         this.ledger.reserve(0, 1, "mkdir", "/");
         this.root = this.directory(0o755);
@@ -380,7 +626,7 @@ export class MemoryFileSystem {
             retained.set("/", this.root);
         }
         const capabilities = this.capabilities;
-        const allowed = new Set(["mkdir", "rm", "rmdir", "rename", "symlink", "link", "chmod", "utimes", "writeFile", "appendFile", "writeStream", "writeFileConditional", "removeFileConditional", "prepareDirectory", "createStagedFile", "publishStagedFile", "removeStagedFile"]);
+        const allowed = new Set(["mkdir", "rm", "rmdir", "rename", "symlink", "link", "chmod", "utimes", "writeFile", "appendFile", "writeStream", "writeFileConditional", "removeFileConditional", "removeEntryConditional", "prepareDirectory", "createStagedFile", "publishStagedFile", "removeStagedFile"]);
         const reads = new Set(["access", "capabilitiesFor", "compareEntry", "lstat", "stat", "readFile", "readStream", "readdir", "readlink", "realpath"]);
         const check = (path, followFinal) => {
             if (!roots.some(root => root === "/" || path === root || path.startsWith(`${root}/`)))
@@ -430,6 +676,24 @@ export class MemoryFileSystem {
                                     this.fail("EPERM", "writeStream", path);
                             } };
                     }
+                    if (property === "createStagedFile")
+                        return Reflect.apply(value, target, args).then(staging => {
+                            const writer = staging.writer;
+                            if (!writer)
+                                return staging;
+                            return Object.freeze({ ...staging, writer: Object.freeze({
+                                    write: async (bytes, controls = {}) => {
+                                        controls.signal?.throwIfAborted();
+                                        check(staging.file.path, true);
+                                        await writer.write(bytes, controls);
+                                    },
+                                    finish: async (controls = {}) => {
+                                        controls.signal?.throwIfAborted();
+                                        check(staging.file.path, true);
+                                        return writer.finish(controls);
+                                    },
+                                }) });
+                        });
                     return Reflect.apply(value, target, args);
                 };
             },
@@ -442,11 +706,17 @@ export class MemoryFileSystem {
             atimeMs: now, mtimeMs: now, ctimeMs: now, birthtimeMs: now,
         };
     }
-    directory(mode) {
-        const now = Date.now();
+    directory(mode, now = Date.now()) {
         const fullMode = typeModes.directory | mode;
         const ino = this.nextInode++;
-        const pooled = memoryCaches.get(this.ledger)?.directories.pop();
+        let pooled;
+        if (sharedDirectoryNodePoolLen > 0) {
+            pooled = sharedDirectoryNodePool[--sharedDirectoryNodePoolLen];
+            sharedDirectoryNodePool[sharedDirectoryNodePoolLen] = DUMMY_POOL_DIR_NODE;
+        }
+        else {
+            pooled = memoryCaches.get(this.ledger)?.directories.pop();
+        }
         if (pooled) {
             pooled.mode = fullMode;
             pooled.ino = ino;
@@ -463,13 +733,13 @@ export class MemoryFileSystem {
         }
         return new MemoryDirectoryNode(fullMode, ino, now);
     }
-    addDirectoryNode(parent, name, mode, syscall, path) {
+    addDirectoryNode(parent, name, mode, syscall, path, now = Date.now()) {
         const bytes = name.length * 2;
         this.ledger.reserve(bytes, 2, syscall, path);
         try {
-            const node = this.directory(mode);
+            const node = this.directory(mode, now);
             parent.entries.set(name, node);
-            this.changed(parent);
+            this.changed(parent, now);
             return node;
         }
         catch (error) {
@@ -511,11 +781,21 @@ export class MemoryFileSystem {
             this.totalBytes -= node.byteLength;
             const alloc = node.allocation;
             node.view = undefined;
+            node.allocation = DUMMY_POOL_ALLOCATION;
             alloc.release();
-            if (alloc.isReleased64() && cache.allocations.length < 128) {
-                cache.allocations.push(alloc);
+            if (alloc.isReleased64()) {
+                alloc.detachLedger(DUMMY_POOL_LEDGER);
+                if (this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity && sharedAllocationPoolLen < SHARED_POOL_CAPACITY) {
+                    sharedAllocationPool[sharedAllocationPoolLen++] = alloc;
+                }
+                else if (cache.allocations.length < 128) {
+                    cache.allocations.push(alloc);
+                }
+            }
+            if (sharedFileNodePoolLen < SHARED_POOL_CAPACITY) {
+                sharedFileNodePool[sharedFileNodePoolLen++] = node;
             }
-            if (cache.files.length < 128) {
+            else if (cache.files.length < 128) {
                 cache.files.push(node);
             }
         }
@@ -527,8 +807,13 @@ export class MemoryFileSystem {
                 cache.lastFastDirPrefix = "";
                 cache.lastFastDirNode = undefined;
             }
-            if (node.entries.size === 0 && cache.directories.length < 32) {
-                cache.directories.push(node);
+            if (node.entries.size === 0) {
+                if (sharedDirectoryNodePoolLen < SHARED_DIR_POOL_CAPACITY) {
+                    sharedDirectoryNodePool[sharedDirectoryNodePoolLen++] = node;
+                }
+                else if (cache.directories.length < 32) {
+                    cache.directories.push(node);
+                }
             }
         }
     }
@@ -898,13 +1183,21 @@ export class MemoryFileSystem {
         this.ledger.fileSize(length, syscall, path);
         this.ledger.reserve(length, 0, syscall, path);
         if (length === 0) {
-            return new MemoryAllocation(EMPTY_ALLOC_BYTES, this.ledger);
+            return DUMMY_POOL_ALLOCATION;
         }
-        const allocations = memoryCaches.get(this.ledger).allocations;
-        if (length === 64 && allocations.length > 0) {
-            const pooled = allocations.pop();
-            pooled.reuse();
-            return pooled;
+        if (length === 64) {
+            let pooled;
+            if (this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity && 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;
+            }
         }
         try {
             // A shared slab's backing buffer exceeds the admitted slice capacity.
@@ -1020,7 +1313,14 @@ export class MemoryFileSystem {
                     const now = Date.now();
                     const fileMode = typeModes.file | target.mode;
                     const view = capacity === length ? allocation.data : undefined;
-                    const pooled = memoryCaches.get(this.ledger).files.pop();
+                    let pooled;
+                    if (sharedFileNodePoolLen > 0) {
+                        pooled = sharedFileNodePool[--sharedFileNodePoolLen];
+                        sharedFileNodePool[sharedFileNodePoolLen] = DUMMY_POOL_FILE_NODE;
+                    }
+                    else {
+                        pooled = memoryCaches.get(this.ledger).files.pop();
+                    }
                     if (pooled) {
                         pooled.mode = fileMode;
                         pooled.ino = this.nextInode++;
@@ -1056,11 +1356,14 @@ export class MemoryFileSystem {
         }
     }
     writeAt(node, data, position, syscall, path) {
-        if (data.byteLength === 0) {
-            this.changed(node);
+        this.writeAtRange(node, data, data.byteLength, position, syscall, path, Date.now());
+    }
+    writeAtRange(node, data, dataLen, position, syscall, path, now) {
+        if (dataLen === 0) {
+            this.changed(node, now);
             return;
         }
-        const end = position + data.byteLength;
+        const end = position + dataLen;
         this.ledger.fileSize(end, syscall, path);
         const curLen = node.byteLength;
         const length = Math.max(curLen, end);
@@ -1079,11 +1382,17 @@ export class MemoryFileSystem {
         }
         try {
             const storage = allocation.data;
-            if (allocation !== node.allocation)
-                storage.set(node.view ?? (curLen === node.allocation.data.byteLength ? node.allocation.data : node.allocation.data.subarray(0, curLen)));
+            if (allocation !== node.allocation && curLen > 0) {
+                storage.set(node.allocation.data.subarray(0, curLen));
+            }
             if (position > curLen)
                 storage.fill(0, curLen, position);
-            storage.set(data, position);
+            if (dataLen === data.byteLength) {
+                storage.set(data, position);
+            }
+            else {
+                storage.set(data.subarray(0, dataLen), position);
+            }
         }
         catch (error) {
             if (allocation !== node.allocation)
@@ -1097,7 +1406,7 @@ export class MemoryFileSystem {
             node.byteLength = length;
             node.view = length === allocation.data.byteLength ? allocation.data : undefined;
         }
-        this.changed(node);
+        this.changed(node, now);
     }
     writeMemoryFileFast(path, data, append, mode) {
         const cache = memoryCaches.get(this.ledger);
@@ -1183,7 +1492,7 @@ export class MemoryFileSystem {
             return;
         }
         if (!current) {
-            const capacity = length;
+            const capacity = length > 0 && length < 64 && this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity ? 64 : length;
             const allocation = this.allocate(capacity, syscall, path);
             try {
                 allocation.data.set(data);
@@ -1191,8 +1500,15 @@ export class MemoryFileSystem {
                 try {
                     const now = Date.now();
                     const fileMode = typeModes.file | mode;
-                    const view = allocation.data;
-                    let node = cache.files.pop();
+                    const view = capacity === length ? allocation.data : undefined;
+                    let node;
+                    if (sharedFileNodePoolLen > 0) {
+                        node = sharedFileNodePool[--sharedFileNodePoolLen];
+                        sharedFileNodePool[sharedFileNodePoolLen] = DUMMY_POOL_FILE_NODE;
+                    }
+                    else {
+                        node = cache.files.pop();
+                    }
                     if (node) {
                         node.mode = fileMode;
                         node.ino = this.nextInode++;
@@ -1326,22 +1642,32 @@ export class MemoryFileSystem {
                 return;
             }
             if (!current) {
-                const capacity = length;
+                const capacity = length > 0 && length < 64 && this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity ? 64 : length;
                 const allocation = this.allocate(capacity, syscall, name);
                 try {
                     allocation.data.set(data);
                     this.ledger.reserve(nameBytes, 2, syscall, name);
                     try {
-                        const now = Date.now();
+                        const now = fastWriteCachedNow;
                         const fileMode = typeModes.file | mode;
-                        const view = allocation.data;
-                        let node = cache.files.pop();
+                        const view = capacity === length ? allocation.data : undefined;
+                        let node;
+                        if (sharedFileNodePoolLen > 0) {
+                            node = sharedFileNodePool[--sharedFileNodePoolLen];
+                            sharedFileNodePool[sharedFileNodePoolLen] = DUMMY_POOL_FILE_NODE;
+                        }
+                        else {
+                            node = cache.files.pop();
+                        }
                         if (node) {
                             node.mode = fileMode;
                             node.ino = this.nextInode++;
-                            node.nlink = 1;
-                            node.references = 0;
-                            node.revision = 0;
+                            if (node.nlink !== 1)
+                                node.nlink = 1;
+                            if (node.references !== 0)
+                                node.references = 0;
+                            if (node.revision !== 0)
+                                node.revision = 0;
                             node.atimeMs = now;
                             node.mtimeMs = now;
                             node.ctimeMs = now;
@@ -1517,13 +1843,16 @@ export class MemoryFileSystem {
         location.parent.references++;
         directory.references++;
         file.references++;
-        return Object.freeze({ ...staging, cleanup: this.retainStagingCleanup(staging, location.parent, directory, file, location.name, name) });
+        return Object.freeze({ ...staging, ...this.retainStagingCleanup(staging, location.parent, directory, file, location.name, name) });
     }
     retainStagingCleanup(staging, parent, directory, file, directoryName, fileName) {
         // Clear this state on release, so keeping the closed handle does not keep
         // detached nodes alive outside the Memory ledger.
         let retained = { parent, directory, file };
-        return createStagingCleanup(staging.directory.path, options => {
+        let expected = staging.file.stat;
+        let writing = true;
+        const receipt = () => ({ ...staging, file: { ...staging.file, stat: expected } });
+        const ownedCleanup = createStagingCleanup(staging.directory.path, options => {
             options.signal?.throwIfAborted();
             const state = retained;
             if (state.parent.nlink === 0 || state.parent.entries.get(directoryName) !== state.directory)
@@ -1535,7 +1864,7 @@ export class MemoryFileSystem {
             const child = state.directory.entries.get(fileName);
             if (child && child !== state.file)
                 this.fail("EAGAIN", "removeStagedFile", staging.file.path);
-            this.removeStagingLocations(staging, {
+            this.removeStagingLocations(receipt(), {
                 node: state.directory, parent: state.parent, name: directoryName, path: staging.directory.path,
             }, { node: child, parent: state.directory, name: fileName, path: staging.file.path });
         }, () => {
@@ -1545,6 +1874,43 @@ export class MemoryFileSystem {
             this.releaseReference(state.directory, staging.directory.path);
             this.releaseReference(state.parent, staging.parent.path);
         });
+        const cleanup = Object.freeze({
+            remove: (options) => { writing = false; return ownedCleanup.remove(options); },
+            close: () => { writing = false; return ownedCleanup.close(); },
+        });
+        if (file.type !== "file")
+            return { cleanup };
+        const inspect = (options) => {
+            options.signal?.throwIfAborted();
+            if (!retained || !writing)
+                this.fail("EBADF", "stagedWrite", staging.file.path);
+            const location = this.stagingLocations(receipt());
+            if (location.file.node !== retained.file)
+                this.fail("EAGAIN", "stagedWrite", staging.file.path);
+            this.expectEntry(retained.file, expected, staging.file.path);
+            this.permission(retained.parent, 3, "stagedWrite", staging.parent.path);
+            this.permission(retained.directory, 3, "stagedWrite", staging.directory.path);
+            return retained.file;
+        };
+        return { cleanup, writer: Object.freeze({
+                write: async (bytes, options = {}) => {
+                    const node = inspect(options);
+                    if (!(bytes instanceof Uint8Array))
+                        throw new TypeError("Staged writes require Uint8Array data");
+                    this.writeAt(node, bytes, node.byteLength, "stagedWrite", staging.file.path);
+                    expected = Object.freeze(this.snapshot(node));
+                },
+                finish: async (options = {}) => {
+                    const node = inspect(options);
+                    this.changed(node);
+                    // changed updates modification time; archive creation metadata is final.
+                    node.atimeMs = staging.file.stat.atimeMs;
+                    node.mtimeMs = staging.file.stat.mtimeMs;
+                    writing = false;
+                    expected = Object.freeze(this.snapshot(node));
+                    return expected;
+                },
+            }) };
     }
     async prepareDirectoryAncestry(ancestors, options = {}) {
         const entries = snapshotDirectoryAncestry(ancestors);
@@ -1879,7 +2245,7 @@ export class MemoryFileSystem {
             return Promise.reject(error);
         }
     }
-    removeLocation(location, path, syscall, recursive) {
+    removeLocation(location, path, syscall, recursive, now = Date.now()) {
         const node = location.node;
         if (this.terminalDot(path))
             this.fail("EINVAL", syscall, path);
@@ -1890,39 +2256,42 @@ export class MemoryFileSystem {
             this.fail("EISDIR", syscall, path);
         const cache = memoryCaches.get(this.ledger);
         cache.clearWrites();
-        const removed = cache.removedScratch;
-        removed.length = 0;
-        removed.push(node);
-        let keyChars = 0;
-        let keyEntries = 0;
-        for (let index = 0; index < removed.length; index++) {
-            const entry = removed[index];
-            if (entry.type === "directory" && entry.entries.size > 0) {
-                this.permission(entry, 7, syscall, path);
-                for (const [name, child] of entry.entries) {
-                    removed.push(child);
-                    keyChars += name.length;
-                    keyEntries++;
+        const removed = sharedRemovedScratch;
+        sharedRemovedLen = 1;
+        removed[0] = node;
+        sharedRemovedKeyChars = 0;
+        sharedRemovedKeyEntries = 0;
+        try {
+            for (let index = 0; index < sharedRemovedLen; index++) {
+                const entry = removed[index];
+                if (entry.type === "directory" && entry.entries.size > 0) {
+                    this.permission(entry, 7, syscall, path);
+                    entry.entries.forEach(collectRemovedChild);
                 }
             }
-        }
-        location.parent.entries.delete(location.name);
-        this.ledger.release((location.name.length + keyChars) * 2, 1 + keyEntries);
-        const now = Date.now();
-        for (let i = 0; i < removed.length; i++) {
-            const entry = removed[i];
-            if (entry.type === "directory") {
-                entry.entries.clear();
-            }
-            entry.nlink--;
-            if (entry.nlink !== 0 || entry.references !== 0) {
-                entry.ctimeMs = now;
-                entry.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, entry.revision + 1);
+            location.parent.entries.delete(location.name);
+            this.ledger.release((location.name.length + sharedRemovedKeyChars) * 2, 1 + sharedRemovedKeyEntries);
+            const totalRemoved = sharedRemovedLen;
+            for (let i = 0; i < totalRemoved; i++) {
+                const entry = removed[i];
+                removed[i] = DUMMY_POOL_FILE_NODE;
+                if (entry.type === "directory") {
+                    entry.entries.clear();
+                }
+                entry.nlink--;
+                if (entry.nlink !== 0 || entry.references !== 0) {
+                    entry.ctimeMs = now;
+                    entry.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, entry.revision + 1);
+                }
+                this.releaseNode(entry);
             }
-            this.releaseNode(entry);
         }
-        removed.length = 0;
-        this.changed(location.parent);
+        finally {
+            for (let i = 0; i < sharedRemovedLen; i++)
+                removed[i] = DUMMY_POOL_FILE_NODE;
+            sharedRemovedLen = 0;
+        }
+        this.changed(location.parent, now);
     }
     unlink(path, options = {}) {
         // Do not allow an untyped recursive option to widen final-entry removal.
@@ -2378,24 +2747,46 @@ export class MemoryRedirectHandle {
         this.position = 0;
         this.closed = false;
     }
-    writeSync(chunk, signal) {
+    reset(fs, path, node, append) {
+        this.fs = fs;
+        this.path = path;
+        this.node = node;
+        this.append = append;
+        this.position = 0;
+        this.closed = false;
+    }
+    writeRangeSync(src, len, signal) {
         signal?.throwIfAborted();
         if (this.closed)
             throw new FsError("EBADF", { syscall: "write", path: this.path });
-        if (chunk.byteLength === 0)
+        if (len === 0)
             return;
         const pos = this.append ? this.node.byteLength : this.position;
-        this.fs.writeAt(this.node, chunk, pos, "write", this.path);
+        const now = Date.now === defaultDateNow ? fastWriteCachedNow : Date.now();
+        this.fs.writeAtRange(this.node, src, len, pos, "write", this.path, now);
         if (!this.append)
-            this.position = pos + chunk.byteLength;
+            this.position = pos + len;
+    }
+    writeSync(chunk, signal) {
+        this.writeRangeSync(chunk, chunk.byteLength, signal);
     }
     close() {
         if (this.closed)
             return;
         this.closed = true;
-        this.fs.releaseReference(this.node, this.path);
+        const fs = this.fs;
+        const node = this.node;
+        const path = this.path;
+        this.fs = undefined;
+        this.node = DUMMY_POOL_FILE_NODE;
+        this.path = "";
+        fs.releaseReference(node, path);
+        if (redirectHandlePool.handle === undefined) {
+            redirectHandlePool.handle = this;
+        }
     }
 }
+const redirectHandlePool = { handle: undefined };
 export function tryOpenMemoryRedirectHandleSync(filesystem, path, append, mode, signal) {
     const mem = filesystem;
     const owner = ownedStores.get(mem);
@@ -2405,38 +2796,118 @@ export function tryOpenMemoryRedirectHandleSync(filesystem, path, append, mode,
         activeConditionalMutations.has(mem.identityScope) ||
         !isStockMemoryMethods(mem, openRedirectFastMethodNames, false) ||
         !isCleanAbsolutePath(path) ||
+        path === "/" ||
         path === "/dev" ||
         path.startsWith("/dev/")) {
         return undefined;
     }
     signal?.throwIfAborted();
-    const validMode = mem.mode(mode, 0o666, "open", path);
-    const location = mem.resolve(path, "open", {
-        followFinal: true,
-        allowMissing: true,
-    });
-    let node = location.node;
-    if (node) {
-        if (node.type !== "file")
-            mem.fail("EISDIR", "open", path);
-        mem.permission(node, 2, "open", path);
-    }
-    else {
-        mem.permission(location.parent, 3, "open", path);
+    const validMode = (mode & 0o777) === mode
+        ? mode
+        : mem.mode(mode, 0o666, "open", path);
+    const memInternal = mem;
+    let parent = memInternal.root;
+    let start = 1;
+    let name = "";
+    while (true) {
+        memInternal.permission(parent, 1, "open", path);
+        const slash = path.indexOf("/", start);
+        if (slash === -1) {
+            name = path.slice(start);
+            if (exceedsComponentByteLimit(name))
+                memInternal.fail("ENAMETOOLONG", "open", path);
+            break;
+        }
+        const seg = path.slice(start, slash);
+        if (exceedsComponentByteLimit(seg))
+            memInternal.fail("ENAMETOOLONG", "open", path);
+        const next = parent.entries.get(seg);
+        if (!next)
+            memInternal.fail("ENOENT", "open", path);
+        if (next.type !== "directory")
+            memInternal.fail("ENOTDIR", "open", path);
+        parent = next;
+        start = slash + 1;
     }
-    const ledger = mem.ledger;
-    ledger.reserve(path.length * 2, 1, "open", path);
-    try {
-        node ??= mem.openWrite(path, {}, "open", { location, mode: validMode, append: false });
+    const existing = parent.entries.get(name);
+    const ledger = memInternal.ledger;
+    let node;
+    if (existing !== undefined) {
+        if (existing.type !== "file")
+            memInternal.fail("EISDIR", "open", path);
+        memInternal.permission(existing, 2, "open", path);
+        ledger.reserve(path.length * 2, 1, "open", path);
+        node = existing;
         if (!append) {
-            mem.resizeNode(node, 0, "open", path);
+            try {
+                memInternal.resizeNode(node, 0, "open", path);
+            }
+            catch (error) {
+                ledger.release(path.length * 2, 1);
+                throw error;
+            }
+        }
+        node.references++;
+    }
+    else {
+        memInternal.permission(parent, 3, "open", path);
+        const refBytes = path.length * 2;
+        const nameBytes = name.length * 2;
+        ledger.reserve(refBytes, 1, "open", path);
+        try {
+            ledger.fileSize(0, "open", path);
+            ledger.reserve(nameBytes, 2, "open", path);
+        }
+        catch (error) {
+            ledger.release(refBytes, 1);
+            throw error;
+        }
+        const cache = memoryCaches.get(ledger);
+        cache.clearWrites();
+        const now = Date.now === defaultDateNow ? ((++fastWriteNowTick & 63) === 0 ? (fastWriteCachedNow = Date.now()) : fastWriteCachedNow) : Date.now();
+        const fileMode = typeModes.file | validMode;
+        let newNode;
+        if (sharedFileNodePoolLen > 0) {
+            newNode = sharedFileNodePool[--sharedFileNodePoolLen];
+            sharedFileNodePool[sharedFileNodePoolLen] = DUMMY_POOL_FILE_NODE;
+        }
+        else {
+            newNode = cache.files.pop();
+        }
+        if (newNode) {
+            newNode.mode = fileMode;
+            newNode.ino = memInternal.nextInode++;
+            newNode.nlink = 1;
+            newNode.references = 1;
+            newNode.revision = 0;
+            newNode.atimeMs = now;
+            newNode.mtimeMs = now;
+            newNode.ctimeMs = now;
+            newNode.birthtimeMs = now;
+            newNode.byteLength = 0;
+            newNode.view = EMPTY_ALLOC_BYTES;
+            newNode.allocation = DUMMY_POOL_ALLOCATION;
+        }
+        else {
+            newNode = new MemoryFileNode(fileMode, memInternal.nextInode++, now, 0, DUMMY_POOL_ALLOCATION, EMPTY_ALLOC_BYTES);
+            newNode.references = 1;
+        }
+        const prevNlink = parent.cachedNlinkRev === parent.revision ? parent.cachedNlink : (parent.entries.size === 0 ? 2 : undefined);
+        parent.entries.set(name, newNode);
+        parent.revision = parent.revision < 1073741823 ? (parent.revision + 1) | 0 : Math.min(Number.MAX_SAFE_INTEGER + 1, parent.revision + 1);
+        parent.mtimeMs = parent.ctimeMs = now;
+        if (prevNlink !== undefined) {
+            parent.cachedNlink = prevNlink;
+            parent.cachedNlinkRev = parent.revision;
         }
+        node = newNode;
     }
-    catch (error) {
-        ledger.release(path.length * 2, 1);
-        throw error;
+    const handle = redirectHandlePool.handle;
+    if (handle !== undefined) {
+        redirectHandlePool.handle = undefined;
+        handle.reset(mem, path, node, append);
+        return handle;
     }
-    node.references++;
     return new MemoryRedirectHandle(mem, path, node, append);
 }
 export function utf8ByteLength(value) {
@@ -2574,7 +3045,8 @@ export function tryReadMemoryFileViewSync(filesystem, path, maxBytes, signal) {
 }
 export function tryGetMemoryDirectoryEntryNamesSync(filesystem, path) {
     const mem = filesystem;
-    if (!ownedStores.has(mem) || mem.symlinkCount !== 0 || !isStockMemoryMethods(mem, readFileFastMethodNames, false))
+    const owner = ownedStores.get(mem);
+    if (!owner || mem.symlinkCount !== 0 || !isStockMemoryMethods(mem, readFileFastMethodNames, false))
         return undefined;
     const root = mem.root;
     if (path === "/") {
@@ -2584,6 +3056,16 @@ export function tryGetMemoryDirectoryEntryNamesSync(filesystem, path) {
     }
     if (!isCleanAbsolutePath(path) || path === "/dev" || path.startsWith("/dev/"))
         return undefined;
+    const cache = memoryCaches.get(owner.ledger);
+    const fastDir = cache?.lastFastDirNode;
+    const fastPrefix = cache?.lastFastDirPrefix;
+    if (fastDir !== undefined &&
+        fastDir.nlink !== 0 &&
+        ((fastDir.mode >> 6) & 4) === 4 &&
+        fastPrefix !== undefined &&
+        (fastPrefix === path || (fastPrefix.length === path.length + 1 && fastPrefix.charCodeAt(path.length) === 47 && fastPrefix.startsWith(path)))) {
+        return fastDir.entries;
+    }
     let current = root;
     let start = 1;
     while (true) {
@@ -2634,16 +3116,34 @@ export function tryMkdirMemorySync(filesystem, path, recursive, mode, signal) {
     signal?.throwIfAborted();
     const validMode = mem.mode(mode, 0o777, "mkdir", path);
     if (recursive) {
-        const node = mem.resolve(path, "mkdir", { createDirectories: validMode }).node;
-        if (node.type !== "directory")
-            mem.fail("EEXIST", "mkdir", path);
+        let current = owner.root;
+        let start = 1;
+        while (true) {
+            mem.permission(current, 1, "mkdir", path);
+            const slash = path.indexOf("/", start);
+            const seg = slash === -1 ? path.slice(start) : path.slice(start, slash);
+            if (exceedsComponentByteLimit(seg))
+                mem.fail("ENAMETOOLONG", "mkdir", path);
+            let next = current.entries.get(seg);
+            if (!next) {
+                mem.permission(current, 3, "mkdir", path);
+                next = mem.addDirectoryNode(current, seg, validMode, "mkdir", path, fastWriteCachedNow);
+            }
+            else if (next.type !== "directory") {
+                mem.fail(slash === -1 ? "EEXIST" : "ENOTDIR", "mkdir", path);
+            }
+            if (slash === -1)
+                break;
+            current = next;
+            start = slash + 1;
+        }
         return true;
     }
-    const location = mem.resolve(path, "mkdir", { allowMissing: true, followFinal: false });
+    const location = mem.resolve(path, "mkdir", sharedAllowMissingNoFollowOptions);
     if (location.node)
         mem.fail("EEXIST", "mkdir", path);
     mem.permission(location.parent, 3, "mkdir", path);
-    mem.addDirectoryNode(location.parent, location.name, validMode, "mkdir", path);
+    mem.addDirectoryNode(location.parent, location.name, validMode, "mkdir", path, fastWriteCachedNow);
     return true;
 }
 export function tryRmRfMemorySync(filesystem, path, signal) {
@@ -2660,16 +3160,46 @@ export function tryRmRfMemorySync(filesystem, path, signal) {
         return false;
     }
     signal?.throwIfAborted();
-    let location;
+    let current = owner.root;
+    let start = 1;
+    let targetNode;
+    let targetName = "";
+    while (true) {
+        mem.permission(current, 1, "rm", path);
+        const slash = path.indexOf("/", start);
+        if (slash === -1) {
+            targetName = path.slice(start);
+            if (exceedsComponentByteLimit(targetName))
+                mem.fail("ENAMETOOLONG", "rm", path);
+            targetNode = current.entries.get(targetName);
+            if (!targetNode)
+                return true;
+            break;
+        }
+        const seg = path.slice(start, slash);
+        if (exceedsComponentByteLimit(seg))
+            mem.fail("ENAMETOOLONG", "rm", path);
+        const next = current.entries.get(seg);
+        if (!next)
+            return true;
+        if (next.type !== "directory")
+            mem.fail("ENOTDIR", "rm", path);
+        current = next;
+        start = slash + 1;
+    }
+    sharedFastLocation.node = targetNode;
+    sharedFastLocation.parent = current;
+    sharedFastLocation.name = targetName;
+    sharedFastLocation.path = path;
     try {
-        location = mem.resolve(path, "rm", noFollowResolveOptions);
+        mem.removeLocation(sharedFastLocation, path, "rm", true, fastWriteCachedNow);
     }
-    catch (error) {
-        if (error instanceof FsError && error.code === "ENOENT")
-            return true;
-        throw error;
+    finally {
+        sharedFastLocation.node = undefined;
+        sharedFastLocation.parent = DUMMY_POOL_DIR_NODE;
+        sharedFastLocation.name = "";
+        sharedFastLocation.path = "";
     }
-    mem.removeLocation(location, path, "rm", true);
     return true;
 }
 export function tryWriteMemoryFileInDirSync(filesystem, dirPrefix, name, data, append, mode, signal) {