@poe-platform/safe-fs 0.1.730 → 0.1.732

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

@@ -15,16 +15,20 @@ import { MemoryAllocation, MemoryLedger } from "./ledger.js";
 import { normalizeMemoryFileSystemLimits } from "./limits.js";
 export { defaultMemoryFileSystemLimits } from "./limits.js";
 class MemoryFileNode {
-    constructor(mode, ino, now, byteLength, allocation, view) {
+    constructor(mode, ino, now, byteLength, allocation, view, sourceRef) {
+        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;
+        this.sourceRef = sourceRef;
     }
     get data() {
         return this.view ??= (this.byteLength === this.allocation.data.byteLength ? this.allocation.data : this.allocation.data.subarray(0, this.byteLength));
@@ -39,6 +43,7 @@ Object.assign(MemoryFileNode.prototype, {
     revision: 0,
     nlink: 1,
     references: 0,
+    sourceRef: undefined,
 });
 const EMPTY_ALLOC_BYTES = new Uint8Array(0);
 const SMALL_ALLOC_SLAB_SIZE = 8192;
@@ -46,19 +51,299 @@ 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 sharedAllocationPool = [];
-const sharedFileNodePool = [];
-const sharedDirectoryNodePool = [];
-const sharedRemovedScratch = [];
+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 lastFastMapMiss = {
+    map: undefined, key: "", slot: -1,
+};
+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;
+        }
+    }
+    getForWrite(k) {
+        return this.getForWriteWithHash(k, this._hash(k));
+    }
+    getForWriteWithHash(k, h) {
+        let slot = h & this._mask;
+        if (this.size === 0) {
+            lastFastMapMiss.map = this;
+            lastFastMapMiss.key = k;
+            lastFastMapMiss.slot = slot;
+            return undefined;
+        }
+        const mask = this._mask;
+        const table = this._table;
+        const keys = this._keys;
+        let firstDeleted = -1;
+        while (true) {
+            const idx = table[slot];
+            if (idx === -1) {
+                lastFastMapMiss.map = this;
+                lastFastMapMiss.key = k;
+                lastFastMapMiss.slot = firstDeleted !== -1 ? firstDeleted : slot;
+                return undefined;
+            }
+            if (idx === -2) {
+                if (firstDeleted === -1)
+                    firstDeleted = slot;
+            }
+            else if (keys[idx] === k) {
+                return this._vals[idx];
+            }
+            slot = (slot + 1) & mask;
+        }
+    }
+    getSubstr(s, start, end) {
+        if (this.size === 0)
+            return undefined;
+        const len = end - start;
+        let h = 5381;
+        for (let i = start; i < end; i++) {
+            h = (((h & 0x1fffff) * 33) ^ s.charCodeAt(i)) & 0x3fffffff;
+        }
+        let slot = h & this._mask;
+        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) {
+                const k = keys[idx];
+                if (k.length === len) {
+                    let match = true;
+                    for (let i = 0; i < len; i++) {
+                        if (k.charCodeAt(i) !== s.charCodeAt(start + i)) {
+                            match = false;
+                            break;
+                        }
+                    }
+                    if (match)
+                        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 === lastFastMapMiss.map && k === lastFastMapMiss.key && this._next < this._keys.length) {
+            const entryIdx = this._next++;
+            this._table[lastFastMapMiss.slot] = entryIdx;
+            this._keys[entryIdx] = k;
+            this._vals[entryIdx] = v;
+            this.size++;
+            lastFastMapMiss.map = undefined;
+            return this;
+        }
+        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 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);
+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) {
-    sharedRemovedScratch.push(child);
+    if (sharedRemovedLen < sharedRemovedScratch.length) {
+        sharedRemovedScratch[sharedRemovedLen++] = child;
+    }
+    else {
+        sharedRemovedScratch.push(child);
+        sharedRemovedLen++;
+    }
     sharedRemovedKeyChars += name.length;
     sharedRemovedKeyEntries++;
 }
 function replenishSharedMemoryPools() {
-    while (sharedAllocationPool.length < 112) {
+    while (sharedAllocationPoolLen < 112) {
         if (smallAllocOffset + 64 > SMALL_ALLOC_SLAB_SIZE) {
             smallAllocSlab = new Uint8Array(SMALL_ALLOC_SLAB_SIZE);
             smallAllocOffset = 0;
@@ -68,24 +353,41 @@ function replenishSharedMemoryPools() {
         DUMMY_POOL_LEDGER.reserve(64, 0, "init", "/");
         const alloc = new MemoryAllocation(slice, DUMMY_POOL_LEDGER);
         alloc.release();
-        sharedAllocationPool.push(alloc);
+        sharedAllocationPool[sharedAllocationPoolLen++] = alloc;
+    }
+    while (sharedFileNodePoolLen < 112) {
+        sharedFileNodePool[sharedFileNodePoolLen++] = new MemoryFileNode(0, 0, fastWriteCachedNow, 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 (sharedFileNodePool.length < 112) {
-        sharedFileNodePool.push(new MemoryFileNode(0, 0, 0, 0, DUMMY_POOL_ALLOCATION, undefined));
+    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 (sharedDirectoryNodePool.length < 16) {
-        sharedDirectoryNodePool.push(new MemoryDirectoryNode(0, 0, 0));
+    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, {
@@ -96,16 +398,18 @@ 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 = [];
     directories = [];
     removedScratch = [];
     lastFastDirPrefix = "";
-    lastFastDirNode;
+    lastFastDirNode = undefined;
     lastFastFilePath = "";
     lastFastFileName = "";
-    lastFastFileNode;
+    lastFastFileNode = undefined;
     clearWrites() {
         this.lastFastDirPrefix = "";
         this.lastFastDirNode = undefined;
@@ -117,6 +421,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;
@@ -317,24 +624,31 @@ export class MemoryFileSystem {
     identityScope = Symbol();
     nextInode = 1;
     ledger;
+    _cache;
+    mutationTick = 0;
+    _owner;
     root;
     totalBytes = 0;
     symlinkCount = 0;
     constructor(options = {}) {
         this.ledger = new MemoryLedger(normalizeMemoryFileSystemLimits(options));
-        if (this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity) {
+        if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes) {
             replenishSharedMemoryPools();
         }
-        memoryCaches.set(this.ledger, new MemoryCache());
+        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;
-        ownedStores.set(this, {
+        const owner = {
             root,
             ledger: this.ledger,
             capabilities: this.capabilities,
             intact: () => this.root === root,
-        });
+        };
+        this._owner = owner;
+        ownedStores.set(this, owner);
         registerMemoryAtomicView(this, {
             stat: (path) => {
                 this.validatePath(path, "overlayAtomicView");
@@ -496,11 +810,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 = sharedDirectoryNodePool.pop() ?? 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;
@@ -517,13 +837,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) {
@@ -565,19 +885,26 @@ export class MemoryFileSystem {
             this.totalBytes -= node.byteLength;
             const alloc = node.allocation;
             node.view = undefined;
+            node.sourceRef = undefined;
             node.allocation = DUMMY_POOL_ALLOCATION;
             alloc.release();
             if (alloc.isReleased64()) {
                 alloc.detachLedger(DUMMY_POOL_LEDGER);
-                if (this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity && sharedAllocationPool.length < 128) {
-                    sharedAllocationPool.push(alloc);
+                if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedAllocationPoolLen < SHARED_POOL_CAPACITY) {
+                    sharedAllocationPool[sharedAllocationPoolLen++] = alloc;
                 }
                 else if (cache.allocations.length < 128) {
                     cache.allocations.push(alloc);
                 }
             }
-            if (sharedFileNodePool.length < 128) {
-                sharedFileNodePool.push(node);
+            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;
             }
             else if (cache.files.length < 128) {
                 cache.files.push(node);
@@ -592,8 +919,8 @@ export class MemoryFileSystem {
                 cache.lastFastDirNode = undefined;
             }
             if (node.entries.size === 0) {
-                if (sharedDirectoryNodePool.length < 32) {
-                    sharedDirectoryNodePool.push(node);
+                if (sharedDirectoryNodePoolLen < SHARED_DIR_POOL_CAPACITY) {
+                    sharedDirectoryNodePool[sharedDirectoryNodePoolLen++] = node;
                 }
                 else if (cache.directories.length < 32) {
                     cache.directories.push(node);
@@ -613,6 +940,18 @@ 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);
@@ -645,6 +984,7 @@ export class MemoryFileSystem {
             this.fail("EINVAL", syscall, path);
     }
     changed(node, now = Date.now()) {
+        this.mutationTick = (this.mutationTick + 1) | 0;
         node.revision = node.revision < 1073741823 ? (node.revision + 1) | 0 : Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
         node.mtimeMs = node.ctimeMs = now;
     }
@@ -654,7 +994,7 @@ export class MemoryFileSystem {
             const fastDir = cache.lastFastDirNode;
             const fastPrefix = cache.lastFastDirPrefix;
             if (fastDir !== undefined && fastDir.nlink !== 0 && fastPrefix.length > 0 && path.startsWith(fastPrefix)) {
-                const name = path.slice(fastPrefix.length);
+                const name = fastPrefix.length === 1 ? (path === _lastFileSlice1Path ? _lastFileSlice1Name : (_lastFileSlice1Path = path, _lastFileSlice1Name = path.slice(1))) : path.slice(fastPrefix.length);
                 if (name.length > 0 && !name.includes("/")) {
                     this.permission(fastDir, 1, syscall, path);
                     if (exceedsComponentByteLimit(name))
@@ -672,9 +1012,9 @@ export class MemoryFileSystem {
                 const slash = path.indexOf("/", start);
                 if (slash === -1) {
                     cache.clearWrites();
-                    cache.lastFastDirPrefix = path.slice(0, start);
+                    cache.lastFastDirPrefix = start === 1 ? "/" : path.slice(0, start);
                     cache.lastFastDirNode = current;
-                    const name = path.slice(start);
+                    const name = start === 1 ? (path === _lastFileSlice1Path ? _lastFileSlice1Name : (_lastFileSlice1Path = path, _lastFileSlice1Name = path.slice(1))) : path.slice(start);
                     if (exceedsComponentByteLimit(name))
                         this.fail("ENAMETOOLONG", syscall, path);
                     const node = current.entries.get(name);
@@ -682,7 +1022,7 @@ export class MemoryFileSystem {
                         this.fail("ENOENT", syscall, path);
                     return node;
                 }
-                const name = path.slice(start, slash);
+                const name = slicePathSegment(path, start, slash);
                 if (exceedsComponentByteLimit(name))
                     this.fail("ENAMETOOLONG", syscall, path);
                 const next = current.entries.get(name);
@@ -706,7 +1046,7 @@ export class MemoryFileSystem {
                 this.permission(current, 1, syscall, path);
                 const slash = path.indexOf("/", start);
                 if (slash === -1) {
-                    const name = path.slice(start);
+                    const name = slicePathSegment(path, start, path.length);
                     if (exceedsComponentByteLimit(name))
                         this.fail("ENAMETOOLONG", syscall, path);
                     let node = current.entries.get(name);
@@ -827,6 +1167,20 @@ export class MemoryFileSystem {
         };
     }
     file(path, syscall) {
+        if (this.symlinkCount === 0 && path.charCodeAt(0) === 47 && path.length > 1 && path.indexOf("/", 1) === -1 && !path.includes("\0")) {
+            const name = path === _lastFileSlice1Path ? _lastFileSlice1Name : (_lastFileSlice1Path = path, _lastFileSlice1Name = path.slice(1));
+            if (name !== "." && name !== "..") {
+                this.permission(this.root, 1, syscall, path);
+                if (exceedsComponentByteLimit(name))
+                    this.fail("ENAMETOOLONG", syscall, path);
+                const node = this.root.entries.get(name);
+                if (!node)
+                    this.fail("ENOENT", syscall, path);
+                if (node.type !== "file")
+                    this.fail("EISDIR", syscall, path);
+                return node;
+            }
+        }
         const cache = memoryCaches.get(this.ledger);
         if (this.symlinkCount === 0 && isCleanAbsolutePath(path)) {
             const fastDir = cache.lastFastDirNode;
@@ -967,12 +1321,33 @@ 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;
+        }
+        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) {
-            const pooled = (this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity
-                ? sharedAllocationPool.pop()
-                : undefined) ?? memoryCaches.get(this.ledger).allocations.pop();
+            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;
@@ -981,7 +1356,7 @@ 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.limits.maxFileBytes === Infinity) {
+            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;
@@ -1092,7 +1467,14 @@ export class MemoryFileSystem {
                     const now = Date.now();
                     const fileMode = typeModes.file | target.mode;
                     const view = capacity === length ? allocation.data : undefined;
-                    const pooled = sharedFileNodePool.pop() ?? 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++;
@@ -1106,9 +1488,10 @@ export class MemoryFileSystem {
                         pooled.byteLength = length;
                         pooled.view = view;
                         pooled.allocation = allocation;
+                        pooled.sourceRef = data;
                         return pooled;
                     }
-                    return new MemoryFileNode(fileMode, this.nextInode++, now, length, allocation, view);
+                    return new MemoryFileNode(fileMode, this.nextInode++, now, length, allocation, view, data);
                 }, syscall, path);
             }
             catch (error) {
@@ -1128,11 +1511,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);
@@ -1140,22 +1526,38 @@ export class MemoryFileSystem {
         let allocation = node.allocation;
         if (length > allocation.data.byteLength) {
             this.ledger.check(length, 0, syscall, path);
-            const baseCap = curLen === 0 && length >= 8192 && length <= 16384 &&
-                this.ledger.limits.maxFileBytes >= 65536 &&
-                this.ledger.availableBytes >= 65536 &&
-                (this.ledger.limits.maxBytes === undefined || this.ledger.limits.maxBytes - this.totalBytes >= 65536)
-                ? 65536
-                : Math.max(length, curLen * 2, 64);
-            const capacity = Math.min(baseCap, this.ledger.limits.maxFileBytes, this.ledger.availableBytes);
+            let capacity;
+            if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && this.ledger.limits.maxBytes === undefined) {
+                capacity = curLen === 0 && length >= 8192 && length <= 65536 ? (length <= 16384 ? 16384 : 65536) : Math.max(length, curLen * 2, 64);
+            }
+            else {
+                const baseCap = curLen === 0 && length >= 8192 && length <= 65536 &&
+                    this.ledger.limits.maxFileBytes >= 65536 &&
+                    this.ledger.availableBytes >= 65536 &&
+                    (this.ledger.limits.maxBytes === undefined || this.ledger.limits.maxBytes - this.totalBytes >= 65536)
+                    ? 65536
+                    : Math.max(length, curLen * 2, 64);
+                capacity = Math.min(baseCap, this.ledger.limits.maxFileBytes, this.ledger.availableBytes);
+            }
             allocation = this.allocate(capacity, syscall, path);
         }
         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.view ?? 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 if (typeof data.copy === "function") {
+                data.copy(storage, position, 0, dataLen);
+            }
+            else {
+                for (let i = 0; i < dataLen; i++)
+                    storage[position + i] = data[i];
+            }
         }
         catch (error) {
             if (allocation !== node.allocation)
@@ -1169,7 +1571,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);
@@ -1220,7 +1622,7 @@ export class MemoryFileSystem {
                     }
                     break;
                 }
-                const seg = path.slice(start, slash);
+                const seg = slicePathSegment(path, start, slash);
                 if (exceedsComponentByteLimit(seg))
                     this.fail("ENAMETOOLONG", syscall, path);
                 const next = parent.entries.get(seg);
@@ -1232,7 +1634,7 @@ export class MemoryFileSystem {
                 start = slash + 1;
             }
         }
-        const existing = parent.entries.get(name);
+        const existing = parent.entries.getForWrite ? parent.entries.getForWrite(name) : parent.entries.get(name);
         if (existing) {
             if (existing.type !== "file")
                 this.fail("EISDIR", syscall, path);
@@ -1255,7 +1657,7 @@ export class MemoryFileSystem {
             return;
         }
         if (!current) {
-            const capacity = length > 0 && length < 64 && this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity ? 64 : length;
+            const capacity = length > 0 && length < 64 && this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes ? 64 : length;
             const allocation = this.allocate(capacity, syscall, path);
             try {
                 allocation.data.set(data);
@@ -1264,7 +1666,14 @@ export class MemoryFileSystem {
                     const now = Date.now();
                     const fileMode = typeModes.file | mode;
                     const view = capacity === length ? allocation.data : undefined;
-                    let node = sharedFileNodePool.pop() ?? cache.files.pop();
+                    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++;
@@ -1278,9 +1687,10 @@ export class MemoryFileSystem {
                         node.byteLength = length;
                         node.view = view;
                         node.allocation = allocation;
+                        node.sourceRef = data;
                     }
                     else {
-                        node = new MemoryFileNode(fileMode, this.nextInode++, now, length, allocation, view);
+                        node = new MemoryFileNode(fileMode, this.nextInode++, now, length, allocation, view, data);
                     }
                     const prevNlink = parent.cachedNlinkRev === parent.revision ? parent.cachedNlink : (parent.entries.size === 0 ? 2 : undefined);
                     parent.entries.set(name, node);
@@ -1318,8 +1728,133 @@ export class MemoryFileSystem {
             throw error;
         }
     }
-    writeMemoryFileInDirFast(dirPrefix, name, data, append, mode) {
-        const cache = memoryCaches.get(this.ledger);
+    writeMemoryFilesInDirBatchFast(firstFileName, dirPrefix, fileNames, nameHashes, payloads, totalNameBytes, payloadBytesSum, mode) {
+        const batchCount = fileNames.length;
+        const cache = this._cache;
+        if (batchCount > 0 &&
+            dirPrefix === cache.lastFastDirPrefix &&
+            cache.lastFastDirNode !== undefined &&
+            cache.lastFastDirNode.nlink !== 0 &&
+            (cache.lastFastDirNode.mode & 0o300) === 0o300 &&
+            this.ledger.hasInfiniteRetained &&
+            this.ledger.hasInfiniteFileBytes &&
+            this.ledger.limits.maxBytes === undefined &&
+            sharedFileNodePoolLen >= batchCount) {
+            const parent = cache.lastFastDirNode;
+            const entries = parent.entries;
+            if (entries.size === 1 &&
+                entries._next === 1 &&
+                entries._keys[0] === firstFileName &&
+                1 + batchCount <= entries._keys.length) {
+                this.ledger.reserve(totalNameBytes, 2 * batchCount, "writeFile", fileNames[batchCount - 1]);
+                this.totalBytes += payloadBytesSum;
+                const now = fastWriteCachedNow;
+                const fileMode = typeModes.file | mode;
+                let ino = this.nextInode;
+                this.nextInode = ino + batchCount;
+                let nextIdx = 1;
+                entries._next = 1 + batchCount;
+                entries.size = 1 + batchCount;
+                const table = entries._table;
+                const mask = table.length - 1;
+                const keys = entries._keys;
+                const vals = entries._vals;
+                for (let k = 0; k < batchCount; k++) {
+                    const name = fileNames[k];
+                    const data = payloads[k];
+                    const node = sharedFileNodePool[--sharedFileNodePoolLen];
+                    sharedFileNodePool[sharedFileNodePoolLen] = DUMMY_POOL_FILE_NODE;
+                    node.mode = fileMode;
+                    node.ino = ino++;
+                    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;
+                    node.birthtimeMs = now;
+                    node.byteLength = data.byteLength;
+                    node.view = data;
+                    node.allocation = DUMMY_POOL_ALLOCATION;
+                    node.sourceRef = data;
+                    const entryIdx = nextIdx++;
+                    keys[entryIdx] = name;
+                    vals[entryIdx] = node;
+                    let slot = nameHashes[k] & mask;
+                    while (table[slot] !== -1)
+                        slot = (slot + 1) & mask;
+                    table[slot] = entryIdx;
+                }
+                this.mutationTick = (this.mutationTick + 1) | 0;
+                parent.revision = parent.revision < 1073741000 ? (parent.revision + batchCount) | 0 : Math.min(Number.MAX_SAFE_INTEGER + 1, parent.revision + batchCount);
+                parent.mtimeMs = parent.ctimeMs = now;
+                cache.lastFastFilePath = "";
+                cache.lastFastFileName = fileNames[batchCount - 1];
+                cache.lastFastFileNode = vals[nextIdx - 1];
+                return;
+            }
+        }
+        for (let k = 0; k < batchCount; k++) {
+            this.writeMemoryFileInDirFast(dirPrefix, fileNames[k], payloads[k], false, mode, nameHashes[k]);
+        }
+    }
+    writeMemoryFileInDirFast(dirPrefix, name, data, append, mode, nameHash) {
+        const cache = this._cache;
+        if (!append &&
+            dirPrefix === cache.lastFastDirPrefix &&
+            cache.lastFastDirNode !== undefined &&
+            cache.lastFastDirNode.nlink !== 0 &&
+            (cache.lastFastDirNode.mode & 0o300) === 0o300 &&
+            name.length <= 85 &&
+            this.ledger.hasInfiniteRetained &&
+            this.ledger.hasInfiniteFileBytes &&
+            this.ledger.limits.maxBytes === undefined &&
+            sharedFileNodePoolLen > 0) {
+            const parent = cache.lastFastDirNode;
+            const entries = parent.entries;
+            const existing = nameHash !== undefined ? entries.getForWriteWithHash(name, nameHash) : entries.getForWrite(name);
+            if (existing === undefined && entries._next < entries._keys.length) {
+                const now = fastWriteCachedNow;
+                const length = data.byteLength;
+                const node = sharedFileNodePool[--sharedFileNodePoolLen];
+                sharedFileNodePool[sharedFileNodePoolLen] = DUMMY_POOL_FILE_NODE;
+                node.mode = typeModes.file | mode;
+                node.ino = this.nextInode++;
+                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;
+                node.birthtimeMs = now;
+                node.byteLength = length;
+                node.view = data;
+                node.allocation = DUMMY_POOL_ALLOCATION;
+                node.sourceRef = data;
+                const entryIdx = entries._next++;
+                entries._table[lastFastMapMiss.slot] = entryIdx;
+                entries._keys[entryIdx] = name;
+                entries._vals[entryIdx] = node;
+                entries.size++;
+                lastFastMapMiss.map = undefined;
+                lastFastMapMiss.key = "";
+                this.ledger.reserve(name.length * 2, 2, "writeFile", name);
+                this.totalBytes += length;
+                this.mutationTick = (this.mutationTick + 1) | 0;
+                parent.revision = parent.revision < 1073741823 ? (parent.revision + 1) | 0 : Math.min(Number.MAX_SAFE_INTEGER + 1, parent.revision + 1);
+                parent.mtimeMs = parent.ctimeMs = now;
+                cache.lastFastFilePath = "";
+                cache.lastFastFileName = name;
+                cache.lastFastFileNode = node;
+                return;
+            }
+        }
         const syscall = append ? "appendFile" : "writeFile";
         try {
             if (append &&
@@ -1354,7 +1889,7 @@ export class MemoryFileSystem {
                 while (start < dirPrefix.length) {
                     this.permission(parent, 1, syscall, name);
                     const slash = dirPrefix.indexOf("/", start);
-                    const seg = slash === -1 ? dirPrefix.slice(start) : dirPrefix.slice(start, slash);
+                    const seg = slash === -1 ? slicePathSegment(dirPrefix, start, dirPrefix.length) : slicePathSegment(dirPrefix, start, slash);
                     if (exceedsComponentByteLimit(seg))
                         this.fail("ENAMETOOLONG", syscall, name);
                     const next = parent.entries.get(seg);
@@ -1375,7 +1910,7 @@ export class MemoryFileSystem {
                     cache.lastFastDirNode = parent;
                 }
             }
-            const existing = parent.entries.get(name);
+            const existing = parent.entries.getForWrite ? parent.entries.getForWrite(name) : parent.entries.get(name);
             if (existing) {
                 if (existing.type !== "file")
                     this.fail("EISDIR", syscall, name);
@@ -1398,22 +1933,34 @@ export class MemoryFileSystem {
                 return;
             }
             if (!current) {
-                const capacity = length > 0 && length < 64 && this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity ? 64 : length;
-                const allocation = this.allocate(capacity, syscall, name);
+                const zeroCopyConst = this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && this.ledger.limits.maxBytes === undefined;
+                const capacity = zeroCopyConst ? 0 : (length > 0 && length < 64 && this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes ? 64 : length);
+                const allocation = zeroCopyConst ? DUMMY_POOL_ALLOCATION : this.allocate(capacity, syscall, name);
                 try {
-                    allocation.data.set(data);
+                    if (!zeroCopyConst)
+                        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 = capacity === length ? allocation.data : undefined;
-                        let node = sharedFileNodePool.pop() ?? cache.files.pop();
+                        const view = zeroCopyConst ? data : (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;
@@ -1421,9 +1968,10 @@ export class MemoryFileSystem {
                             node.byteLength = length;
                             node.view = view;
                             node.allocation = allocation;
+                            node.sourceRef = data;
                         }
                         else {
-                            node = new MemoryFileNode(fileMode, this.nextInode++, now, length, allocation, view);
+                            node = new MemoryFileNode(fileMode, this.nextInode++, now, length, allocation, view, data);
                         }
                         const prevNlink = parent.cachedNlinkRev === parent.revision ? parent.cachedNlink : (parent.entries.size === 0 ? 2 : undefined);
                         parent.entries.set(name, node);
@@ -1436,8 +1984,12 @@ export class MemoryFileSystem {
                         cache.lastFastFilePath = "";
                         cache.lastFastFileName = name;
                         cache.lastFastFileNode = node;
+                        lastFastMapMiss.map = undefined;
+                        lastFastMapMiss.key = "";
                     }
                     catch (error) {
+                        lastFastMapMiss.map = undefined;
+                        lastFastMapMiss.key = "";
                         this.ledger.release(nameBytes, 2);
                         throw error;
                     }
@@ -1915,6 +2467,45 @@ export class MemoryFileSystem {
         }
         return result.sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
     }
+    tryMkdirFastSync(path, recursive, mode) {
+        try {
+            this.validatePath(path, "mkdir");
+            const resolvedMode = this.mode(mode, 0o777, "mkdir", path);
+            if (recursive) {
+                const node = this.resolve(path, "mkdir", { createDirectories: resolvedMode }).node;
+                return node.type === "directory";
+            }
+            const location = this.resolve(path.replace(/\/+$/, "") || "/", "mkdir", { allowMissing: true, followFinal: false });
+            if (location.node)
+                return false;
+            this.permission(location.parent, 3, "mkdir", path);
+            this.addNode(location.parent, location.name, () => this.directory(resolvedMode), "mkdir", path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    tryRmFastSync(path, recursive, force) {
+        if (activeConditionalMutations.has(this.identityScope))
+            return false;
+        try {
+            let location;
+            try {
+                location = this.entry(path, "rm", false);
+            }
+            catch (error) {
+                if (force && error instanceof FsError && error.code === "ENOENT")
+                    return true;
+                return false;
+            }
+            this.removeLocation(location, path, "rm", recursive);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     mkdir(path, options = {}) {
         try {
             options.signal?.throwIfAborted();
@@ -1991,7 +2582,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);
@@ -2003,12 +2594,12 @@ export class MemoryFileSystem {
         const cache = memoryCaches.get(this.ledger);
         cache.clearWrites();
         const removed = sharedRemovedScratch;
-        removed.length = 0;
-        removed.push(node);
+        sharedRemovedLen = 1;
+        removed[0] = node;
         sharedRemovedKeyChars = 0;
         sharedRemovedKeyEntries = 0;
         try {
-            for (let index = 0; index < removed.length; index++) {
+            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);
@@ -2017,9 +2608,10 @@ export class MemoryFileSystem {
             }
             location.parent.entries.delete(location.name);
             this.ledger.release((location.name.length + sharedRemovedKeyChars) * 2, 1 + sharedRemovedKeyEntries);
-            const now = Date.now();
-            for (let i = 0; i < removed.length; i++) {
+            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();
                 }
@@ -2032,9 +2624,11 @@ export class MemoryFileSystem {
             }
         }
         finally {
-            removed.length = 0;
+            for (let i = 0; i < sharedRemovedLen; i++)
+                removed[i] = DUMMY_POOL_FILE_NODE;
+            sharedRemovedLen = 0;
         }
-        this.changed(location.parent);
+        this.changed(location.parent, now);
     }
     unlink(path, options = {}) {
         // Do not allow an untyped recursive option to widen final-entry removal.
@@ -2490,65 +3084,225 @@ 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;
+    }
+    writeImmutableSync(immutableData, signal) {
+        signal?.throwIfAborted();
+        if (this.closed)
+            throw new FsError("EBADF", { syscall: "write", path: this.path });
+        const len = immutableData.byteLength;
+        if (len === 0)
+            return;
+        const mem = this.fs;
+        if (!this.append &&
+            this.position === 0 &&
+            this.node.byteLength === 0 &&
+            this.node.allocation === DUMMY_POOL_ALLOCATION &&
+            mem.ledger.hasInfiniteRetained &&
+            mem.ledger.hasInfiniteFileBytes &&
+            mem.ledger.limits.maxBytes === undefined) {
+            const now = Date.now === defaultDateNow ? fastWriteCachedNow : Date.now();
+            this.node.byteLength = len;
+            this.node.view = immutableData;
+            this.node.sourceRef = immutableData;
+            this.position = len;
+            mem.totalBytes += len;
+            mem.changed(this.node, now);
+            return;
+        }
+        this.writeRangeSync(immutableData, len, signal);
+    }
+    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 = "";
+        if (node.nlink > 0 && node.references === 1) {
+            node.references = 0;
+            fs.ledger.release(path.length * 2, 1);
+        }
+        else {
+            fs.releaseReference(node, path);
+        }
+        if (redirectHandlePool.handle === undefined) {
+            redirectHandlePool.handle = this;
+        }
     }
 }
+const redirectHandlePool = { handle: undefined };
+let _lastRedirectSlice1Path = "";
+let _lastRedirectSlice1Name = "";
+let _lastFileSlice1Path = "";
+let _lastFileSlice1Name = "";
 export function tryOpenMemoryRedirectHandleSync(filesystem, path, append, mode, signal) {
     const mem = filesystem;
-    const owner = ownedStores.get(mem);
+    const owner = mem._owner ?? ownedStores.get(mem);
     if (!owner ||
         mem.symlinkCount !== 0 ||
         mem.capabilities !== owner.capabilities ||
-        activeConditionalMutations.has(mem.identityScope) ||
+        (activeConditionalMutations.size > 0 && 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 = start === 1
+                ? (path === _lastRedirectSlice1Path ? _lastRedirectSlice1Name : (_lastRedirectSlice1Path = path, _lastRedirectSlice1Name = path.slice(1)))
+                : path.slice(start);
+            if (exceedsComponentByteLimit(name))
+                memInternal.fail("ENAMETOOLONG", "open", path);
+            break;
+        }
+        const seg = slicePathSegment(path, 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.getForWrite(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;
+        if (ledger.hasInfiniteRetained && ledger.hasInfiniteFileBytes) {
+            ledger.reserve(refBytes + nameBytes, 3, "open", path);
+        }
+        else {
+            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 = mem._cache;
+        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++;
+            if (newNode.nlink !== 1)
+                newNode.nlink = 1;
+            newNode.references = 1;
+            if (newNode.revision !== 0)
+                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);
+        const entries = parent.entries;
+        if (lastFastMapMiss.map === entries && lastFastMapMiss.key === name && entries._next < entries._keys.length) {
+            const entryIdx = entries._next++;
+            entries._table[lastFastMapMiss.slot] = entryIdx;
+            entries._keys[entryIdx] = name;
+            entries._vals[entryIdx] = newNode;
+            entries.size++;
+            lastFastMapMiss.map = undefined;
+            lastFastMapMiss.key = "";
         }
+        else {
+            entries.set(name, newNode);
+        }
+        mem.mutationTick = (mem.mutationTick + 1) | 0;
+        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) {
@@ -2614,14 +3368,14 @@ export function tryResolveMemoryDevicePath(filesystem, path, resizeCreate) {
             return undefined;
         const slash = path.indexOf("/", start);
         if (slash === -1) {
-            const name = path.slice(start);
+            const name = slicePathSegment(path, start, path.length);
             if (exceedsComponentByteLimit(name))
                 return undefined;
             if (resizeCreate === false && !current.entries.has(name))
                 return undefined;
             return path;
         }
-        const name = path.slice(start, slash);
+        const name = slicePathSegment(path, start, slash);
         if (exceedsComponentByteLimit(name))
             return undefined;
         const next = current.entries.get(name);
@@ -2631,7 +3385,7 @@ export function tryResolveMemoryDevicePath(filesystem, path, resizeCreate) {
             let remStart = slash + 1;
             while (true) {
                 const nextSlash = path.indexOf("/", remStart);
-                const seg = nextSlash === -1 ? path.slice(remStart) : path.slice(remStart, nextSlash);
+                const seg = nextSlash === -1 ? slicePathSegment(path, remStart, path.length) : slicePathSegment(path, remStart, nextSlash);
                 if (exceedsComponentByteLimit(seg))
                     return undefined;
                 if (nextSlash === -1)
@@ -2645,9 +3399,19 @@ export function tryResolveMemoryDevicePath(filesystem, path, resizeCreate) {
         start = slash + 1;
     }
 }
+const cachedMethodValuesMap = new WeakMap();
+function getExpectedMethodValues(names) {
+    let vals = cachedMethodValuesMap.get(names);
+    if (!vals) {
+        vals = names.map(name => memoryImplementation[name]?.value);
+        cachedMethodValuesMap.set(names, vals);
+    }
+    return vals;
+}
+const hasOwn = Object.prototype.hasOwnProperty;
 function isStockMemoryMethods(mem, names, checkRootAccessor = true) {
-    const owner = ownedStores.get(mem);
-    if (!owner || Object.getPrototypeOf(mem) !== MemoryFileSystem.prototype)
+    const owner = mem?._owner ?? ownedStores.get(mem);
+    if (!owner || Object.getPrototypeOf(mem) !== MemoryFileSystem.prototype || ownedStores.get(mem) !== owner)
         return false;
     if (checkRootAccessor) {
         const rootDesc = Object.getOwnPropertyDescriptor(mem, "root");
@@ -2657,36 +3421,124 @@ function isStockMemoryMethods(mem, names, checkRootAccessor = true) {
     else if (mem.root !== owner.root) {
         return false;
     }
+    const vals = getExpectedMethodValues(names);
+    const proto = MemoryFileSystem.prototype;
     for (let i = 0; i < names.length; i++) {
         const name = names[i];
-        if (Object.prototype.hasOwnProperty.call(mem, name)) {
+        const expected = vals[i];
+        if (hasOwn.call(mem, name)) {
             const descriptor = Object.getOwnPropertyDescriptor(mem, name);
-            if (!descriptor || !("value" in descriptor) || descriptor.value !== memoryImplementation[name]?.value)
+            if (!descriptor || !("value" in descriptor) || descriptor.value !== expected)
                 return false;
         }
-        else if (MemoryFileSystem.prototype[name] !== memoryImplementation[name]?.value) {
+        else if (proto[name] !== expected) {
             return false;
         }
     }
     return true;
 }
-export function tryReadMemoryFileViewSync(filesystem, path, maxBytes, signal) {
+let lastReadViewData;
+let lastReadViewSourceRef;
+export function getLastReadMemoryFileSourceRef(view) {
+    const ref = view === lastReadViewData ? lastReadViewSourceRef : undefined;
+    lastReadViewData = undefined;
+    lastReadViewSourceRef = undefined;
+    return ref;
+}
+export function tryReadMemoryFileViewSync(filesystem, path, maxBytes, signal, captureSourceRef = false) {
     const mem = filesystem;
-    if (!ownedStores.has(mem) || !isStockMemoryMethods(mem, readFileFastMethodNames, false))
+    if (mem._owner === undefined || !isStockMemoryMethods(mem, readFileFastMethodNames, false))
         return undefined;
     signal?.throwIfAborted();
     if (maxBytes !== undefined)
         mem.integer(maxBytes, "readFile", path);
     const node = mem.file(path, "readFile");
     mem.permission(node, 4, "readFile", path);
-    if (maxBytes !== undefined && node.data.byteLength > maxBytes)
+    const data = node.data;
+    if (maxBytes !== undefined && data.byteLength > maxBytes)
         mem.fail("EFBIG", "readFile", path);
-    node.atimeMs = Date.now();
-    return node.data;
+    if (Date.now !== defaultDateNow)
+        node.atimeMs = Date.now();
+    else if ((++fastWriteNowTick & 63) === 0)
+        node.atimeMs = fastWriteCachedNow = Date.now();
+    if (captureSourceRef && node.revision === 0) {
+        lastReadViewData = data;
+        lastReadViewSourceRef = node.sourceRef;
+    }
+    return data;
+}
+let segCache0 = "";
+let segCache1 = "";
+let segCache2 = "";
+let segCache3 = "";
+let segCacheCursor = 0;
+function slicePathSegment(path, start, end) {
+    const len = end - start;
+    if (len <= 0)
+        return "";
+    if (len === 1)
+        return String.fromCharCode(path.charCodeAt(start));
+    if (len <= 16) {
+        const c0 = path.charCodeAt(start);
+        if (segCache0.length === len && segCache0.charCodeAt(0) === c0) {
+            let ok = true;
+            for (let i = 1; i < len; i++)
+                if (path.charCodeAt(start + i) !== segCache0.charCodeAt(i)) {
+                    ok = false;
+                    break;
+                }
+            if (ok)
+                return segCache0;
+        }
+        if (segCache1.length === len && segCache1.charCodeAt(0) === c0) {
+            let ok = true;
+            for (let i = 1; i < len; i++)
+                if (path.charCodeAt(start + i) !== segCache1.charCodeAt(i)) {
+                    ok = false;
+                    break;
+                }
+            if (ok)
+                return segCache1;
+        }
+        if (segCache2.length === len && segCache2.charCodeAt(0) === c0) {
+            let ok = true;
+            for (let i = 1; i < len; i++)
+                if (path.charCodeAt(start + i) !== segCache2.charCodeAt(i)) {
+                    ok = false;
+                    break;
+                }
+            if (ok)
+                return segCache2;
+        }
+        if (segCache3.length === len && segCache3.charCodeAt(0) === c0) {
+            let ok = true;
+            for (let i = 1; i < len; i++)
+                if (path.charCodeAt(start + i) !== segCache3.charCodeAt(i)) {
+                    ok = false;
+                    break;
+                }
+            if (ok)
+                return segCache3;
+        }
+        const sliced = path.slice(start, end);
+        const slot = segCacheCursor;
+        segCacheCursor = (slot + 1) & 3;
+        if (slot === 0)
+            segCache0 = sliced;
+        else if (slot === 1)
+            segCache1 = sliced;
+        else if (slot === 2)
+            segCache2 = sliced;
+        else
+            segCache3 = sliced;
+        return sliced;
+    }
+    return path.slice(start, end);
 }
 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 === "/") {
@@ -2696,6 +3548,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) {
@@ -2703,12 +3565,12 @@ export function tryGetMemoryDirectoryEntryNamesSync(filesystem, path) {
             return undefined;
         const slash = path.indexOf("/", start);
         if (slash === -1) {
-            const next = current.entries.get(path.slice(start));
+            const next = current.entries.getSubstr(path, start, path.length);
             if (!next || next.type !== "directory" || ((next.mode >> 6) & 4) !== 4)
                 return undefined;
             return next.entries;
         }
-        const next = current.entries.get(path.slice(start, slash));
+        const next = current.entries.getSubstr(path, start, slash);
         if (!next || next.type !== "directory")
             return undefined;
         current = next;
@@ -2731,7 +3593,7 @@ export function tryWriteMemoryFileSync(filesystem, path, data, append, mode, sig
     mem.writeMemoryFileFast(path, data, append, mode);
     return true;
 }
-export function tryMkdirMemorySync(filesystem, path, recursive, mode, signal) {
+export function tryMkdirMemorySync(filesystem, path, recursive, mode, signal, dirPrefixHint) {
     const mem = filesystem;
     const owner = ownedStores.get(mem);
     if (!owner ||
@@ -2746,16 +3608,39 @@ 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 ? slicePathSegment(path, start, path.length) : slicePathSegment(path, 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) {
+                if (dirPrefixHint !== undefined) {
+                    mem._cache.lastFastDirPrefix = dirPrefixHint;
+                    mem._cache.lastFastDirNode = next;
+                }
+                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) {
@@ -2772,16 +3657,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 = slicePathSegment(path, start, path.length);
+            if (exceedsComponentByteLimit(targetName))
+                mem.fail("ENAMETOOLONG", "rm", path);
+            targetNode = current.entries.get(targetName);
+            if (!targetNode)
+                return true;
+            break;
+        }
+        const seg = slicePathSegment(path, 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) {