@poe-platform/safe-fs 0.1.728 → 0.1.730

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

@@ -15,19 +15,6 @@ import { MemoryAllocation, MemoryLedger } from "./ledger.js";
 import { normalizeMemoryFileSystemLimits } from "./limits.js";
 export { defaultMemoryFileSystemLimits } from "./limits.js";
 class MemoryFileNode {
-    type = "file";
-    revision = 0;
-    mode;
-    ino;
-    nlink = 1;
-    atimeMs;
-    mtimeMs;
-    ctimeMs;
-    birthtimeMs;
-    references = 0;
-    byteLength;
-    view;
-    allocation;
     constructor(mode, ino, now, byteLength, allocation, view) {
         this.mode = mode;
         this.ino = ino;
@@ -47,17 +34,83 @@ class MemoryFileNode {
         this.byteLength = value.byteLength;
     }
 }
+Object.assign(MemoryFileNode.prototype, {
+    type: "file",
+    revision: 0,
+    nlink: 1,
+    references: 0,
+});
+const EMPTY_ALLOC_BYTES = new Uint8Array(0);
+const SMALL_ALLOC_SLAB_SIZE = 8192;
+let smallAllocSlab = new Uint8Array(SMALL_ALLOC_SLAB_SIZE);
+let smallAllocOffset = 0;
+const DUMMY_POOL_LEDGER = new MemoryLedger(normalizeMemoryFileSystemLimits({}));
+const DUMMY_POOL_ALLOCATION = new MemoryAllocation(EMPTY_ALLOC_BYTES, DUMMY_POOL_LEDGER);
+const sharedAllocationPool = [];
+const sharedFileNodePool = [];
+const sharedDirectoryNodePool = [];
+const sharedRemovedScratch = [];
+let sharedRemovedKeyChars = 0;
+let sharedRemovedKeyEntries = 0;
+function collectRemovedChild(child, name) {
+    sharedRemovedScratch.push(child);
+    sharedRemovedKeyChars += name.length;
+    sharedRemovedKeyEntries++;
+}
+function replenishSharedMemoryPools() {
+    while (sharedAllocationPool.length < 112) {
+        if (smallAllocOffset + 64 > SMALL_ALLOC_SLAB_SIZE) {
+            smallAllocSlab = new Uint8Array(SMALL_ALLOC_SLAB_SIZE);
+            smallAllocOffset = 0;
+        }
+        const slice = smallAllocSlab.subarray(smallAllocOffset, smallAllocOffset + 64);
+        smallAllocOffset += 64;
+        DUMMY_POOL_LEDGER.reserve(64, 0, "init", "/");
+        const alloc = new MemoryAllocation(slice, DUMMY_POOL_LEDGER);
+        alloc.release();
+        sharedAllocationPool.push(alloc);
+    }
+    while (sharedFileNodePool.length < 112) {
+        sharedFileNodePool.push(new MemoryFileNode(0, 0, 0, 0, DUMMY_POOL_ALLOCATION, undefined));
+    }
+    while (sharedDirectoryNodePool.length < 16) {
+        sharedDirectoryNodePool.push(new MemoryDirectoryNode(0, 0, 0));
+    }
+}
+class MemoryDirectoryNode {
+    constructor(mode, ino, now) {
+        this.mode = mode;
+        this.ino = ino;
+        this.atimeMs = now;
+        this.mtimeMs = now;
+        this.ctimeMs = now;
+        this.birthtimeMs = now;
+        this.entries = new Map();
+    }
+}
+Object.assign(MemoryDirectoryNode.prototype, {
+    type: "directory",
+    revision: 0,
+    nlink: 1,
+    references: 0,
+    cachedNlink: 2,
+    cachedNlinkRev: 0,
+});
 class MemoryCache {
     allocations = [];
     files = [];
+    directories = [];
+    removedScratch = [];
     lastFastDirPrefix = "";
     lastFastDirNode;
     lastFastFilePath = "";
+    lastFastFileName = "";
     lastFastFileNode;
     clearWrites() {
         this.lastFastDirPrefix = "";
         this.lastFastDirNode = undefined;
         this.lastFastFilePath = "";
+        this.lastFastFileName = "";
         this.lastFastFileNode = undefined;
     }
 }
@@ -70,6 +123,14 @@ const ext4HtreeEof64 = (1n << 63n) - 1n;
 const extractionStreamGuard = Symbol("extractionStreamGuard");
 const ownedStats = new WeakMap();
 const ownedStores = new WeakMap();
+// Ensure V8 uses Tagged representation for timestamp fields so all 4 fields share one HeapNumber pointer.
+{
+    const dummyAlloc = new MemoryAllocation(new Uint8Array(0), new MemoryLedger(normalizeMemoryFileSystemLimits({})));
+    const dummyFile = new MemoryFileNode(0, 0, null, 0, dummyAlloc, dummyAlloc.data);
+    dummyFile.atimeMs = dummyFile.mtimeMs = dummyFile.ctimeMs = dummyFile.birthtimeMs = 1700000000000;
+    const dummyDir = new MemoryDirectoryNode(0, 0, null);
+    dummyDir.atimeMs = dummyDir.mtimeMs = dummyDir.ctimeMs = dummyDir.birthtimeMs = 1700000000000;
+}
 // Forwarded receivers share the ledger, so mutations invalidate the owner's cache.
 const memoryCaches = new WeakMap();
 const registeredAuthorities = new WeakSet();
@@ -127,6 +188,107 @@ export async function bindConditionalMutation(identityScope, binding, action) {
         }
     }
 }
