@poe-platform/safe-fs 0.1.731 → 0.1.732

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

@@ -15,7 +15,7 @@ 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;
@@ -28,6 +28,7 @@ class MemoryFileNode {
         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));
@@ -42,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;
@@ -54,6 +56,9 @@ DUMMY_POOL_FILE_NODE.atimeMs = DUMMY_POOL_FILE_NODE.mtimeMs = DUMMY_POOL_FILE_NO
 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;
@@ -85,6 +90,72 @@ class FastDirectoryEntriesMap {
             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;
     }
@@ -128,6 +199,15 @@ class FastDirectoryEntriesMap {
         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);
         }
@@ -238,6 +318,11 @@ 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);
@@ -273,6 +358,18 @@ function replenishSharedMemoryPools() {
     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 (sharedMediumAllocationPoolLen < 4) {
+        DUMMY_POOL_LEDGER.reserve(16384, 0, "init", "/");
+        const alloc = new MemoryAllocation(new Uint8Array(16384), DUMMY_POOL_LEDGER);
+        alloc.release();
+        sharedMediumAllocationPool[sharedMediumAllocationPoolLen++] = alloc;
+    }
     while (sharedDirectoryNodePoolLen < 16) {
         sharedDirectoryNodePool[sharedDirectoryNodePoolLen++] = new MemoryDirectoryNode(0, 0, fastWriteCachedNow);
     }
@@ -309,10 +406,10 @@ class MemoryCache {
     directories = [];
     removedScratch = [];
     lastFastDirPrefix = "";
-    lastFastDirNode;
+    lastFastDirNode = undefined;
     lastFastFilePath = "";
     lastFastFileName = "";
-    lastFastFileNode;
+    lastFastFileNode = undefined;
     clearWrites() {
         this.lastFastDirPrefix = "";
         this.lastFastDirNode = undefined;
@@ -527,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");
@@ -781,17 +885,24 @@ 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 && sharedAllocationPoolLen < SHARED_POOL_CAPACITY) {
+                if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedAllocationPoolLen < SHARED_POOL_CAPACITY) {
                     sharedAllocationPool[sharedAllocationPoolLen++] = alloc;
                 }
                 else if (cache.allocations.length < 128) {
                     cache.allocations.push(alloc);
                 }
             }
+            else if (alloc.isReleased65536()) {
+                alloc.detachLedger(DUMMY_POOL_LEDGER);
+                if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedLargeAllocationPoolLen < SHARED_LARGE_POOL_CAPACITY) {
+                    sharedLargeAllocationPool[sharedLargeAllocationPoolLen++] = alloc;
+                }
+            }
             if (sharedFileNodePoolLen < SHARED_POOL_CAPACITY) {
                 sharedFileNodePool[sharedFileNodePoolLen++] = node;
             }
@@ -829,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);
@@ -861,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;
     }
@@ -870,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))
@@ -888,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);
@@ -898,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);
@@ -922,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);
@@ -1043,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;
@@ -1185,9 +1323,25 @@ export class MemoryFileSystem {
         if (length === 0) {
             return DUMMY_POOL_ALLOCATION;
         }
+        if (length === 16384) {
+            if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedMediumAllocationPoolLen > 0) {
+                const pooled = sharedMediumAllocationPool[--sharedMediumAllocationPoolLen];
+                sharedMediumAllocationPool[sharedMediumAllocationPoolLen] = DUMMY_POOL_ALLOCATION;
+                pooled.reuse(this.ledger);
+                return pooled;
+            }
+        }
+        if (length === 65536) {
+            if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedLargeAllocationPoolLen > 0) {
+                const pooled = sharedLargeAllocationPool[--sharedLargeAllocationPoolLen];
+                sharedLargeAllocationPool[sharedLargeAllocationPoolLen] = DUMMY_POOL_ALLOCATION;
+                pooled.reuse(this.ledger);
+                return pooled;
+            }
+        }
         if (length === 64) {
             let pooled;
-            if (this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity && sharedAllocationPoolLen > 0) {
+            if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && sharedAllocationPoolLen > 0) {
                 pooled = sharedAllocationPool[--sharedAllocationPoolLen];
                 sharedAllocationPool[sharedAllocationPoolLen] = DUMMY_POOL_ALLOCATION;
             }
@@ -1202,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;
@@ -1334,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) {
@@ -1371,27 +1526,37 @@ 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 && curLen > 0) {
-                storage.set(node.allocation.data.subarray(0, curLen));
+                storage.set((node.view ?? node.allocation.data).subarray(0, curLen));
             }
             if (position > curLen)
                 storage.fill(0, curLen, position);
             if (dataLen === data.byteLength) {
                 storage.set(data, position);
             }
+            else if (typeof data.copy === "function") {
+                data.copy(storage, position, 0, dataLen);
+            }
             else {
-                storage.set(data.subarray(0, dataLen), position);
+                for (let i = 0; i < dataLen; i++)
+                    storage[position + i] = data[i];
             }
         }
         catch (error) {
@@ -1457,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);
@@ -1469,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);
@@ -1492,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);
@@ -1522,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);
@@ -1562,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 &&
@@ -1598,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);
@@ -1619,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);
@@ -1642,15 +1933,17 @@ 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 = fastWriteCachedNow;
                         const fileMode = typeModes.file | mode;
