@poe-platform/safe-fs 0.1.730 → 0.1.731

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

@@ -69,6 +69,7 @@ export declare class MemoryFileSystem implements FileSystem {
     private openWrite;
     private writeData;
     private writeAt;
+    private writeAtRange;
     writeMemoryFileFast(path: string, data: Uint8Array, append: boolean, mode: number): void;
     writeMemoryFileInDirFast(dirPrefix: string, name: string, data: Uint8Array, append: boolean, mode: number): void;
     readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
@@ -118,13 +119,15 @@ export declare class MemoryFileSystem implements FileSystem {
 }
 export declare function createMemoryFileSystem(options?: MemoryFileSystemOptions | Readonly<Record<string, unknown>>): MemoryFileSystem;
 export declare class MemoryRedirectHandle {
-    readonly fs: MemoryFileSystem;
-    readonly path: string;
-    readonly node: FileNode;
-    readonly append: boolean;
+    fs: MemoryFileSystem;
+    path: string;
+    node: FileNode;
+    append: boolean;
     position: number;
     closed: boolean;
     constructor(fs: MemoryFileSystem, path: string, node: FileNode, append: boolean);
+    reset(fs: MemoryFileSystem, path: string, node: FileNode, append: boolean): void;
+    writeRangeSync(src: Uint8Array, len: number, signal?: AbortSignal): void;
     writeSync(chunk: Uint8Array, signal?: AbortSignal): void;
     close(): void;
 }

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

@@ -16,12 +16,15 @@ import { normalizeMemoryFileSystemLimits } from "./limits.js";
 export { defaultMemoryFileSystemLimits } from "./limits.js";
 class MemoryFileNode {
     constructor(mode, ino, now, byteLength, allocation, view) {
+        this.revision = 0;
         this.mode = mode;
         this.ino = ino;
+        this.nlink = 1;
         this.atimeMs = now;
         this.mtimeMs = now;
         this.ctimeMs = now;
         this.birthtimeMs = now;
+        this.references = 0;
         this.byteLength = byteLength;
         this.allocation = allocation;
         this.view = view;
@@ -46,19 +49,216 @@ 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;
+class FastDirectoryEntriesMap {
+    _table = new Int16Array(128).fill(-1);
+    _mask = 127;
+    _keys = new Array(64).fill("");
+    _vals = new Array(64).fill(DUMMY_POOL_FILE_NODE);
+    _next = 0;
+    size = 0;
+    [Symbol.toStringTag] = "Map";
+    _hash(k) {
+        let h = 5381;
+        for (let i = 0; i < k.length; i++) {
+            h = (((h & 0x1fffff) * 33) ^ k.charCodeAt(i)) & 0x3fffffff;
+        }
+        return h & this._mask;
+    }
+    get(k) {
+        if (this.size === 0)
+            return undefined;
+        let slot = this._hash(k);
+        const mask = this._mask;
+        const table = this._table;
+        const keys = this._keys;
+        while (true) {
+            const idx = table[slot];
+            if (idx === -1)
+                return undefined;
+            if (idx >= 0 && keys[idx] === k)
+                return this._vals[idx];
+            slot = (slot + 1) & mask;
+        }
+    }
+    has(k) {
+        return this.get(k) !== undefined;
+    }
+    _rebuild(newCap) {
+        const newTableLen = newCap * 2;
+        const newMask = newTableLen - 1;
+        const newTable = newCap <= 16384 ? new Int16Array(newTableLen).fill(-1) : new Int32Array(newTableLen).fill(-1);
+        const oldKeys = this._keys;
+        const oldVals = this._vals;
+        const oldNext = this._next;
+        const newKeys = newCap === oldKeys.length ? oldKeys : new Array(newCap).fill("");
+        const newVals = newCap === oldVals.length ? oldVals : new Array(newCap).fill(DUMMY_POOL_FILE_NODE);
+        let writeIdx = 0;
+        for (let i = 0; i < oldNext; i++) {
+            const v = oldVals[i];
+            if (v === DUMMY_POOL_FILE_NODE)
+                continue;
+            const k = oldKeys[i];
+            newKeys[writeIdx] = k;
+            newVals[writeIdx] = v;
+            let h = 5381;
+            for (let c = 0; c < k.length; c++) {
+                h = (((h & 0x1fffff) * 33) ^ k.charCodeAt(c)) & 0x3fffffff;
+            }
+            let slot = h & newMask;
+            while (newTable[slot] !== -1) {
+                slot = (slot + 1) & newMask;
+            }
+            newTable[slot] = writeIdx++;
+        }
+        if (newKeys === oldKeys) {
+            for (let i = writeIdx; i < oldNext; i++) {
+                newKeys[i] = "";
+                newVals[i] = DUMMY_POOL_FILE_NODE;
+            }
+        }
+        this._table = newTable;
+        this._mask = newMask;
+        this._keys = newKeys;
+        this._vals = newVals;
+        this._next = writeIdx;
+    }
+    set(k, v) {
+        if (this._next >= this._keys.length) {
+            this._rebuild(this.size * 2 <= this._keys.length ? this._keys.length : this._keys.length * 2);
+        }
+        let slot = this._hash(k);
+        const mask = this._mask;
+        const table = this._table;
+        const keys = this._keys;
+        let firstDeleted = -1;
+        while (true) {
+            const idx = table[slot];
+            if (idx === -1) {
+                const targetSlot = firstDeleted !== -1 ? firstDeleted : slot;
+                const entryIdx = this._next++;
+                table[targetSlot] = entryIdx;
+                keys[entryIdx] = k;
+                this._vals[entryIdx] = v;
+                this.size++;
+                return this;
+            }
+            if (idx === -2) {
+                if (firstDeleted === -1)
+                    firstDeleted = slot;
+            }
+            else if (keys[idx] === k) {
+                this._vals[idx] = v;
+                return this;
+            }
+            slot = (slot + 1) & mask;
+        }
+    }
+    delete(k) {
+        if (this.size === 0)
+            return false;
+        let slot = this._hash(k);
+        const mask = this._mask;
+        const table = this._table;
+        const keys = this._keys;
+        while (true) {
+            const idx = table[slot];
+            if (idx === -1)
+                return false;
+            if (idx >= 0 && keys[idx] === k) {
+                if (this.size === 1) {
+                    this.clear();
+                    return true;
+                }
+                table[slot] = -2;
+                keys[idx] = "";
+                this._vals[idx] = DUMMY_POOL_FILE_NODE;
+                if (idx === this._next - 1)
+                    this._next--;
+                this.size--;
+                return true;
+            }
+            slot = (slot + 1) & mask;
+        }
+    }
+    clear() {
+        if (this._next > 0) {
+            this._table.fill(-1);
+            for (let i = 0; i < this._next; i++) {
+                this._keys[i] = "";
+                this._vals[i] = DUMMY_POOL_FILE_NODE;
+            }
+            this._next = 0;
+            this.size = 0;
+        }
+    }
+    forEach(callbackfn, thisArg) {
+        const next = this._next;
+        const keys = this._keys;
+        const vals = this._vals;
+        for (let i = 0; i < next; i++) {
+            const v = vals[i];
+            if (v !== DUMMY_POOL_FILE_NODE) {
+                if (thisArg !== undefined)
+                    callbackfn.call(thisArg, v, keys[i], this);
+                else
+                    callbackfn(v, keys[i], this);
+            }
+        }
+    }
+    *keys() {
+        for (let i = 0; i < this._next; i++) {
+            if (this._vals[i] !== DUMMY_POOL_FILE_NODE)
+                yield this._keys[i];
+        }
+    }
+    *values() {
+        for (let i = 0; i < this._next; i++) {
+            const v = this._vals[i];
+            if (v !== DUMMY_POOL_FILE_NODE)
+                yield v;
+        }
+    }
+    *entries() {
+        for (let i = 0; i < this._next; i++) {
+            const v = this._vals[i];
+            if (v !== DUMMY_POOL_FILE_NODE)
+                yield [this._keys[i], v];
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+}
+const SHARED_POOL_CAPACITY = 256;
+const SHARED_DIR_POOL_CAPACITY = 64;
+const sharedAllocationPool = new Array(SHARED_POOL_CAPACITY).fill(DUMMY_POOL_ALLOCATION);
+let sharedAllocationPoolLen = 0;
+const sharedFileNodePool = new Array(SHARED_POOL_CAPACITY).fill(DUMMY_POOL_FILE_NODE);
+let sharedFileNodePoolLen = 0;
+const sharedDirectoryNodePool = new Array(SHARED_DIR_POOL_CAPACITY);
+let sharedDirectoryNodePoolLen = 0;
+const sharedRemovedScratch = new Array(SHARED_POOL_CAPACITY).fill(DUMMY_POOL_FILE_NODE);
+let sharedRemovedLen = 0;
 let sharedRemovedKeyChars = 0;
 let sharedRemovedKeyEntries = 0;
 function collectRemovedChild(child, name) {
-    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 +268,29 @@ 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 (sharedFileNodePool.length < 112) {
-        sharedFileNodePool.push(new MemoryFileNode(0, 0, 0, 0, DUMMY_POOL_ALLOCATION, undefined));
+    while (sharedFileNodePoolLen < 112) {
+        sharedFileNodePool[sharedFileNodePoolLen++] = new MemoryFileNode(0, 0, fastWriteCachedNow, 0, DUMMY_POOL_ALLOCATION, undefined);
     }
-    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,6 +301,8 @@ Object.assign(MemoryDirectoryNode.prototype, {
     cachedNlink: 2,
     cachedNlinkRev: 0,
 });
+const DUMMY_POOL_DIR_NODE = new MemoryDirectoryNode(0, 0, null);
+DUMMY_POOL_DIR_NODE.atimeMs = DUMMY_POOL_DIR_NODE.mtimeMs = DUMMY_POOL_DIR_NODE.ctimeMs = DUMMY_POOL_DIR_NODE.birthtimeMs = 1700000000000;
 class MemoryCache {
     allocations = [];
     files = [];
@@ -117,6 +324,9 @@ class MemoryCache {
 const typeModes = { file: 0o100000, directory: 0o040000, symlink: 0o120000 };
 const emptyResolveOptions = Object.freeze({});
 const noFollowResolveOptions = Object.freeze({ followFinal: false });
+const sharedMkdirResolveOptions = { createDirectories: 0o777 };
+const sharedAllowMissingNoFollowOptions = Object.freeze({ allowMissing: true, followFinal: false });
+const sharedFastLocation = { node: undefined, parent: DUMMY_POOL_DIR_NODE, name: "", path: "" };
 const resolvedVoid = Promise.resolve();
 const preferredIoBlockSize = 64 * 1024;
 const ext4HtreeEof64 = (1n << 63n) - 1n;
@@ -496,11 +706,17 @@ export class MemoryFileSystem {
             atimeMs: now, mtimeMs: now, ctimeMs: now, birthtimeMs: now,
         };
     }
-    directory(mode) {
-        const now = Date.now();
+    directory(mode, now = Date.now()) {
         const fullMode = typeModes.directory | mode;
         const ino = this.nextInode++;
-        const pooled = 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 +733,13 @@ export class MemoryFileSystem {
         }
         return new MemoryDirectoryNode(fullMode, ino, now);
     }
-    addDirectoryNode(parent, name, mode, syscall, path) {
+    addDirectoryNode(parent, name, mode, syscall, path, now = Date.now()) {
         const bytes = name.length * 2;
         this.ledger.reserve(bytes, 2, syscall, path);
         try {
-            const node = this.directory(mode);
+            const node = this.directory(mode, now);
             parent.entries.set(name, node);
-            this.changed(parent);
+            this.changed(parent, now);
             return node;
         }
         catch (error) {
@@ -569,15 +785,15 @@ export class MemoryFileSystem {
             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.limits.maxFileBytes === Infinity && sharedAllocationPoolLen < SHARED_POOL_CAPACITY) {
+                    sharedAllocationPool[sharedAllocationPoolLen++] = alloc;
                 }
                 else if (cache.allocations.length < 128) {
                     cache.allocations.push(alloc);
                 }
             }
-            if (sharedFileNodePool.length < 128) {
-                sharedFileNodePool.push(node);
+            if (sharedFileNodePoolLen < SHARED_POOL_CAPACITY) {
+                sharedFileNodePool[sharedFileNodePoolLen++] = node;
             }
             else if (cache.files.length < 128) {
                 cache.files.push(node);
@@ -592,8 +808,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);
@@ -967,12 +1183,17 @@ 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 === 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.limits.maxFileBytes === Infinity && sharedAllocationPoolLen > 0) {
+                pooled = sharedAllocationPool[--sharedAllocationPoolLen];
+                sharedAllocationPool[sharedAllocationPoolLen] = DUMMY_POOL_ALLOCATION;
+            }
+            else {
+                pooled = memoryCaches.get(this.ledger).allocations.pop();
+            }
             if (pooled) {
                 pooled.reuse(this.ledger);
                 return pooled;
@@ -1092,7 +1313,14 @@ export class MemoryFileSystem {
                     const now = Date.now();
                     const fileMode = typeModes.file | target.mode;
                     const view = capacity === length ? allocation.data : undefined;
-                    const pooled = 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++;
@@ -1128,11 +1356,14 @@ export class MemoryFileSystem {
         }
     }
     writeAt(node, data, position, syscall, path) {
-        if (data.byteLength === 0) {
-            this.changed(node);
+        this.writeAtRange(node, data, data.byteLength, position, syscall, path, Date.now());
+    }
+    writeAtRange(node, data, dataLen, position, syscall, path, now) {
+        if (dataLen === 0) {
+            this.changed(node, now);
             return;
         }
-        const end = position + data.byteLength;
+        const end = position + dataLen;
         this.ledger.fileSize(end, syscall, path);
         const curLen = node.byteLength;
         const length = Math.max(curLen, end);
@@ -1151,11 +1382,17 @@ export class MemoryFileSystem {
         }
         try {
             const storage = allocation.data;
-            if (allocation !== node.allocation)
-                storage.set(node.view ?? (curLen === node.allocation.data.byteLength ? node.allocation.data : node.allocation.data.subarray(0, curLen)));
+            if (allocation !== node.allocation && curLen > 0) {
+                storage.set(node.allocation.data.subarray(0, curLen));
+            }
             if (position > curLen)
                 storage.fill(0, curLen, position);
-            storage.set(data, position);
+            if (dataLen === data.byteLength) {
+                storage.set(data, position);
+            }
+            else {
+                storage.set(data.subarray(0, dataLen), position);
+            }
         }
         catch (error) {
             if (allocation !== node.allocation)
@@ -1169,7 +1406,7 @@ export class MemoryFileSystem {
             node.byteLength = length;
             node.view = length === allocation.data.byteLength ? allocation.data : undefined;
         }
-        this.changed(node);
+        this.changed(node, now);
     }
     writeMemoryFileFast(path, data, append, mode) {
         const cache = memoryCaches.get(this.ledger);
@@ -1264,7 +1501,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++;
@@ -1404,16 +1648,26 @@ export class MemoryFileSystem {
                     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();
+                        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;
@@ -1991,7 +2245,7 @@ export class MemoryFileSystem {
             return Promise.reject(error);
         }
     }
-    removeLocation(location, path, syscall, recursive) {
+    removeLocation(location, path, syscall, recursive, now = Date.now()) {
         const node = location.node;
         if (this.terminalDot(path))
             this.fail("EINVAL", syscall, path);
@@ -2003,12 +2257,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 +2271,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 +2287,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,24 +2747,46 @@ export class MemoryRedirectHandle {
         this.position = 0;
         this.closed = false;
     }
-    writeSync(chunk, signal) {
+    reset(fs, path, node, append) {
+        this.fs = fs;
+        this.path = path;
+        this.node = node;
+        this.append = append;
+        this.position = 0;
+        this.closed = false;
+    }
+    writeRangeSync(src, len, signal) {
         signal?.throwIfAborted();
         if (this.closed)
             throw new FsError("EBADF", { syscall: "write", path: this.path });
-        if (chunk.byteLength === 0)
+        if (len === 0)
             return;
         const pos = this.append ? this.node.byteLength : this.position;
-        this.fs.writeAt(this.node, chunk, pos, "write", this.path);
+        const now = Date.now === defaultDateNow ? fastWriteCachedNow : Date.now();
+        this.fs.writeAtRange(this.node, src, len, pos, "write", this.path, now);
         if (!this.append)
-            this.position = pos + chunk.byteLength;
+            this.position = pos + len;
+    }
+    writeSync(chunk, signal) {
+        this.writeRangeSync(chunk, chunk.byteLength, signal);
     }
     close() {
         if (this.closed)
             return;
         this.closed = true;
-        this.fs.releaseReference(this.node, this.path);
+        const fs = this.fs;
+        const node = this.node;
+        const path = this.path;
+        this.fs = undefined;
+        this.node = DUMMY_POOL_FILE_NODE;
+        this.path = "";
+        fs.releaseReference(node, path);
+        if (redirectHandlePool.handle === undefined) {
+            redirectHandlePool.handle = this;
+        }
     }
 }
+const redirectHandlePool = { handle: undefined };
 export function tryOpenMemoryRedirectHandleSync(filesystem, path, append, mode, signal) {
     const mem = filesystem;
     const owner = ownedStores.get(mem);
@@ -2517,38 +2796,118 @@ export function tryOpenMemoryRedirectHandleSync(filesystem, path, append, mode,
         activeConditionalMutations.has(mem.identityScope) ||
         !isStockMemoryMethods(mem, openRedirectFastMethodNames, false) ||
         !isCleanAbsolutePath(path) ||
+        path === "/" ||
         path === "/dev" ||
         path.startsWith("/dev/")) {
         return undefined;
     }
     signal?.throwIfAborted();
-    const validMode = mem.mode(mode, 0o666, "open", path);
-    const location = mem.resolve(path, "open", {
-        followFinal: true,
-        allowMissing: true,
-    });
-    let node = location.node;
-    if (node) {
-        if (node.type !== "file")
-            mem.fail("EISDIR", "open", path);
-        mem.permission(node, 2, "open", path);
-    }
-    else {
-        mem.permission(location.parent, 3, "open", path);
+    const validMode = (mode & 0o777) === mode
+        ? mode
+        : mem.mode(mode, 0o666, "open", path);
+    const memInternal = mem;
+    let parent = memInternal.root;
+    let start = 1;
+    let name = "";
+    while (true) {
+        memInternal.permission(parent, 1, "open", path);
+        const slash = path.indexOf("/", start);
+        if (slash === -1) {
+            name = path.slice(start);
+            if (exceedsComponentByteLimit(name))
+                memInternal.fail("ENAMETOOLONG", "open", path);
+            break;
+        }
+        const seg = path.slice(start, slash);
+        if (exceedsComponentByteLimit(seg))
+            memInternal.fail("ENAMETOOLONG", "open", path);
+        const next = parent.entries.get(seg);
+        if (!next)
+            memInternal.fail("ENOENT", "open", path);
+        if (next.type !== "directory")
+            memInternal.fail("ENOTDIR", "open", path);
+        parent = next;
+        start = slash + 1;
     }
-    const ledger = mem.ledger;
-    ledger.reserve(path.length * 2, 1, "open", path);
-    try {
-        node ??= mem.openWrite(path, {}, "open", { location, mode: validMode, append: false });
+    const existing = parent.entries.get(name);
+    const ledger = memInternal.ledger;
+    let node;
+    if (existing !== undefined) {
+        if (existing.type !== "file")
+            memInternal.fail("EISDIR", "open", path);
+        memInternal.permission(existing, 2, "open", path);
+        ledger.reserve(path.length * 2, 1, "open", path);
+        node = existing;
         if (!append) {
-            mem.resizeNode(node, 0, "open", path);
+            try {
+                memInternal.resizeNode(node, 0, "open", path);
+            }
+            catch (error) {
+                ledger.release(path.length * 2, 1);
+                throw error;
+            }
+        }
+        node.references++;
+    }
+    else {
+        memInternal.permission(parent, 3, "open", path);
+        const refBytes = path.length * 2;
+        const nameBytes = name.length * 2;
+        ledger.reserve(refBytes, 1, "open", path);
+        try {
+            ledger.fileSize(0, "open", path);
+            ledger.reserve(nameBytes, 2, "open", path);
+        }
+        catch (error) {
+            ledger.release(refBytes, 1);
+            throw error;
+        }
+        const cache = memoryCaches.get(ledger);
+        cache.clearWrites();
+        const now = Date.now === defaultDateNow ? ((++fastWriteNowTick & 63) === 0 ? (fastWriteCachedNow = Date.now()) : fastWriteCachedNow) : Date.now();
+        const fileMode = typeModes.file | validMode;
+        let newNode;
+        if (sharedFileNodePoolLen > 0) {
+            newNode = sharedFileNodePool[--sharedFileNodePoolLen];
+            sharedFileNodePool[sharedFileNodePoolLen] = DUMMY_POOL_FILE_NODE;
         }
+        else {
+            newNode = cache.files.pop();
+        }
+        if (newNode) {
+            newNode.mode = fileMode;
+            newNode.ino = memInternal.nextInode++;
+            newNode.nlink = 1;
+            newNode.references = 1;
+            newNode.revision = 0;
+            newNode.atimeMs = now;
+            newNode.mtimeMs = now;
+            newNode.ctimeMs = now;
+            newNode.birthtimeMs = now;
+            newNode.byteLength = 0;
+            newNode.view = EMPTY_ALLOC_BYTES;
+            newNode.allocation = DUMMY_POOL_ALLOCATION;
+        }
+        else {
+            newNode = new MemoryFileNode(fileMode, memInternal.nextInode++, now, 0, DUMMY_POOL_ALLOCATION, EMPTY_ALLOC_BYTES);
+            newNode.references = 1;
+        }
+        const prevNlink = parent.cachedNlinkRev === parent.revision ? parent.cachedNlink : (parent.entries.size === 0 ? 2 : undefined);
+        parent.entries.set(name, newNode);
+        parent.revision = parent.revision < 1073741823 ? (parent.revision + 1) | 0 : Math.min(Number.MAX_SAFE_INTEGER + 1, parent.revision + 1);
+        parent.mtimeMs = parent.ctimeMs = now;
+        if (prevNlink !== undefined) {
+            parent.cachedNlink = prevNlink;
+            parent.cachedNlinkRev = parent.revision;
+        }
+        node = newNode;
     }
-    catch (error) {
-        ledger.release(path.length * 2, 1);
-        throw error;
+    const handle = redirectHandlePool.handle;
+    if (handle !== undefined) {
+        redirectHandlePool.handle = undefined;
+        handle.reset(mem, path, node, append);
+        return handle;
     }
-    node.references++;
     return new MemoryRedirectHandle(mem, path, node, append);
 }
 export function utf8ByteLength(value) {
@@ -2686,7 +3045,8 @@ export function tryReadMemoryFileViewSync(filesystem, path, maxBytes, signal) {
 }
 export function tryGetMemoryDirectoryEntryNamesSync(filesystem, path) {
     const mem = filesystem;
-    if (!ownedStores.has(mem) || mem.symlinkCount !== 0 || !isStockMemoryMethods(mem, readFileFastMethodNames, false))
+    const owner = ownedStores.get(mem);
+    if (!owner || mem.symlinkCount !== 0 || !isStockMemoryMethods(mem, readFileFastMethodNames, false))
         return undefined;
     const root = mem.root;
     if (path === "/") {
@@ -2696,6 +3056,16 @@ export function tryGetMemoryDirectoryEntryNamesSync(filesystem, path) {
     }
     if (!isCleanAbsolutePath(path) || path === "/dev" || path.startsWith("/dev/"))
         return undefined;
+    const cache = memoryCaches.get(owner.ledger);
+    const fastDir = cache?.lastFastDirNode;
+    const fastPrefix = cache?.lastFastDirPrefix;
+    if (fastDir !== undefined &&
+        fastDir.nlink !== 0 &&
+        ((fastDir.mode >> 6) & 4) === 4 &&
+        fastPrefix !== undefined &&
+        (fastPrefix === path || (fastPrefix.length === path.length + 1 && fastPrefix.charCodeAt(path.length) === 47 && fastPrefix.startsWith(path)))) {
+        return fastDir.entries;
+    }
     let current = root;
     let start = 1;
     while (true) {
@@ -2746,16 +3116,34 @@ export function tryMkdirMemorySync(filesystem, path, recursive, mode, signal) {
     signal?.throwIfAborted();
     const validMode = mem.mode(mode, 0o777, "mkdir", path);
     if (recursive) {
-        const node = mem.resolve(path, "mkdir", { createDirectories: validMode }).node;
-        if (node.type !== "directory")
-            mem.fail("EEXIST", "mkdir", path);
+        let current = owner.root;
+        let start = 1;
+        while (true) {
+            mem.permission(current, 1, "mkdir", path);
+            const slash = path.indexOf("/", start);
+            const seg = slash === -1 ? path.slice(start) : path.slice(start, slash);
+            if (exceedsComponentByteLimit(seg))
+                mem.fail("ENAMETOOLONG", "mkdir", path);
+            let next = current.entries.get(seg);
+            if (!next) {
+                mem.permission(current, 3, "mkdir", path);
+                next = mem.addDirectoryNode(current, seg, validMode, "mkdir", path, fastWriteCachedNow);
+            }
+            else if (next.type !== "directory") {
+                mem.fail(slash === -1 ? "EEXIST" : "ENOTDIR", "mkdir", path);
+            }
+            if (slash === -1)
+                break;
+            current = next;
+            start = slash + 1;
+        }
         return true;
     }
-    const location = mem.resolve(path, "mkdir", { allowMissing: true, followFinal: false });
+    const location = mem.resolve(path, "mkdir", sharedAllowMissingNoFollowOptions);
     if (location.node)
         mem.fail("EEXIST", "mkdir", path);
     mem.permission(location.parent, 3, "mkdir", path);
-    mem.addDirectoryNode(location.parent, location.name, validMode, "mkdir", path);
+    mem.addDirectoryNode(location.parent, location.name, validMode, "mkdir", path, fastWriteCachedNow);
     return true;
 }
 export function tryRmRfMemorySync(filesystem, path, signal) {
@@ -2772,16 +3160,46 @@ export function tryRmRfMemorySync(filesystem, path, signal) {
         return false;
     }
     signal?.throwIfAborted();
-    let location;
+    let current = owner.root;
+    let start = 1;
+    let targetNode;
+    let targetName = "";
+    while (true) {
+        mem.permission(current, 1, "rm", path);
+        const slash = path.indexOf("/", start);
+        if (slash === -1) {
+            targetName = path.slice(start);
+            if (exceedsComponentByteLimit(targetName))
+                mem.fail("ENAMETOOLONG", "rm", path);
+            targetNode = current.entries.get(targetName);
+            if (!targetNode)
+                return true;
+            break;
+        }
+        const seg = path.slice(start, slash);
+        if (exceedsComponentByteLimit(seg))
+            mem.fail("ENAMETOOLONG", "rm", path);
+        const next = current.entries.get(seg);
+        if (!next)
+            return true;
+        if (next.type !== "directory")
+            mem.fail("ENOTDIR", "rm", path);
+        current = next;
+        start = slash + 1;
+    }
+    sharedFastLocation.node = targetNode;
+    sharedFastLocation.parent = current;
+    sharedFastLocation.name = targetName;
+    sharedFastLocation.path = path;
     try {
-        location = mem.resolve(path, "rm", noFollowResolveOptions);
+        mem.removeLocation(sharedFastLocation, path, "rm", true, fastWriteCachedNow);
     }
-    catch (error) {
-        if (error instanceof FsError && error.code === "ENOENT")
-            return true;
-        throw error;
+    finally {
+        sharedFastLocation.node = undefined;
+        sharedFastLocation.parent = DUMMY_POOL_DIR_NODE;
+        sharedFastLocation.name = "";
+        sharedFastLocation.path = "";
     }
-    mem.removeLocation(location, path, "rm", true);
     return true;
 }
 export function tryWriteMemoryFileInDirSync(filesystem, dirPrefix, name, data, append, mode, signal) {

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

@@ -68,13 +68,18 @@ export class MemoryLedger {
 }
 export class MemoryAllocation {
     constructor(data, ledger) {
+        this.references = 1;
         this.data = data;
         this.ledger = ledger;
     }
     retain() {
+        if (this.data.byteLength === 0)
+            return;
         this.references++;
     }
     release() {
+        if (this.data.byteLength === 0)
+            return;
         if (this.references <= 0)
             throw new Error("Memory allocation already released");
         if (--this.references === 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-fs",
-  "version": "0.1.730",
+  "version": "0.1.731",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",