+const STREAM_DONE_RESULT = Object.freeze({ done: true, value: undefined });
+const STREAM_RESOLVED_DONE = Promise.resolve(STREAM_DONE_RESULT);
+class MemoryReadStream {
+    constructor(fs, path, options) {
+        this.fs = fs;
+        this.path = path;
+        this.options = options;
+        this.abortSignal = options.signal;
+        this.initialized = false;
+        this.finished = false;
+        this.offset = 0;
+        this.end = 0;
+        this.chunkSize = preferredIoBlockSize;
+        this.node = undefined;
+        this.allocation = undefined;
+        this.data = undefined;
+    }
+    [Symbol.asyncIterator]() {
+        if (this.initialized || this.finished) {
+            return new MemoryReadStream(this.fs, this.path, this.options);
+        }
+        return this;
+    }
+    _release() {
+        if (this.finished)
+            return;
+        this.finished = true;
+        if (this.allocation) {
+            this.allocation.release();
+            this.allocation = undefined;
+        }
+        if (this.node) {
+            const releasedNode = this.node;
+            this.node = undefined;
+            this.fs.releaseReference(releasedNode, this.path);
+        }
+        this.data = undefined;
+    }
+    tryNextSync() {
+        if (this.finished)
+            return STREAM_DONE_RESULT;
+        try {
+            const options = this.options;
+            options.signal?.throwIfAborted();
+            if (!this.initialized) {
+                this.initialized = true;
+                const fs = this.fs;
+                const path = this.path;
+                const start = options.start ?? 0;
+                const chunkSize = options.chunkSize ?? preferredIoBlockSize;
+                this.chunkSize = chunkSize;
+                fs.integer(start, "readStream", path);
+                fs.integer(chunkSize, "readStream", path);
+                if (chunkSize === 0)
+                    fs.fail("EINVAL", "readStream", path);
+                if (options.endExclusive !== undefined) {
+                    fs.integer(options.endExclusive, "readStream", path);
+                    if (options.endExclusive < start)
+                        fs.fail("EINVAL", "readStream", path);
+                }
+                const target = fs.file(path, "readStream");
+                fs.permission(target, 4, "readStream", path);
+                fs.ledger.reserve(path.length * 2, 1, "readStream", path);
+                target.references++;
+                this.node = target;
+                this.allocation = target.allocation;
+                target.allocation.retain();
+                const data = target.data;
+                this.data = data;
+                this.offset = start;
+                this.end = Math.min(options.endExclusive ?? data.byteLength, data.byteLength);
+                target.atimeMs = Date.now();
+            }
+            if (this.offset < this.end) {
+                const nextEnd = Math.min(this.offset + this.chunkSize, this.end);
+                const chunk = this.data.slice(this.offset, nextEnd);
+                this.offset = nextEnd;
+                return { done: false, value: chunk };
+            }
+            this._release();
+            return STREAM_DONE_RESULT;
+        }
+        catch (error) {
+            this._release();
+            throw error;
+        }
+    }
+    next() {
+        try {
+            const res = this.tryNextSync();
+            return res.done ? STREAM_RESOLVED_DONE : Promise.resolve(res);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    return() {
+        this._release();
+        return STREAM_RESOLVED_DONE;
+    }
+}
 export class MemoryFileSystem {
     capabilitiesFor;
     capabilities = ((filesystem) => {
@@ -142,7 +304,7 @@ export class MemoryFileSystem {
             permissions: true,
             timestamps: true,
             atomicRename: true,
-            atomicFileStaging: true, retainedStagingCleanup: true, atomicStagingAncestry: true, atomicFileMutation: true, atomicEntryRemoval: true, atomicEntryRemovalReceipt: true, atomicTreeRemoval: true,
+            atomicFileStaging: true, retainedStagingCleanup: true, retainedStagingWrite: true, atomicStagingAncestry: true, atomicFileMutation: true, atomicEntryRemoval: true, atomicEntryRemovalReceipt: true, atomicTreeRemoval: true,
             synchronousDirectoryValidation: true, synchronousStagingResolution: true, guardedStagingPublication: true,
             atomicDirectoryMetadata: true,
             streamingRead: true,
@@ -160,6 +322,9 @@ export class MemoryFileSystem {
     symlinkCount = 0;
     constructor(options = {}) {
         this.ledger = new MemoryLedger(normalizeMemoryFileSystemLimits(options));
+        if (this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity) {
+            replenishSharedMemoryPools();
+        }
         memoryCaches.set(this.ledger, new MemoryCache());
         this.ledger.reserve(0, 1, "mkdir", "/");
         this.root = this.directory(0o755);
@@ -250,8 +415,8 @@ export class MemoryFileSystem {
             }
             retained.set("/", this.root);
         }
-        const capabilities = Object.freeze({ ...this.capabilities, retainedStagingCleanup: false });
-        const allowed = new Set(["mkdir", "rm", "rmdir", "rename", "symlink", "link", "chmod", "utimes", "writeFile", "appendFile", "writeStream", "writeFileConditional", "removeFileConditional"]);
+        const capabilities = this.capabilities;
+        const allowed = new Set(["mkdir", "rm", "rmdir", "rename", "symlink", "link", "chmod", "utimes", "writeFile", "appendFile", "writeStream", "writeFileConditional", "removeFileConditional", "removeEntryConditional", "prepareDirectory", "createStagedFile", "publishStagedFile", "removeStagedFile"]);
         const reads = new Set(["access", "capabilitiesFor", "compareEntry", "lstat", "stat", "readFile", "readStream", "readdir", "readlink", "realpath"]);
         const check = (path, followFinal) => {
             if (!roots.some(root => root === "/" || path === root || path.startsWith(`${root}/`)))
@@ -287,7 +452,7 @@ export class MemoryFileSystem {
                         throw new FsError("ENOTSUP", { syscall: String(property) });
                     // Stock mutations resolve and commit synchronously. Streamed writes
                     // repeat the boundary and file-binding check at each backend mutation.
-                    const paths = property === "symlink" ? [args[1]] : property === "link" || property === "rename" ? args.slice(0, 2) : [args[0]];
+                    const paths = property === "publishStagedFile" ? [args[1], args[0].directory.path] : property === "removeStagedFile" ? [args[0].directory.path] : property === "symlink" ? [args[1]] : property === "link" || property === "rename" ? args.slice(0, 2) : [args[0]];
                     for (const path of paths) {
                         if (typeof path !== "string")
                             throw new FsError("EINVAL");
@@ -301,6 +466,24 @@ export class MemoryFileSystem {
                                     this.fail("EPERM", "writeStream", path);
                             } };
                     }
+                    if (property === "createStagedFile")
+                        return Reflect.apply(value, target, args).then(staging => {
+                            const writer = staging.writer;
+                            if (!writer)
+                                return staging;
+                            return Object.freeze({ ...staging, writer: Object.freeze({
+                                    write: async (bytes, controls = {}) => {
+                                        controls.signal?.throwIfAborted();
+                                        check(staging.file.path, true);
+                                        await writer.write(bytes, controls);
+                                    },
+                                    finish: async (controls = {}) => {
+                                        controls.signal?.throwIfAborted();
+                                        check(staging.file.path, true);
+                                        return writer.finish(controls);
+                                    },
+                                }) });
+                        });
                     return Reflect.apply(value, target, args);
                 };
             },
@@ -314,7 +497,39 @@ export class MemoryFileSystem {
         };
     }
     directory(mode) {
-        return { ...this.metadata(typeModes.directory | mode), type: "directory", entries: new Map() };
+        const now = Date.now();
+        const fullMode = typeModes.directory | mode;
+        const ino = this.nextInode++;
+        const pooled = sharedDirectoryNodePool.pop() ?? memoryCaches.get(this.ledger)?.directories.pop();
+        if (pooled) {
+            pooled.mode = fullMode;
+            pooled.ino = ino;
+            pooled.nlink = 1;
+            pooled.references = 0;
+            pooled.revision = 0;
+            pooled.atimeMs = now;
+            pooled.mtimeMs = now;
+            pooled.ctimeMs = now;
+            pooled.birthtimeMs = now;
+            pooled.cachedNlink = 2;
+            pooled.cachedNlinkRev = 0;
+            return pooled;
+        }
+        return new MemoryDirectoryNode(fullMode, ino, now);
+    }
+    addDirectoryNode(parent, name, mode, syscall, path) {
+        const bytes = name.length * 2;
+        this.ledger.reserve(bytes, 2, syscall, path);
+        try {
+            const node = this.directory(mode);
+            parent.entries.set(name, node);
+            this.changed(parent);
+            return node;
+        }
+        catch (error) {
+            this.ledger.release(bytes, 2);
+            throw error;
+        }
     }
     addNode(parent, name, create, syscall, path, retainedBytes = 0) {
         const bytes = name.length * 2 + retainedBytes;
@@ -344,25 +559,46 @@ export class MemoryFileSystem {
         if (node.type === "file") {
             if (cache.lastFastFileNode === node) {
                 cache.lastFastFilePath = "";
+                cache.lastFastFileName = "";
                 cache.lastFastFileNode = undefined;
             }
             this.totalBytes -= node.byteLength;
             const alloc = node.allocation;
             node.view = undefined;
+            node.allocation = DUMMY_POOL_ALLOCATION;
             alloc.release();
-            if (alloc.isReleased64() && cache.allocations.length < 128) {
-                cache.allocations.push(alloc);
+            if (alloc.isReleased64()) {
+                alloc.detachLedger(DUMMY_POOL_LEDGER);
+                if (this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity && sharedAllocationPool.length < 128) {
+                    sharedAllocationPool.push(alloc);
+                }
+                else if (cache.allocations.length < 128) {
+                    cache.allocations.push(alloc);
+                }
+            }
+            if (sharedFileNodePool.length < 128) {
+                sharedFileNodePool.push(node);
             }
-            if (cache.files.length < 128) {
+            else if (cache.files.length < 128) {
                 cache.files.push(node);
             }
         }
         else if (node.type === "symlink") {
             this.symlinkCount--;
         }
-        else if (cache.lastFastDirNode === node) {
-            cache.lastFastDirPrefix = "";
-            cache.lastFastDirNode = undefined;
+        else {
+            if (cache.lastFastDirNode === node) {
+                cache.lastFastDirPrefix = "";
+                cache.lastFastDirNode = undefined;
+            }
+            if (node.entries.size === 0) {
+                if (sharedDirectoryNodePool.length < 32) {
+                    sharedDirectoryNodePool.push(node);
+                }
+                else if (cache.directories.length < 32) {
+                    cache.directories.push(node);
+                }
+            }
         }
     }
     releaseReference(node, path) {
@@ -408,9 +644,9 @@ export class MemoryFileSystem {
         if (!Number.isSafeInteger(value) || value < 0)
             this.fail("EINVAL", syscall, path);
     }
-    changed(node) {
+    changed(node, now = Date.now()) {
         node.revision = node.revision < 1073741823 ? (node.revision + 1) | 0 : Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
-        node.mtimeMs = node.ctimeMs = Date.now();
+        node.mtimeMs = node.ctimeMs = now;
     }
     resolveNode(path, syscall, followFinal = true) {
         const cache = memoryCaches.get(this.ledger);
@@ -462,7 +698,7 @@ export class MemoryFileSystem {
     }
     resolve(path, syscall, options = emptyResolveOptions) {
         this.validatePath(path, syscall);
-        if (this.symlinkCount === 0 && options.createDirectories === undefined && options.resizeCreate === undefined
+        if (this.symlinkCount === 0 && options.resizeCreate === undefined
             && options.resolutionSteps === undefined && isCleanAbsolutePath(path)) {
             let current = this.root;
             let start = 1;
@@ -473,7 +709,11 @@ export class MemoryFileSystem {
                     const name = path.slice(start);
                     if (exceedsComponentByteLimit(name))
                         this.fail("ENAMETOOLONG", syscall, path);
-                    const node = current.entries.get(name);
+                    let node = current.entries.get(name);
+                    if (!node && options.createDirectories !== undefined) {
+                        this.permission(current, 3, syscall, path);
+                        node = this.addDirectoryNode(current, name, options.createDirectories, syscall, path);
+                    }
                     if (!node && !options.allowMissing)
                         this.fail("ENOENT", syscall, path);
                     return { node, parent: current, name, path };
@@ -481,7 +721,11 @@ export class MemoryFileSystem {
                 const name = path.slice(start, slash);
                 if (exceedsComponentByteLimit(name))
                     this.fail("ENAMETOOLONG", syscall, path);
-                const next = current.entries.get(name);
+                let next = current.entries.get(name);
+                if (!next && options.createDirectories !== undefined) {
+                    this.permission(current, 3, syscall, path);
+                    next = this.addDirectoryNode(current, name, options.createDirectories, syscall, path);
+                }
                 if (!next)
                     this.fail("ENOENT", syscall, path);
                 if (next.type !== "directory")
@@ -645,6 +889,12 @@ export class MemoryFileSystem {
         return location;
     }
     terminalDot(path) {
+        const len = path.length;
+        if (len === 0)
+            return false;
+        const last = path.charCodeAt(len - 1);
+        if (last !== 46 && last !== 47)
+            return false;
         return /(?:^|\/)\.{1,2}\/*$/.test(path);
     }
     directoryNlink(node) {
@@ -716,13 +966,30 @@ export class MemoryFileSystem {
     allocate(length, syscall, path) {
         this.ledger.fileSize(length, syscall, path);
         this.ledger.reserve(length, 0, syscall, path);
-        const allocations = memoryCaches.get(this.ledger).allocations;
-        if (length === 64 && allocations.length > 0) {
-            const pooled = allocations.pop();
-            pooled.reuse();
-            return pooled;
+        if (length === 0) {
+            return new MemoryAllocation(EMPTY_ALLOC_BYTES, this.ledger);
+        }
+        if (length === 64) {
+            const pooled = (this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity
+                ? sharedAllocationPool.pop()
+                : undefined) ?? memoryCaches.get(this.ledger).allocations.pop();
+            if (pooled) {
+                pooled.reuse(this.ledger);
+                return pooled;
+            }
         }
         try {
+            // A shared slab's backing buffer exceeds the admitted slice capacity.
+            // Finite file/storage ceilings require independently owned exact buffers.
+            if (length <= 64 && this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity) {
+                if (smallAllocOffset + length > SMALL_ALLOC_SLAB_SIZE) {
+                    smallAllocSlab = new Uint8Array(SMALL_ALLOC_SLAB_SIZE);
+                    smallAllocOffset = 0;
+                }
+                const slice = smallAllocSlab.subarray(smallAllocOffset, smallAllocOffset + length);
+                smallAllocOffset += length;
+                return new MemoryAllocation(slice, this.ledger);
+            }
             return new MemoryAllocation(new Uint8Array(length), this.ledger);
         }
         catch (cause) {
@@ -825,7 +1092,7 @@ export class MemoryFileSystem {
                     const now = Date.now();
                     const fileMode = typeModes.file | target.mode;
                     const view = capacity === length ? allocation.data : undefined;
-                    const pooled = memoryCaches.get(this.ledger).files.pop();
+                    const pooled = sharedFileNodePool.pop() ?? memoryCaches.get(this.ledger).files.pop();
                     if (pooled) {
                         pooled.mode = fileMode;
                         pooled.ino = this.nextInode++;
@@ -873,7 +1140,13 @@ export class MemoryFileSystem {
         let allocation = node.allocation;
         if (length > allocation.data.byteLength) {
             this.ledger.check(length, 0, syscall, path);
-            const capacity = Math.min(Math.max(length, curLen * 2, 64), this.ledger.limits.maxFileBytes, this.ledger.availableBytes);
+            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);
             allocation = this.allocate(capacity, syscall, path);
         }
         try {
@@ -977,13 +1250,12 @@ export class MemoryFileSystem {
         if (current && append) {
             this.writeAt(current, data, current.byteLength, syscall, path);
             cache.lastFastFilePath = path;
+            cache.lastFastFileName = name;
             cache.lastFastFileNode = current;
             return;
         }
         if (!current) {
-            const capacity = length > 0 && (append || (length < 64 && this.ledger.availableBytes > 65536 && this.ledger.limits.maxFileBytes >= 64))
-                ? Math.min(Math.max(length, 64), this.ledger.limits.maxFileBytes, this.ledger.availableBytes - nameBytes)
-                : length;
+            const capacity = length > 0 && length < 64 && this.ledger.hasInfiniteRetained && this.ledger.limits.maxFileBytes === Infinity ? 64 : length;
             const allocation = this.allocate(capacity, syscall, path);
             try {
                 allocation.data.set(data);
@@ -992,7 +1264,7 @@ export class MemoryFileSystem {
                     const now = Date.now();
                     const fileMode = typeModes.file | mode;
                     const view = capacity === length ? allocation.data : undefined;
-                    let node = cache.files.pop();
+                    let node = sharedFileNodePool.pop() ?? cache.files.pop();
                     if (node) {
                         node.mode = fileMode;
                         node.ino = this.nextInode++;
@@ -1010,16 +1282,16 @@ export class MemoryFileSystem {
                     else {
                         node = new MemoryFileNode(fileMode, this.nextInode++, now, length, allocation, view);
                     }
-                    this.admitSize(undefined, length, syscall, path);
                     const prevNlink = parent.cachedNlinkRev === parent.revision ? parent.cachedNlink : (parent.entries.size === 0 ? 2 : undefined);
                     parent.entries.set(name, node);
                     this.totalBytes += length;
-                    this.changed(parent);
+                    this.changed(parent, now);
                     if (prevNlink !== undefined) {
                         parent.cachedNlink = prevNlink;
                         parent.cachedNlinkRev = parent.revision;
                     }
                     cache.lastFastFilePath = path;
+                    cache.lastFastFileName = name;
                     cache.lastFastFileNode = node;
                 }
                 catch (error) {
@@ -1037,12 +1309,169 @@ export class MemoryFileSystem {
         try {
             this.replaceData(current, copied);
             this.changed(current);
+            cache.lastFastFilePath = path;
+            cache.lastFastFileName = name;
+            cache.lastFastFileNode = current;
         }
         catch (error) {
             copied.release();
             throw error;
         }
     }
+    writeMemoryFileInDirFast(dirPrefix, name, data, append, mode) {
+        const cache = memoryCaches.get(this.ledger);
+        const syscall = append ? "appendFile" : "writeFile";
+        try {
+            if (append &&
+                dirPrefix === cache.lastFastDirPrefix &&
+                name === cache.lastFastFileName &&
+                cache.lastFastFileNode !== undefined &&
+                cache.lastFastFileNode.nlink !== 0 &&
+                cache.lastFastDirNode !== undefined &&
+                cache.lastFastDirNode.nlink !== 0 &&
+                (cache.lastFastDirNode.mode & 1) !== 0 &&
+                (cache.lastFastFileNode.mode & 2) !== 0) {
+                const current = cache.lastFastFileNode;
+                const length = current.byteLength + data.byteLength;
+                this.admitSize(current, length, syscall, name);
+                const growth = length > current.allocation.data.byteLength ? length : 0;
+                this.ledger.check(data.byteLength + growth, 0, syscall, name);
+                this.writeAt(current, data, current.byteLength, syscall, name);
+                return;
+            }
+            let parent = this.root;
+            const cachedDir = cache.lastFastDirNode;
+            if (cachedDir !== undefined &&
+                cachedDir.nlink !== 0 &&
+                (cachedDir.mode & 1) !== 0 &&
+                dirPrefix === cache.lastFastDirPrefix) {
+                parent = cachedDir;
+                if (exceedsComponentByteLimit(name))
+                    this.fail("ENAMETOOLONG", syscall, name);
+            }
+            else {
+                let start = 1;
+                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);
+                    if (exceedsComponentByteLimit(seg))
+                        this.fail("ENAMETOOLONG", syscall, name);
+                    const next = parent.entries.get(seg);
+                    if (!next)
+                        this.fail("ENOENT", syscall, name);
+                    if (next.type !== "directory")
+                        this.fail("ENOTDIR", syscall, name);
+                    parent = next;
+                    if (slash === -1)
+                        break;
+                    start = slash + 1;
+                }
+                this.permission(parent, 1, syscall, name);
+                if (exceedsComponentByteLimit(name))
+                    this.fail("ENAMETOOLONG", syscall, name);
+                if (dirPrefix.length > 1 && (parent.mode & 1) !== 0) {
+                    cache.lastFastDirPrefix = dirPrefix;
+                    cache.lastFastDirNode = parent;
+                }
+            }
+            const existing = parent.entries.get(name);
+            if (existing) {
+                if (existing.type !== "file")
+                    this.fail("EISDIR", syscall, name);
+                this.permission(existing, 2, syscall, name);
+            }
+            else {
+                this.permission(parent, 3, syscall, name);
+            }
+            const current = existing;
+            const length = (append ? current?.byteLength ?? 0 : 0) + data.byteLength;
+            this.admitSize(current, length, syscall, name);
+            const growth = append && length > (current?.allocation.data.byteLength ?? 0) ? length : 0;
+            const nameBytes = name.length * 2;
+            this.ledger.check(data.byteLength + growth + (current ? 0 : nameBytes), current ? 0 : 2, syscall, name);
+            if (current && append) {
+                this.writeAt(current, data, current.byteLength, syscall, name);
+                cache.lastFastFilePath = "";
+                cache.lastFastFileName = name;
+                cache.lastFastFileNode = current;
+                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);
+                try {
+                    allocation.data.set(data);
+                    this.ledger.reserve(nameBytes, 2, syscall, name);
+                    try {
+                        const now = Date.now();
+                        const fileMode = typeModes.file | mode;
+                        const view = capacity === length ? allocation.data : undefined;
+                        let node = sharedFileNodePool.pop() ?? cache.files.pop();
+                        if (node) {
+                            node.mode = fileMode;
+                            node.ino = this.nextInode++;
+                            node.nlink = 1;
+                            node.references = 0;
+                            node.revision = 0;
+                            node.atimeMs = now;
+                            node.mtimeMs = now;
+                            node.ctimeMs = now;
+                            node.birthtimeMs = now;
+                            node.byteLength = length;
+                            node.view = view;
+                            node.allocation = allocation;
+                        }
+                        else {
+                            node = new MemoryFileNode(fileMode, this.nextInode++, now, length, allocation, view);
+                        }
+                        const prevNlink = parent.cachedNlinkRev === parent.revision ? parent.cachedNlink : (parent.entries.size === 0 ? 2 : undefined);
+                        parent.entries.set(name, node);
+                        this.totalBytes += length;
+                        this.changed(parent, now);
+                        if (prevNlink !== undefined) {
+                            parent.cachedNlink = prevNlink;
+                            parent.cachedNlinkRev = parent.revision;
+                        }
+                        cache.lastFastFilePath = "";
+                        cache.lastFastFileName = name;
+                        cache.lastFastFileNode = node;
+                    }
+                    catch (error) {
+                        this.ledger.release(nameBytes, 2);
+                        throw error;
+                    }
+                }
+                catch (error) {
+                    allocation.release();
+                    throw error;
+                }
+                return;
+            }
+            const copied = this.bytes(data, syscall, name);
+            try {
+                this.replaceData(current, copied);
+                this.changed(current);
+                cache.lastFastFilePath = "";
+                cache.lastFastFileName = name;
+                cache.lastFastFileNode = current;
+            }
+            catch (error) {
+                copied.release();
+                throw error;
+            }
+        }
+        catch (error) {
+            if (error instanceof FsError && error.path === name) {
+                throw new FsError(error.code, {
+                    syscall: error.syscall ?? syscall,
+                    path: dirPrefix + name,
+                    ...(error.dest === undefined ? {} : { dest: error.dest }),
+                });
+            }
+            throw error;
+        }
+    }
     async readFile(path, options = {}) {
         options.signal?.throwIfAborted();
         if (options.maxBytes !== undefined)
@@ -1143,6 +1572,8 @@ export class MemoryFileSystem {
             location.parent.entries.set(location.name, directory);
             if (file.type === "file")
                 this.totalBytes += file.data.byteLength;
+            else
+                this.symlinkCount++;
         }
         catch (error) {
             allocation?.release();
@@ -1158,13 +1589,16 @@ export class MemoryFileSystem {
         location.parent.references++;
         directory.references++;
         file.references++;
-        return Object.freeze({ ...staging, cleanup: this.retainStagingCleanup(staging, location.parent, directory, file, location.name, name) });
+        return Object.freeze({ ...staging, ...this.retainStagingCleanup(staging, location.parent, directory, file, location.name, name) });
     }
     retainStagingCleanup(staging, parent, directory, file, directoryName, fileName) {
         // Clear this state on release, so keeping the closed handle does not keep
         // detached nodes alive outside the Memory ledger.
         let retained = { parent, directory, file };
-        return createStagingCleanup(staging.directory.path, options => {
+        let expected = staging.file.stat;
+        let writing = true;
+        const receipt = () => ({ ...staging, file: { ...staging.file, stat: expected } });
+        const ownedCleanup = createStagingCleanup(staging.directory.path, options => {
             options.signal?.throwIfAborted();
             const state = retained;
             if (state.parent.nlink === 0 || state.parent.entries.get(directoryName) !== state.directory)
@@ -1176,7 +1610,7 @@ export class MemoryFileSystem {
             const child = state.directory.entries.get(fileName);
             if (child && child !== state.file)
                 this.fail("EAGAIN", "removeStagedFile", staging.file.path);
-            this.removeStagingLocations(staging, {
+            this.removeStagingLocations(receipt(), {
                 node: state.directory, parent: state.parent, name: directoryName, path: staging.directory.path,
             }, { node: child, parent: state.directory, name: fileName, path: staging.file.path });
         }, () => {
@@ -1186,6 +1620,43 @@ export class MemoryFileSystem {
             this.releaseReference(state.directory, staging.directory.path);
             this.releaseReference(state.parent, staging.parent.path);
         });
+        const cleanup = Object.freeze({
+            remove: (options) => { writing = false; return ownedCleanup.remove(options); },
+            close: () => { writing = false; return ownedCleanup.close(); },
+        });
+        if (file.type !== "file")
+            return { cleanup };
+        const inspect = (options) => {
+            options.signal?.throwIfAborted();
+            if (!retained || !writing)
+                this.fail("EBADF", "stagedWrite", staging.file.path);
+            const location = this.stagingLocations(receipt());
+            if (location.file.node !== retained.file)
+                this.fail("EAGAIN", "stagedWrite", staging.file.path);
+            this.expectEntry(retained.file, expected, staging.file.path);
+            this.permission(retained.parent, 3, "stagedWrite", staging.parent.path);
+            this.permission(retained.directory, 3, "stagedWrite", staging.directory.path);
+            return retained.file;
+        };
+        return { cleanup, writer: Object.freeze({
+                write: async (bytes, options = {}) => {
+                    const node = inspect(options);
+                    if (!(bytes instanceof Uint8Array))
+                        throw new TypeError("Staged writes require Uint8Array data");
+                    this.writeAt(node, bytes, node.byteLength, "stagedWrite", staging.file.path);
+                    expected = Object.freeze(this.snapshot(node));
+                },
+                finish: async (options = {}) => {
+                    const node = inspect(options);
+                    this.changed(node);
+                    // changed updates modification time; archive creation metadata is final.
+                    node.atimeMs = staging.file.stat.atimeMs;
+                    node.mtimeMs = staging.file.stat.mtimeMs;
+                    writing = false;
+                    expected = Object.freeze(this.snapshot(node));
+                    return expected;
+                },
+            }) };
     }
     async prepareDirectoryAncestry(ancestors, options = {}) {
         const entries = snapshotDirectoryAncestry(ancestors);
@@ -1529,31 +2000,39 @@ export class MemoryFileSystem {
         this.permission(location.parent, 3, syscall, path);
         if (node.type === "directory" && !recursive)
             this.fail("EISDIR", syscall, path);
-        memoryCaches.get(this.ledger).clearWrites();
-        const removed = [node];
-        let keyChars = 0;
-        let keyEntries = 0;
-        for (let index = 0; index < removed.length; index++) {
-            const entry = removed[index];
-            if (entry.type === "directory" && entry.entries.size > 0) {
-                this.permission(entry, 7, syscall, path);
-                entry.entries.forEach((child, name) => {
-                    removed.push(child);
-                    keyChars += name.length;
-                    keyEntries++;
-                });
+        const cache = memoryCaches.get(this.ledger);
+        cache.clearWrites();
+        const removed = sharedRemovedScratch;
+        removed.length = 0;
+        removed.push(node);
+        sharedRemovedKeyChars = 0;
+        sharedRemovedKeyEntries = 0;
+        try {
+            for (let index = 0; index < removed.length; index++) {
+                const entry = removed[index];
+                if (entry.type === "directory" && entry.entries.size > 0) {
+                    this.permission(entry, 7, syscall, path);
+                    entry.entries.forEach(collectRemovedChild);
+                }
             }
-        }
-        location.parent.entries.delete(location.name);
-        this.ledger.release((location.name.length + keyChars) * 2, 1 + keyEntries);
-        for (const entry of removed) {
-            if (entry.type === "directory") {
-                entry.entries.clear();
+            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 entry = removed[i];
+                if (entry.type === "directory") {
+                    entry.entries.clear();
+                }
+                entry.nlink--;
+                if (entry.nlink !== 0 || entry.references !== 0) {
+                    entry.ctimeMs = now;
+                    entry.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, entry.revision + 1);
+                }
+                this.releaseNode(entry);
             }
-            entry.nlink--;
-            entry.ctimeMs = Date.now();
-            entry.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, entry.revision + 1);
-            this.releaseNode(entry);
+        }
+        finally {
+            removed.length = 0;
         }
         this.changed(location.parent);
     }
@@ -1882,94 +2361,7 @@ export class MemoryFileSystem {
         };
     }
     readStream(path, options = {}) {
-        return {
-            [Symbol.asyncIterator]: () => {
-                let initialized = false;
-                let finished = false;
-                let offset = 0;
-                let end = 0;
-                let chunkSize = preferredIoBlockSize;
-                let node;
-                let allocation;
-                let data;
-                const release = () => {
-                    if (finished)
-                        return;
-                    finished = true;
-                    if (allocation) {
-                        allocation.release();
-                        allocation = undefined;
-                    }
-                    if (node) {
-                        const releasedNode = node;
-                        node = undefined;
-                        this.releaseReference(releasedNode, path);
-                    }
-                    data = undefined;
-                };
-                const step = () => {
-                    if (finished)
-                        return { done: true, value: undefined };
-                    try {
-                        options.signal?.throwIfAborted();
-                        if (!initialized) {
-                            initialized = true;
-                            const start = options.start ?? 0;
-                            chunkSize = options.chunkSize ?? preferredIoBlockSize;
-                            this.integer(start, "readStream", path);
-                            this.integer(chunkSize, "readStream", path);
-                            if (chunkSize === 0)
-                                this.fail("EINVAL", "readStream", path);
-                            if (options.endExclusive !== undefined) {
-                                this.integer(options.endExclusive, "readStream", path);
-                                if (options.endExclusive < start)
-                                    this.fail("EINVAL", "readStream", path);
-                            }
-                            const target = this.file(path, "readStream");
-                            this.permission(target, 4, "readStream", path);
-                            this.ledger.reserve(path.length * 2, 1, "readStream", path);
-                            target.references++;
-                            node = target;
-                            allocation = target.allocation;
-                            allocation.retain();
-                            data = target.data;
-                            offset = start;
-                            end = Math.min(options.endExclusive ?? data.byteLength, data.byteLength);
-                            target.atimeMs = Date.now();
-                        }
-                        if (offset < end) {
-                            const nextEnd = Math.min(offset + chunkSize, end);
-                            const chunk = data.slice(offset, nextEnd);
-                            offset = nextEnd;
-                            return { done: false, value: chunk };
-                        }
-                        release();
-                        return { done: true, value: undefined };
-                    }
-                    catch (error) {
-                        release();
-                        throw error;
-                    }
-                };
-                return {
-                    abortSignal: options.signal,
-                    [Symbol.asyncIterator]() { return this; },
-                    tryNextSync: step,
-                    next() {
-                        try {
-                            return Promise.resolve(step());
-                        }
-                        catch (error) {
-                            return Promise.reject(error);
-                        }
-                    },
-                    return() {
-                        release();
-                        return Promise.resolve({ done: true, value: undefined });
-                    },
-                };
-            },
-        };
+        return new MemoryReadStream(this, path, options);
     }
     async writeStream(path, source, options = {}) {
         options.signal?.throwIfAborted();
@@ -2075,6 +2467,90 @@ const writeFileFastMethodNames = [
     "addNode", "replaceData", "resolve", "permission", "validatePath", "mode",
     "bytes", "allocate", "admitSize", "changed", "metadata", "fail",
 ];
+const mkdirFastMethodNames = [
+    "mkdir", "lstat", "stat", "resolve", "permission", "validatePath", "mode",
+    "addNode", "directory", "changed", "fail",
+];
+const rmFastMethodNames = [
+    "rm", "lstat", "stat", "readdir", "entry", "resolve", "removeLocation",
+    "permission", "validatePath", "terminalDot", "releaseNode", "changed", "fail",
+];
+const openRedirectFastMethodNames = [
+    "open", "writeFile", "appendFile", "rename", "writeData", "prepareWrite", "openWrite",
+    "resizeNode", "writeAt", "addNode", "replaceData", "resolve", "permission",
+    "validatePath", "mode", "bytes", "allocate", "admitSize", "changed", "metadata",
+    "releaseReference", "releaseNode", "fail",
+];
+export class MemoryRedirectHandle {
+    constructor(fs, path, node, append) {
+        this.fs = fs;
+        this.path = path;
+        this.node = node;
+        this.append = append;
+        this.position = 0;
+        this.closed = false;
+    }
+    writeSync(chunk, signal) {
+        signal?.throwIfAborted();
+        if (this.closed)
+            throw new FsError("EBADF", { syscall: "write", path: this.path });
+        if (chunk.byteLength === 0)
+            return;
+        const pos = this.append ? this.node.byteLength : this.position;
+        this.fs.writeAt(this.node, chunk, pos, "write", this.path);
+        if (!this.append)
+            this.position = pos + chunk.byteLength;
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.fs.releaseReference(this.node, this.path);
+    }
+}
+export function tryOpenMemoryRedirectHandleSync(filesystem, path, append, mode, signal) {
+    const mem = filesystem;
+    const owner = ownedStores.get(mem);
+    if (!owner ||
+        mem.symlinkCount !== 0 ||
+        mem.capabilities !== owner.capabilities ||
+        activeConditionalMutations.has(mem.identityScope) ||
+        !isStockMemoryMethods(mem, openRedirectFastMethodNames, false) ||
+        !isCleanAbsolutePath(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 ledger = mem.ledger;
+    ledger.reserve(path.length * 2, 1, "open", path);
+    try {
+        node ??= mem.openWrite(path, {}, "open", { location, mode: validMode, append: false });
+        if (!append) {
+            mem.resizeNode(node, 0, "open", path);
+        }
+    }
+    catch (error) {
+        ledger.release(path.length * 2, 1);
+        throw error;
+    }
+    node.references++;
+    return new MemoryRedirectHandle(mem, path, node, append);
+}
 export function utf8ByteLength(value) {
     let bytes = 0;
     for (let i = 0; i < value.length; i++) {
@@ -2255,3 +2731,75 @@ 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) {
+    const mem = filesystem;
+    const owner = ownedStores.get(mem);
+    if (!owner ||
+        mem.symlinkCount !== 0 ||
+        mem.capabilities !== owner.capabilities ||
+        !isStockMemoryMethods(mem, mkdirFastMethodNames, false) ||
+        !isCleanAbsolutePath(path) ||
+        path === "/dev" ||
+        path.startsWith("/dev/")) {
+        return false;
+    }
+    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);
+        return true;
+    }
+    const location = mem.resolve(path, "mkdir", { allowMissing: true, followFinal: false });
+    if (location.node)
+        mem.fail("EEXIST", "mkdir", path);
+    mem.permission(location.parent, 3, "mkdir", path);
+    mem.addDirectoryNode(location.parent, location.name, validMode, "mkdir", path);
+    return true;
+}
+export function tryRmRfMemorySync(filesystem, path, signal) {
+    const mem = filesystem;
+    const owner = ownedStores.get(mem);
+    if (!owner ||
+        mem.symlinkCount !== 0 ||
+        mem.capabilities !== owner.capabilities ||
+        activeConditionalMutations.has(mem.identityScope) ||
+        !isStockMemoryMethods(mem, rmFastMethodNames, false) ||
+        !isCleanAbsolutePath(path) ||
+        path === "/dev" ||
+        path.startsWith("/dev/")) {
+        return false;
+    }
+    signal?.throwIfAborted();
+    let location;
+    try {
+        location = mem.resolve(path, "rm", noFollowResolveOptions);
+    }
+    catch (error) {
+        if (error instanceof FsError && error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+    mem.removeLocation(location, path, "rm", true);
+    return true;
+}
+export function tryWriteMemoryFileInDirSync(filesystem, dirPrefix, name, data, append, mode, signal) {
+    const mem = filesystem;
+    const owner = ownedStores.get(mem);
+    if (!owner ||
+        mem.symlinkCount !== 0 ||
+        mem.capabilities !== owner.capabilities ||
+        !isStockMemoryMethods(mem, writeFileFastMethodNames, false) ||
+        name.length === 0 ||
+        name === "." ||
+        name === ".." ||
+        name.indexOf("/") !== -1 ||
+        name.indexOf("\0") !== -1 ||
+        dirPrefix.length + name.length > 65536) {
+        return false;
+    }
+    signal?.throwIfAborted();
+    mem.writeMemoryFileInDirFast(dirPrefix, name, data, append, mode);
+    return true;
+}