-                        const view = capacity === length ? allocation.data : undefined;
+                        const view = zeroCopyConst ? data : (capacity === length ? allocation.data : undefined);
                         let node;
                         if (sharedFileNodePoolLen > 0) {
                             node = sharedFileNodePool[--sharedFileNodePoolLen];
@@ -1675,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);
@@ -1690,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;
                     }
@@ -2169,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();
@@ -2767,6 +3104,32 @@ export class MemoryRedirectHandle {
         if (!this.append)
             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);
     }
@@ -2780,20 +3143,30 @@ export class MemoryRedirectHandle {
         this.fs = undefined;
         this.node = DUMMY_POOL_FILE_NODE;
         this.path = "";
-        fs.releaseReference(node, 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 === "/" ||
@@ -2813,12 +3186,14 @@ export function tryOpenMemoryRedirectHandleSync(filesystem, path, append, mode,
         memInternal.permission(parent, 1, "open", path);
         const slash = path.indexOf("/", start);
         if (slash === -1) {
-            name = path.slice(start);
+            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 = path.slice(start, slash);
+        const seg = slicePathSegment(path, start, slash);
         if (exceedsComponentByteLimit(seg))
             memInternal.fail("ENAMETOOLONG", "open", path);
         const next = parent.entries.get(seg);
@@ -2829,7 +3204,7 @@ export function tryOpenMemoryRedirectHandleSync(filesystem, path, append, mode,
         parent = next;
         start = slash + 1;
     }
-    const existing = parent.entries.get(name);
+    const existing = parent.entries.getForWrite(name);
     const ledger = memInternal.ledger;
     let node;
     if (existing !== undefined) {
@@ -2853,16 +3228,21 @@ export function tryOpenMemoryRedirectHandleSync(filesystem, path, append, mode,
         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);
+        if (ledger.hasInfiniteRetained && ledger.hasInfiniteFileBytes) {
+            ledger.reserve(refBytes + nameBytes, 3, "open", path);
         }
-        catch (error) {
-            ledger.release(refBytes, 1);
-            throw error;
+        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 = memoryCaches.get(ledger);
+        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;
@@ -2877,9 +3257,11 @@ export function tryOpenMemoryRedirectHandleSync(filesystem, path, append, mode,
         if (newNode) {
             newNode.mode = fileMode;
             newNode.ino = memInternal.nextInode++;
-            newNode.nlink = 1;
+            if (newNode.nlink !== 1)
+                newNode.nlink = 1;
             newNode.references = 1;
-            newNode.revision = 0;
+            if (newNode.revision !== 0)
+                newNode.revision = 0;
             newNode.atimeMs = now;
             newNode.mtimeMs = now;
             newNode.ctimeMs = now;
@@ -2893,7 +3275,20 @@ export function tryOpenMemoryRedirectHandleSync(filesystem, path, append, mode,
             newNode.references = 1;
         }
         const prevNlink = parent.cachedNlinkRev === parent.revision ? parent.cachedNlink : (parent.entries.size === 0 ? 2 : undefined);
-        parent.entries.set(name, newNode);
+        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) {
@@ -2973,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);
@@ -2990,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)
@@ -3004,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");
@@ -3016,32 +3421,119 @@ 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;
@@ -3073,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;
@@ -3101,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 ||
@@ -3121,7 +3613,7 @@ export function tryMkdirMemorySync(filesystem, path, recursive, mode, signal) {
         while (true) {
             mem.permission(current, 1, "mkdir", path);
             const slash = path.indexOf("/", start);
-            const seg = slash === -1 ? path.slice(start) : path.slice(start, slash);
+            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);
@@ -3132,8 +3624,13 @@ export function tryMkdirMemorySync(filesystem, path, recursive, mode, signal) {
             else if (next.type !== "directory") {
                 mem.fail(slash === -1 ? "EEXIST" : "ENOTDIR", "mkdir", path);
             }
-            if (slash === -1)
+            if (slash === -1) {
+                if (dirPrefixHint !== undefined) {
+                    mem._cache.lastFastDirPrefix = dirPrefixHint;
+                    mem._cache.lastFastDirNode = next;
+                }
                 break;
+            }
             current = next;
             start = slash + 1;
         }
@@ -3168,7 +3665,7 @@ export function tryRmRfMemorySync(filesystem, path, signal) {
         mem.permission(current, 1, "rm", path);
         const slash = path.indexOf("/", start);
         if (slash === -1) {
-            targetName = path.slice(start);
+            targetName = slicePathSegment(path, start, path.length);
             if (exceedsComponentByteLimit(targetName))
                 mem.fail("ENAMETOOLONG", "rm", path);
             targetNode = current.entries.get(targetName);
@@ -3176,7 +3673,7 @@ export function tryRmRfMemorySync(filesystem, path, signal) {
                 return true;
             break;
         }
-        const seg = path.slice(start, slash);
+        const seg = slicePathSegment(path, start, slash);
         if (exceedsComponentByteLimit(seg))
             mem.fail("ENAMETOOLONG", "rm", path);
         const next = current.entries.get(seg);