@poe-platform/safe-fs 0.1.727 → 0.1.729

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

@@ -1,19 +1,105 @@
 import { FsError } from "../../contracts/errors.js";
+import { normalizePath } from "../../contracts/virtual-path.js";
 import { assertCallbackAuthorityAllowed, compareEntries, registerEntryAuthority } from "../mount/comparison.js";
 import { getOwnedS3Entry } from "../s3/registry.js";
 import { getOwnedWebDavEntry } from "../webdav/resource-id.js";
 import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
 import { openFileDescriptor } from "../descriptor.js";
+import { directoryAncestryPaths, runStagingGuard, snapshotDirectoryAncestry, snapshotStagingResolution } from "../staging-ancestry.js";
+import { compareIdentity } from "../mount/identity.js";
+import { createStagingCleanup, snapshotStagingCreation } from "../staging-cleanup.js";
 import { resolveMissingTarget } from "./missing-target.js";
 import { registerMemoryAtomicView } from "./atomic-view.js";
+import { snapshotConditionalChmod } from "../conditional-chmod.js";
 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) {
+        this.mode = mode;
+        this.ino = ino;
+        this.atimeMs = now;
+        this.mtimeMs = now;
+        this.ctimeMs = now;
+        this.birthtimeMs = now;
+        this.byteLength = byteLength;
+        this.allocation = allocation;
+        this.view = view;
+    }
+    get data() {
+        return this.view ??= (this.byteLength === this.allocation.data.byteLength ? this.allocation.data : this.allocation.data.subarray(0, this.byteLength));
+    }
+    set data(value) {
+        this.view = value;
+        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;
+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;
+    }
+}
 const typeModes = { file: 0o100000, directory: 0o040000, symlink: 0o120000 };
+const emptyResolveOptions = Object.freeze({});
+const noFollowResolveOptions = Object.freeze({ followFinal: false });
+const resolvedVoid = Promise.resolve();
 const preferredIoBlockSize = 64 * 1024;
 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();
 const compareOwnedMemory = async (own, peer, options) => {
     options.signal?.throwIfAborted();
@@ -55,7 +141,123 @@ const compareOwnedMemory = async (own, peer, options) => {
     options.signal?.throwIfAborted();
     return qualified ? "distinct" : "unknown";
 };
+const activeConditionalMutations = new Map();
+export async function bindConditionalMutation(identityScope, binding, action) {
+    if (identityScope === undefined || identityScope === null)
+        return action();
+    activeConditionalMutations.set(identityScope, binding);
+    try {
+        return await action();
+    }
+    finally {
+        if (activeConditionalMutations.get(identityScope) === binding) {
+            activeConditionalMutations.delete(identityScope);
+        }
+    }
+}
+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) => {
         return Object.freeze({
             read: true, stat: true, readdir: true, realpath: true, access: true, open: true,
@@ -64,12 +266,13 @@ export class MemoryFileSystem {
             rename: true, atomicRenameNoReplace: true, copy: true, exclusiveCopy: true, readlink: true, truncate: true,
             streamingAppend: true, randomAccessWrite: true,
             readOnly: false,
-            symlinks: true,
+            symlinks: true, conditionalChmod: true,
             hardlinks: true,
             permissions: true,
             timestamps: true,
             atomicRename: true,
-            atomicFileStaging: true, atomicStagingAncestry: true, atomicFileMutation: true, atomicEntryRemoval: true, atomicTreeRemoval: true,
+            atomicFileStaging: true, retainedStagingCleanup: true, atomicStagingAncestry: true, atomicFileMutation: true, atomicEntryRemoval: true, atomicEntryRemovalReceipt: true, atomicTreeRemoval: true,
+            synchronousDirectoryValidation: true, synchronousStagingResolution: true, guardedStagingPublication: true,
             atomicDirectoryMetadata: true,
             streamingRead: true,
             retainedRead: true,
@@ -83,8 +286,10 @@ export class MemoryFileSystem {
     ledger;
     root;
     totalBytes = 0;
+    symlinkCount = 0;
     constructor(options = {}) {
         this.ledger = new MemoryLedger(normalizeMemoryFileSystemLimits(options));
+        memoryCaches.set(this.ledger, new MemoryCache());
         this.ledger.reserve(0, 1, "mkdir", "/");
         this.root = this.directory(0o755);
         const root = this.root;
@@ -117,16 +322,28 @@ export class MemoryFileSystem {
                 return [...node.entries.keys()];
             },
         }, () => {
-            if (Object.getPrototypeOf(this) !== MemoryFileSystem.prototype
-                || Object.getOwnPropertyDescriptor(this, "root")?.value !== root
-                || Object.getOwnPropertyDescriptor(this, "ledger")?.value !== ownedStores.get(this)?.ledger
-                || Object.getOwnPropertyDescriptor(this, "capabilities")?.value !== ownedStores.get(this)?.capabilities)
+            if (Object.getPrototypeOf(this) !== MemoryFileSystem.prototype ||
+                this.root !== root ||
+                this.ledger !== ownedStores.get(this)?.ledger ||
+                this.capabilities !== ownedStores.get(this)?.capabilities) {
                 return false;
-            return Object.entries(memoryImplementation).every(([name, expected]) => {
-                const actual = Object.getOwnPropertyDescriptor(this, name)
-                    ?? Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, name);
-                return actual?.value === expected.value && actual?.get === expected.get && actual?.set === expected.set;
-            });
+            }
+            const proto = MemoryFileSystem.prototype;
+            for (let i = 0; i < memoryImplementationKeys.length; i++) {
+                const name = memoryImplementationKeys[i];
+                const expected = memoryImplementationDescriptors[i];
+                if (Object.prototype.hasOwnProperty.call(this, name)) {
+                    const actual = Object.getOwnPropertyDescriptor(this, name);
+                    if (!actual || actual.value !== expected.value || actual.get !== expected.get || actual.set !== expected.set)
+                        return false;
+                }
+                else if (expected.get !== undefined || expected.set !== undefined || proto[name] !== expected.value) {
+                    const actual = Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, name);
+                    if (!actual || actual.value !== expected.value || actual.get !== expected.get || actual.set !== expected.set)
+                        return false;
+                }
+            }
+            return true;
         });
         if (this.compareEntry === memoryImplementation.compareEntry?.value) {
             registeredAuthorities.add(this);
@@ -138,16 +355,9 @@ export class MemoryFileSystem {
     }
     canonicalizeMissingTarget(path, options = {}) {
         options.signal?.throwIfAborted();
-        const owner = ownedStores.get(this);
-        if (!owner || Object.getPrototypeOf(this) !== MemoryFileSystem.prototype
-            || Object.getOwnPropertyDescriptor(this, "root")?.value !== owner.root)
+        if (!isStockMemoryMethods(this, missingTargetMethodNames))
             return undefined;
-        for (const name of ["realpath", "lstat", "resolve", "permission", "validatePath", "fail", "snapshot"]) {
-            const descriptor = Object.getOwnPropertyDescriptor(this, name)
-                ?? Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, name);
-            if (!descriptor || !("value" in descriptor) || descriptor.value !== memoryImplementation[name]?.value)
-                return undefined;
-        }
+        const owner = ownedStores.get(this);
         if (path !== "")
             this.validatePath(path, "realpath");
         return resolveMissingTarget(owner.root, path || ".", options.signal);
@@ -169,7 +379,8 @@ export class MemoryFileSystem {
             }
             retained.set("/", this.root);
         }
-        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", "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}/`)))
@@ -193,6 +404,8 @@ export class MemoryFileSystem {
             get: (target, property) => {
                 if (property === "objects" || property === "confineExtraction")
                     return undefined;
+                if (property === "capabilities")
+                    return capabilities;
                 const value = Reflect.get(target, property);
                 if (typeof value !== "function")
                     return value;
@@ -201,14 +414,22 @@ export class MemoryFileSystem {
                 return (...args) => {
                     if (!allowed.has(String(property)))
                         throw new FsError("ENOTSUP", { syscall: String(property) });
-                    // Stock mutations resolve and commit synchronously; writeStream retains
-                    // its file node before its first await, so later chunks cannot redirect.
-                    const paths = property === "symlink" ? [args[1]] : property === "link" || property === "rename" ? args.slice(0, 2) : [args[0]];
+                    // Stock mutations resolve and commit synchronously. Streamed writes
+                    // repeat the boundary and file-binding check at each backend mutation.
+                    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");
                         check(path, ["chmod", "utimes", "appendFile", "writeFile", "writeStream", "writeFileConditional", "link"].includes(String(property)));
                     }
+                    if (property === "writeStream") {
+                        const path = args[0];
+                        args[2] = { ...args[2], [extractionStreamGuard]: (node) => {
+                                check(path, true);
+                                if (this.resolve(path, "writeStream").node !== node)
+                                    this.fail("EPERM", "writeStream", path);
+                            } };
+                    }
                     return Reflect.apply(value, target, args);
                 };
             },
@@ -222,7 +443,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 = 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;
@@ -230,10 +483,12 @@ export class MemoryFileSystem {
         try {
             const node = create();
             if (node.type === "file")
-                this.admitSize(undefined, node.data.byteLength, syscall, path);
+                this.admitSize(undefined, node.byteLength, syscall, path);
             parent.entries.set(name, node);
             if (node.type === "file")
-                this.totalBytes += node.data.byteLength;
+                this.totalBytes += node.byteLength;
+            else if (node.type === "symlink")
+                this.symlinkCount++;
             this.changed(parent);
             return node;
         }
@@ -245,10 +500,36 @@ export class MemoryFileSystem {
     releaseNode(node) {
         if (node.nlink !== 0 || node.references !== 0)
             return;
+        const cache = memoryCaches.get(this.ledger);
         this.ledger.release(node.type === "symlink" ? node.target.length * 2 : 0, 1);
         if (node.type === "file") {
-            this.totalBytes -= node.data.byteLength;
-            node.allocation.release();
+            if (cache.lastFastFileNode === node) {
+                cache.lastFastFilePath = "";
+                cache.lastFastFileName = "";
+                cache.lastFastFileNode = undefined;
+            }
+            this.totalBytes -= node.byteLength;
+            const alloc = node.allocation;
+            node.view = undefined;
+            alloc.release();
+            if (alloc.isReleased64() && cache.allocations.length < 128) {
+                cache.allocations.push(alloc);
+            }
+            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;
+            }
+            if (node.entries.size === 0 && cache.directories.length < 32) {
+                cache.directories.push(node);
+            }
         }
     }
     releaseReference(node, path) {
@@ -258,14 +539,16 @@ export class MemoryFileSystem {
     }
     replaceData(node, allocation, length = allocation.data.byteLength) {
         const previous = node.allocation;
-        this.totalBytes += length - node.data.byteLength;
-        node.data = allocation.data.subarray(0, length);
+        this.totalBytes += length - node.byteLength;
+        node.byteLength = length;
+        node.view = length === allocation.data.byteLength ? allocation.data : undefined;
         node.allocation = allocation;
         previous.release();
     }
     admitSize(node, length, syscall, path) {
         this.ledger.fileSize(length, syscall, path);
-        if (length - (node?.data.byteLength ?? 0) > (this.ledger.limits.maxBytes ?? Number.MAX_SAFE_INTEGER) - this.totalBytes) {
+        const maxBytes = this.ledger.limits.maxBytes;
+        if (maxBytes !== undefined && length - (node?.byteLength ?? 0) > maxBytes - this.totalBytes) {
             this.fail("ENOSPC", syscall, path);
         }
     }
@@ -292,20 +575,126 @@ export class MemoryFileSystem {
         if (!Number.isSafeInteger(value) || value < 0)
             this.fail("EINVAL", syscall, path);
     }
-    changed(node) {
-        node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
-        node.mtimeMs = node.ctimeMs = Date.now();
+    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 = now;
+    }
+    resolveNode(path, syscall, followFinal = true) {
+        const cache = memoryCaches.get(this.ledger);
+        if (this.symlinkCount === 0 && isCleanAbsolutePath(path)) {
+            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);
+                if (name.length > 0 && !name.includes("/")) {
+                    this.permission(fastDir, 1, syscall, path);
+                    if (exceedsComponentByteLimit(name))
+                        this.fail("ENAMETOOLONG", syscall, path);
+                    const node = fastDir.entries.get(name);
+                    if (!node)
+                        this.fail("ENOENT", syscall, path);
+                    return node;
+                }
+            }
+            let current = this.root;
+            let start = 1;
+            while (true) {
+                this.permission(current, 1, syscall, path);
+                const slash = path.indexOf("/", start);
+                if (slash === -1) {
+                    cache.clearWrites();
+                    cache.lastFastDirPrefix = path.slice(0, start);
+                    cache.lastFastDirNode = current;
+                    const name = path.slice(start);
+                    if (exceedsComponentByteLimit(name))
+                        this.fail("ENAMETOOLONG", syscall, path);
+                    const node = current.entries.get(name);
+                    if (!node)
+                        this.fail("ENOENT", syscall, path);
+                    return node;
+                }
+                const name = path.slice(start, slash);
+                if (exceedsComponentByteLimit(name))
+                    this.fail("ENAMETOOLONG", syscall, path);
+                const next = current.entries.get(name);
+                if (!next)
+                    this.fail("ENOENT", syscall, path);
+                if (next.type !== "directory")
+                    this.fail("ENOTDIR", syscall, path);
+                current = next;
+                start = slash + 1;
+            }
+        }
+        return this.resolve(path, syscall, followFinal ? emptyResolveOptions : noFollowResolveOptions).node;
     }
-    resolve(path, syscall, options = {}) {
+    resolve(path, syscall, options = emptyResolveOptions) {
         this.validatePath(path, syscall);
+        if (this.symlinkCount === 0 && options.resizeCreate === undefined
+            && options.resolutionSteps === undefined && isCleanAbsolutePath(path)) {
+            let current = this.root;
+            let start = 1;
+            while (true) {
+                this.permission(current, 1, syscall, path);
+                const slash = path.indexOf("/", start);
+                if (slash === -1) {
+                    const name = path.slice(start);
+                    if (exceedsComponentByteLimit(name))
+                        this.fail("ENAMETOOLONG", syscall, path);
+                    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 };
+                }
+                const name = path.slice(start, slash);
+                if (exceedsComponentByteLimit(name))
+                    this.fail("ENAMETOOLONG", syscall, path);
+                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")
+                    this.fail("ENOTDIR", syscall, path);
+                current = next;
+                start = slash + 1;
+            }
+        }
         // Bound all component arrays allocated by this resolution, including cycles.
         let remainingPathUnits = 65_536 - path.length;
         if (remainingPathUnits < 0)
             this.fail("ENAMETOOLONG", syscall, path);
+        let initialComponents = 0;
+        let inComp = false;
+        for (let i = 0; i < path.length; i++) {
+            if (path.charCodeAt(i) === 47)
+                inComp = false;
+            else if (!inComp) {
+                inComp = true;
+                if (++initialComponents > 256)
+                    this.fail("ENAMETOOLONG", syscall, path);
+            }
+        }
         const pending = path.split("/").filter(Boolean);
+        let remainingComponents = 256 - pending.length;
         if (path.endsWith("/"))
             pending.push("");
         const stack = [{ node: this.root, name: "" }];
+        let recordedUnits = 0;
+        const observe = (node, entryPath) => {
+            if (!options.resolutionSteps)
+                return;
+            recordedUnits += entryPath.length + (node.type === "symlink" ? node.target.length : 0);
+            if (options.resolutionSteps.length >= 4096 || recordedUnits > 1_048_576)
+                this.fail("EFBIG", syscall, path);
+            options.resolutionSteps.push({ path: entryPath, stat: this.snapshot(node), ...(node.type === "symlink" ? { linkTarget: node.target } : {}) });
+        };
+        observe(this.root, "/");
         let links = 0;
         while (pending.length > 0) {
             const component = pending.shift();
@@ -321,7 +710,7 @@ export class MemoryFileSystem {
                     stack.pop();
                 continue;
             }
-            if (new TextEncoder().encode(component).byteLength > 255)
+            if (exceedsComponentByteLimit(component))
                 this.fail("ENAMETOOLONG", syscall, path);
             if (options.resizeCreate === true && pending.length === 1 && pending[0] === "")
                 this.fail("EISDIR", syscall, path);
@@ -337,6 +726,8 @@ export class MemoryFileSystem {
                 }
                 this.fail("ENOENT", syscall, path);
             }
+            if (options.resolutionSteps)
+                observe(node, [...stack.map(entry => entry.name), component].join("/"));
             if (node.type === "symlink" && (options.followFinal !== false || pending.length > 0)) {
                 if (++links > 40)
                     this.fail("ELOOP", syscall, path);
@@ -344,6 +735,9 @@ export class MemoryFileSystem {
                     this.fail("ENAMETOOLONG", syscall, path);
                 remainingPathUnits -= node.target.length;
                 const target = node.target.split("/").filter(Boolean);
+                if (target.length > remainingComponents)
+                    this.fail("ENAMETOOLONG", syscall, path);
+                remainingComponents -= target.length;
                 if (node.target.endsWith("/"))
                     target.push("");
                 if (options.resizeCreate !== undefined && target.at(-1) === "" && pending[0] === "")
@@ -364,6 +758,55 @@ export class MemoryFileSystem {
         };
     }
     file(path, syscall) {
+        const cache = memoryCaches.get(this.ledger);
+        if (this.symlinkCount === 0 && isCleanAbsolutePath(path)) {
+            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);
+                if (name.length > 0 && !name.includes("/")) {
+                    this.permission(fastDir, 1, syscall, path);
+                    if (exceedsComponentByteLimit(name))
+                        this.fail("ENAMETOOLONG", syscall, path);
+                    const node = fastDir.entries.get(name);
+                    if (!node)
+                        this.fail("ENOENT", syscall, path);
+                    if (node.type !== "file")
+                        this.fail("EISDIR", syscall, path);
+                    return node;
+                }
+            }
+            let current = this.root;
+            let start = 1;
+            while (true) {
+                this.permission(current, 1, syscall, path);
+                const slash = path.indexOf("/", start);
+                if (slash === -1) {
+                    cache.clearWrites();
+                    cache.lastFastDirPrefix = path.slice(0, start);
+                    cache.lastFastDirNode = current;
+                    const name = path.slice(start);
+                    if (exceedsComponentByteLimit(name))
+                        this.fail("ENAMETOOLONG", syscall, path);
+                    const node = current.entries.get(name);
+                    if (!node)
+                        this.fail("ENOENT", syscall, path);
+                    if (node.type !== "file")
+                        this.fail("EISDIR", syscall, path);
+                    return node;
+                }
+                const name = path.slice(start, slash);
+                if (exceedsComponentByteLimit(name))
+                    this.fail("ENAMETOOLONG", syscall, path);
+                const next = current.entries.get(name);
+                if (!next)
+                    this.fail("ENOENT", syscall, path);
+                if (next.type !== "directory")
+                    this.fail("ENOTDIR", syscall, path);
+                current = next;
+                start = slash + 1;
+            }
+        }
         const node = this.resolve(path, syscall).node;
         if (node.type !== "file")
             this.fail("EISDIR", syscall, path);
@@ -377,21 +820,66 @@ 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) {
+        if (node.cachedNlinkRev === node.revision && node.cachedNlink !== undefined) {
+            return node.cachedNlink;
+        }
+        let nlink = 2;
+        node.entries.forEach(entry => {
+            if (entry.type === "directory")
+                nlink++;
+        });
+        node.cachedNlinkRev = node.revision;
+        node.cachedNlink = nlink;
+        return nlink;
+    }
     snapshot(node) {
+        const hasRev = Number.isSafeInteger(node.revision);
+        const hasScope = ownedStores.get(this)?.intact() === true;
+        const size = node.type === "file" ? node.byteLength
+            : node.type === "symlink" ? new TextEncoder().encode(node.target).byteLength : 0;
+        const nlink = node.type === "directory" && node.nlink !== 0
+            ? this.directoryNlink(node) : node.nlink;
+        if (hasRev && hasScope) {
+            return {
+                type: node.type,
+                filesystemType: "memory",
+                ioBlockSize: preferredIoBlockSize,
+                revision: node.revision,
+                preferredIoBlockSize: 4096,
+                size,
+                mode: node.mode,
+                identityScope: this.identityScope,
+                ino: node.ino,
+                dev: 0,
+                uid: 0,
+                gid: 0,
+                nlink,
+                atimeMs: node.atimeMs,
+                mtimeMs: node.mtimeMs,
+                ctimeMs: node.ctimeMs,
+                birthtimeMs: node.birthtimeMs,
+            };
+        }
         return {
             type: node.type,
             filesystemType: "memory",
             ioBlockSize: preferredIoBlockSize,
-            ...(Number.isSafeInteger(node.revision) ? { revision: node.revision } : {}),
+            ...(hasRev ? { revision: node.revision } : {}),
             preferredIoBlockSize: 4096,
-            size: node.type === "file" ? node.data.byteLength
-                : node.type === "symlink" ? new TextEncoder().encode(node.target).byteLength : 0,
-            mode: node.mode, ...(ownedStores.get(this)?.intact() ? { identityScope: this.identityScope } : {}),
+            size,
+            mode: node.mode,
+            ...(hasScope ? { identityScope: this.identityScope } : {}),
             ino: node.ino, dev: 0, uid: 0, gid: 0,
-            nlink: node.type === "directory" && node.nlink !== 0
-                ? 2 + [...node.entries.values()].filter((entry) => entry.type === "directory").length : node.nlink,
+            nlink,
             atimeMs: node.atimeMs, mtimeMs: node.mtimeMs, ctimeMs: node.ctimeMs, birthtimeMs: node.birthtimeMs,
         };
     }
@@ -409,7 +897,27 @@ export class MemoryFileSystem {
     allocate(length, syscall, path) {
         this.ledger.fileSize(length, syscall, path);
         this.ledger.reserve(length, 0, syscall, path);
+        if (length === 0) {
+            return new MemoryAllocation(EMPTY_ALLOC_BYTES, this.ledger);
+        }
+        const allocations = memoryCaches.get(this.ledger).allocations;
+        if (length === 64 && allocations.length > 0) {
+            const pooled = allocations.pop();
+            pooled.reuse();
+            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) {
@@ -418,9 +926,7 @@ export class MemoryFileSystem {
         }
     }
     open(path, options) {
-        return openFileDescriptor(path, options, {
-            noFollow: true, positionedRead: true, positionedWrite: true, truncate: true, synchronization: "volatile", position: true,
-        }, async (admitted) => {
+        return openFileDescriptor(path, options, MEMORY_DESCRIPTOR_CAPABILITIES, async (admitted) => {
             const location = this.resolve(path, "open", {
                 followFinal: !admitted.noFollow && admitted.creation !== "exclusive", allowMissing: admitted.creation !== "never",
             });
@@ -448,40 +954,16 @@ export class MemoryFileSystem {
                 throw error;
             }
             node.references++;
-            const resource = { node, position: 0 };
+            const resource = { fs: this, path, append: admitted.append, node, position: 0 };
             return {
                 resource,
-                getPosition: async (retained) => retained.position,
-                stat: async (retained) => this.snapshot(retained.node),
-                read: async (retained, buffer, position) => {
-                    const inode = retained.node;
-                    const start = position ?? retained.position;
-                    const count = Math.min(buffer.byteLength, Math.max(0, inode.data.byteLength - start));
-                    buffer.set(inode.data.subarray(start, start + count));
-                    if (position === null)
-                        retained.position += count;
-                    inode.atimeMs = Date.now();
-                    return count;
-                },
-                write: async (retained, buffer, position) => {
-                    const inode = retained.node;
-                    const start = admitted.append ? inode.data.byteLength : position ?? retained.position;
-                    const end = start + buffer.byteLength;
-                    this.writeAt(inode, buffer, start, "write", path);
-                    if (position === null)
-                        retained.position = end;
-                    return buffer.byteLength;
-                },
-                truncate: async (retained, length) => {
-                    const inode = retained.node;
-                    this.resizeNode(inode, length, "ftruncate", path);
-                },
-                sync: async () => { },
-                close: async (retained) => {
-                    const inode = retained.node;
-                    retained.node = undefined;
-                    this.releaseReference(inode, path);
-                },
+                getPosition: memoryDescriptorGetPosition,
+                stat: memoryDescriptorStat,
+                read: memoryDescriptorRead,
+                write: memoryDescriptorWrite,
+                truncate: memoryDescriptorTruncate,
+                sync: memoryDescriptorSync,
+                close: memoryDescriptorClose,
             };
         });
     }
@@ -510,7 +992,8 @@ export class MemoryFileSystem {
             return location.node;
         return this.addNode(location.parent, location.name, () => {
             const allocation = new MemoryAllocation(new Uint8Array(), this.ledger);
-            return { ...this.metadata(typeModes.file | mode), type: "file", data: allocation.data, allocation };
+            const meta = this.metadata(typeModes.file | mode);
+            return new MemoryFileNode(meta.mode, meta.ino, meta.atimeMs, 0, allocation, allocation.data);
         }, syscall, path);
     }
     writeData(path, data, options, syscall) {
@@ -518,41 +1001,58 @@ export class MemoryFileSystem {
             throw new TypeError("Memory files require Uint8Array data");
         const target = this.prepareWrite(path, options, syscall);
         const current = target.location.node;
-        const length = (target.append ? current?.data.byteLength ?? 0 : 0) + data.byteLength;
+        const length = (target.append ? current?.byteLength ?? 0 : 0) + data.byteLength;
         this.admitSize(current, length, syscall, path);
         const growth = target.append && length > (current?.allocation.data.byteLength ?? 0) ? length : 0;
         this.ledger.check(data.byteLength + growth + (current ? 0 : target.location.name.length * 2), current ? 0 : 2, syscall, path);
-        const copied = this.bytes(data, syscall, path);
-        let allocation = copied;
-        let transferred = false;
-        try {
-            if (!current) {
-                if (target.append && length > 0) {
-                    const capacity = Math.min(Math.max(length, 64), this.ledger.limits.maxFileBytes, this.ledger.availableBytes - target.location.name.length * 2);
-                    allocation = this.allocate(capacity, syscall, path);
-                    allocation.data.set(copied.data);
-                }
-                const node = this.addNode(target.location.parent, target.location.name, () => ({
-                    ...this.metadata(typeModes.file | target.mode), type: "file",
-                    data: allocation.data.subarray(0, length), allocation,
-                }), syscall, path);
-                transferred = true;
-                return node;
+        if (current && target.append) {
+            this.writeAt(current, data, current.byteLength, syscall, path);
+            return current;
+        }
+        if (!current) {
+            const capacity = length > 0 && (target.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 - target.location.name.length * 2)
+                : length;
+            const allocation = this.allocate(capacity, syscall, path);
+            try {
+                allocation.data.set(data);
+                return this.addNode(target.location.parent, target.location.name, () => {
+                    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();
+                    if (pooled) {
+                        pooled.mode = fileMode;
+                        pooled.ino = this.nextInode++;
+                        pooled.nlink = 1;
+                        pooled.references = 0;
+                        pooled.revision = 0;
+                        pooled.atimeMs = now;
+                        pooled.mtimeMs = now;
+                        pooled.ctimeMs = now;
+                        pooled.birthtimeMs = now;
+                        pooled.byteLength = length;
+                        pooled.view = view;
+                        pooled.allocation = allocation;
+                        return pooled;
+                    }
+                    return new MemoryFileNode(fileMode, this.nextInode++, now, length, allocation, view);
+                }, syscall, path);
             }
-            if (target.append)
-                this.writeAt(current, copied.data, current.data.byteLength, syscall, path);
-            else {
-                this.replaceData(current, copied);
-                transferred = true;
-                this.changed(current);
+            catch (error) {
+                allocation.release();
+                throw error;
             }
+        }
+        const copied = this.bytes(data, syscall, path);
+        try {
+            this.replaceData(current, copied);
+            this.changed(current);
             return current;
         }
-        finally {
-            if (allocation !== copied && !transferred)
-                allocation.release();
-            if (!transferred || allocation !== copied)
-                copied.release();
+        catch (error) {
+            copied.release();
+            throw error;
         }
     }
     writeAt(node, data, position, syscall, path) {
@@ -562,20 +1062,27 @@ export class MemoryFileSystem {
         }
         const end = position + data.byteLength;
         this.ledger.fileSize(end, syscall, path);
-        const length = Math.max(node.data.byteLength, end);
+        const curLen = node.byteLength;
+        const length = Math.max(curLen, end);
         this.admitSize(node, length, syscall, path);
         let allocation = node.allocation;
         if (length > allocation.data.byteLength) {
             this.ledger.check(length, 0, syscall, path);
-            const capacity = Math.min(Math.max(length, node.data.byteLength * 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 {
             const storage = allocation.data;
             if (allocation !== node.allocation)
-                storage.set(node.data);
-            if (position > node.data.byteLength)
-                storage.fill(0, node.data.byteLength, position);
+                storage.set(node.view ?? (curLen === node.allocation.data.byteLength ? node.allocation.data : node.allocation.data.subarray(0, curLen)));
+            if (position > curLen)
+                storage.fill(0, curLen, position);
             storage.set(data, position);
         }
         catch (error) {
@@ -586,11 +1093,313 @@ export class MemoryFileSystem {
         if (allocation !== node.allocation)
             this.replaceData(node, allocation, length);
         else {
-            this.totalBytes += length - node.data.byteLength;
-            node.data = allocation.data.subarray(0, length);
+            this.totalBytes += length - curLen;
+            node.byteLength = length;
+            node.view = length === allocation.data.byteLength ? allocation.data : undefined;
         }
         this.changed(node);
     }
+    writeMemoryFileFast(path, data, append, mode) {
+        const cache = memoryCaches.get(this.ledger);
+        const syscall = append ? "appendFile" : "writeFile";
+        if (append &&
+            path === cache.lastFastFilePath &&
+            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, path);
+            const growth = length > current.allocation.data.byteLength ? length : 0;
+            this.ledger.check(data.byteLength + growth, 0, syscall, path);
+            this.writeAt(current, data, current.byteLength, syscall, path);
+            return;
+        }
+        let parent = this.root;
+        let start = 1;
+        let name = "";
+        const cachedPrefix = cache.lastFastDirPrefix;
+        const cachedDir = cache.lastFastDirNode;
+        if (cachedDir !== undefined &&
+            cachedDir.nlink !== 0 &&
+            (cachedDir.mode & 1) !== 0 &&
+            cachedPrefix.length > 1 &&
+            path.startsWith(cachedPrefix) &&
+            path.indexOf("/", cachedPrefix.length) === -1) {
+            parent = cachedDir;
+            name = path.slice(cachedPrefix.length);
+            if (exceedsComponentByteLimit(name))
+                this.fail("ENAMETOOLONG", syscall, path);
+        }
+        else {
+            while (true) {
+                this.permission(parent, 1, syscall, path);
+                const slash = path.indexOf("/", start);
+                if (slash === -1) {
+                    name = path.slice(start);
+                    if (exceedsComponentByteLimit(name))
+                        this.fail("ENAMETOOLONG", syscall, path);
+                    if (start > 1 && (parent.mode & 1) !== 0) {
+                        cache.lastFastDirPrefix = path.slice(0, start);
+                        cache.lastFastDirNode = parent;
+                    }
+                    break;
+                }
+                const seg = path.slice(start, slash);
+                if (exceedsComponentByteLimit(seg))
+                    this.fail("ENAMETOOLONG", syscall, path);
+                const next = parent.entries.get(seg);
+                if (!next)
+                    this.fail("ENOENT", syscall, path);
+                if (next.type !== "directory")
+                    this.fail("ENOTDIR", syscall, path);
+                parent = next;
+                start = slash + 1;
+            }
+        }
+        const existing = parent.entries.get(name);
+        if (existing) {
+            if (existing.type !== "file")
+                this.fail("EISDIR", syscall, path);
+            this.permission(existing, 2, syscall, path);
+        }
+        else {
+            this.permission(parent, 3, syscall, path);
+        }
+        const current = existing;
+        const length = (append ? current?.byteLength ?? 0 : 0) + data.byteLength;
+        this.admitSize(current, length, syscall, path);
+        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, path);
+        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;
+            const allocation = this.allocate(capacity, syscall, path);
+            try {
+                allocation.data.set(data);
+                this.ledger.reserve(nameBytes, 2, syscall, path);
+                try {
+                    const now = Date.now();
+                    const fileMode = typeModes.file | mode;
+                    const view = allocation.data;
+                    let node = 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 = path;
+                    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, path);
+        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;
+                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 = allocation.data;
+                        let node = 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)
@@ -610,19 +1419,26 @@ export class MemoryFileSystem {
         }
         if (!node)
             this.fail("EAGAIN", "fileStaging", path);
+        if (!unchanged) {
+            const currentScope = ownedStores.get(this)?.intact() ? this.identityScope : undefined;
+            if (!expected.identityScope || expected.identityScope !== currentScope
+                || !Number.isSafeInteger(expected.ino) || !Number.isSafeInteger(expected.dev))
+                this.fail("ENOTSUP", "fileStaging", path);
+            if (node.ino !== expected.ino || expected.dev !== 0 || node.type !== expected.type)
+                this.fail("EAGAIN", "fileStaging", path);
+            return;
+        }
         const current = this.snapshot(node);
         if (!expected.identityScope || expected.identityScope !== current.identityScope
             || !Number.isSafeInteger(expected.ino) || !Number.isSafeInteger(expected.dev))
             this.fail("ENOTSUP", "fileStaging", path);
         if (current.ino !== expected.ino || current.dev !== expected.dev || current.type !== expected.type)
             this.fail("EAGAIN", "fileStaging", path);
-        if (unchanged) {
-            if (!Number.isSafeInteger(expected.revision) || !Number.isSafeInteger(current.revision))
-                this.fail("ENOTSUP", "fileStaging", path);
-            if (current.revision !== expected.revision || current.size !== expected.size || current.mode !== expected.mode
-                || current.nlink !== expected.nlink || current.mtimeMs !== expected.mtimeMs || current.ctimeMs !== expected.ctimeMs)
-                this.fail("EAGAIN", "fileStaging", path);
-        }
+        if (!Number.isSafeInteger(expected.revision) || !Number.isSafeInteger(current.revision))
+            this.fail("ENOTSUP", "fileStaging", path);
+        if (current.revision !== expected.revision || current.size !== expected.size || current.mode !== expected.mode
+            || current.nlink !== expected.nlink || current.mtimeMs !== expected.mtimeMs || current.ctimeMs !== expected.ctimeMs)
+            this.fail("EAGAIN", "fileStaging", path);
     }
     stagingLocations(staging) {
         const parent = this.entry(staging.parent.path, "fileStaging");
@@ -639,7 +1455,10 @@ export class MemoryFileSystem {
         return { directory, file };
     }
     async createStagedFile(directoryPath, name, content, options) {
+        options = snapshotStagingCreation(options, directoryPath);
         options.signal?.throwIfAborted();
+        if (options.retainCleanup === true && this.capabilities.retainedStagingCleanup !== true)
+            this.fail("ENOTSUP", "createStagedFile", directoryPath);
         if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\0"))
             this.fail("EINVAL", "createStagedFile", directoryPath);
         const location = this.entry(directoryPath, "createStagedFile", true);
@@ -658,7 +1477,11 @@ export class MemoryFileSystem {
         if (content.type === "symlink")
             this.validatePath(content.target, "createStagedFile");
         const retained = (location.name.length + name.length) * 2 + (content.type === "symlink" ? content.target.length * 2 : 0);
-        this.ledger.reserve(retained, 4, "createStagedFile", directoryPath);
+        const parentPath = location.path.slice(0, location.path.lastIndexOf("/")) || "/";
+        const filePath = `${location.path}/${name}`;
+        const cleanupBytes = options.retainCleanup ? (parentPath.length + location.path.length + filePath.length) * 2 : 0;
+        const cleanupUnits = options.retainCleanup ? 3 : 0;
+        this.ledger.reserve(retained + cleanupBytes, 4 + cleanupUnits, "createStagedFile", directoryPath);
         let allocation;
         let directory;
         let file;
@@ -667,7 +1490,7 @@ export class MemoryFileSystem {
                 allocation = this.bytes(content.data, "createStagedFile", directoryPath);
             directory = this.directory(0o700);
             file = content.type === "file"
-                ? { ...this.metadata(typeModes.file | mode), type: "file", data: allocation.data, allocation: allocation }
+                ? (() => { const m = this.metadata(typeModes.file | mode); return new MemoryFileNode(m.mode, m.ino, m.atimeMs, allocation.data.byteLength, allocation, allocation.data); })()
                 : { ...this.metadata(typeModes.symlink | mode), type: "symlink", target: content.target };
             if (options.atimeMs !== undefined)
                 file.atimeMs = options.atimeMs;
@@ -677,52 +1500,153 @@ 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();
-            this.ledger.release(retained, 4);
+            this.ledger.release(retained + cleanupBytes, 4 + cleanupUnits);
             throw error;
         }
         this.changed(location.parent);
-        const parentPath = location.path.slice(0, location.path.lastIndexOf("/")) || "/";
         const receipt = (path, node) => Object.freeze({ path, stat: Object.freeze(this.snapshot(node)) });
-        return Object.freeze({ parent: receipt(parentPath, location.parent), directory: receipt(location.path, directory), file: receipt(`${location.path}/${name}`, file) });
+        const staging = Object.freeze({ parent: receipt(parentPath, location.parent), directory: receipt(location.path, directory), file: receipt(filePath, file) });
+        if (!options.retainCleanup)
+            return staging;
+        // Reservations above include these references before either entry is exposed.
+        location.parent.references++;
+        directory.references++;
+        file.references++;
+        return Object.freeze({ ...staging, cleanup: 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 => {
+            options.signal?.throwIfAborted();
+            const state = retained;
+            if (state.parent.nlink === 0 || state.parent.entries.get(directoryName) !== state.directory)
+                this.fail("EAGAIN", "removeStagedFile", staging.directory.path);
+            this.expectEntry(state.parent, staging.parent.stat, staging.parent.path, false);
+            this.expectEntry(state.directory, staging.directory.stat, staging.directory.path, false);
+            if ((state.directory.mode & 0o777) !== 0o700)
+                this.fail("EAGAIN", "removeStagedFile", staging.directory.path);
+            const child = state.directory.entries.get(fileName);
+            if (child && child !== state.file)
+                this.fail("EAGAIN", "removeStagedFile", staging.file.path);
+            this.removeStagingLocations(staging, {
+                node: state.directory, parent: state.parent, name: directoryName, path: staging.directory.path,
+            }, { node: child, parent: state.directory, name: fileName, path: staging.file.path });
+        }, () => {
+            const state = retained;
+            retained = undefined;
+            this.releaseReference(state.file, staging.file.path);
+            this.releaseReference(state.directory, staging.directory.path);
+            this.releaseReference(state.parent, staging.parent.path);
+        });
     }
-    async publishStagedFile(staging, destination, options) {
-        options.signal?.throwIfAborted();
-        if (options.ancestors) {
-            let path = "/";
-            const parentPath = destination.slice(0, destination.lastIndexOf("/")) || "/";
-            const paths = ["/", ...parentPath.split("/").filter(Boolean).map(component => {
-                    path = path === "/" ? `/${component}` : `${path}/${component}`;
-                    return path;
-                })];
-            if (paths.length !== options.ancestors.length)
-                this.fail("EINVAL", "publishStagedFile", destination);
-            for (let index = 0; index < paths.length; index++) {
-                const expected = options.ancestors[index];
-                if (expected.path !== paths[index])
-                    this.fail("EINVAL", "publishStagedFile", destination);
-                const entry = this.entry(expected.path, "publishStagedFile");
-                if (entry.node?.type !== "directory")
-                    this.fail("EAGAIN", "publishStagedFile", destination);
-                this.expectEntry(entry.node, expected.stat, expected.path, false);
+    async prepareDirectoryAncestry(ancestors, options = {}) {
+        const entries = snapshotDirectoryAncestry(ancestors);
+        const controls = options.signal === undefined ? {} : { signal: options.signal };
+        controls.signal?.throwIfAborted();
+        return () => this.verifyDirectoryAncestry(entries, controls);
+    }
+    async prepareStagingResolution(path, options = {}) {
+        const controls = options.signal === undefined ? {} : { signal: options.signal };
+        controls.signal?.throwIfAborted();
+        this.validatePath(path, "prepareStagingResolution");
+        if (!path.startsWith("/") || normalizePath(path) !== path)
+            this.fail("EINVAL", "prepareStagingResolution", path);
+        const traversed = [];
+        const location = this.resolve(path, "prepareStagingResolution", { followFinal: false, allowMissing: true, resolutionSteps: traversed });
+        if (location.node && location.node.type !== "file")
+            this.fail("ENOTSUP", "prepareStagingResolution", path);
+        const parentPath = location.path.slice(0, location.path.lastIndexOf("/")) || "/";
+        const ancestors = snapshotDirectoryAncestry(directoryAncestryPaths(parentPath).map(entryPath => ({
+            path: entryPath, stat: this.snapshot(this.entry(entryPath, "prepareStagingResolution").node),
+        })));
+        const steps = traversed.map(entry => ({ ...entry, stat: { ...entry.stat } }));
+        const canonical = location.path;
+        const destination = location.node ? this.snapshot(location.node) : null;
+        const validate = () => {
+            controls.signal?.throwIfAborted();
+            const currentSteps = [];
+            let current;
+            try {
+                current = this.resolve(path, "verifyStagingResolution", { followFinal: false, allowMissing: true, resolutionSteps: currentSteps });
+            }
+            catch (error) {
+                if (error instanceof FsError && ["ENOENT", "ENOTDIR", "ELOOP"].includes(error.code))
+                    this.fail("EAGAIN", "verifyStagingResolution", path);
+                throw error;
             }
+            if (current.path !== canonical || steps.length !== currentSteps.length)
+                this.fail("EAGAIN", "verifyStagingResolution", path);
+            for (const [index, before] of steps.entries()) {
+                const after = currentSteps[index];
+                if (before.path !== after.path || before.linkTarget !== after.linkTarget || before.stat.type !== after.stat.type
+                    || compareIdentity(before.stat, after.stat) !== "same"
+                    || before.stat.type !== "directory" && ["revision", "size", "mode", "nlink", "mtimeMs", "ctimeMs"].some(field => before.stat[field] !== after.stat[field])) {
+                    this.fail("EAGAIN", "verifyStagingResolution", before.path);
+                }
+            }
+            this.expectEntry(current.node, destination, path);
+            return this.verifyDirectoryAncestry(ancestors, controls);
+        };
+        return snapshotStagingResolution({ path: canonical, parent: this.snapshot(location.parent), destination, ancestors, traversed: steps, validate });
+    }
+    verifyDirectoryAncestry(ancestors, options) {
+        const entries = snapshotDirectoryAncestry(ancestors);
+        options.signal?.throwIfAborted();
+        let node = this.root;
+        for (const [index, expected] of entries.entries()) {
+            if (index > 0)
+                node = node.entries.get(expected.path.slice(expected.path.lastIndexOf("/") + 1));
+            if (node?.type !== "directory")
+                this.fail("EAGAIN", "verifyDirectoryAncestry", expected.path);
+            this.expectEntry(node, expected.stat, expected.path, false);
+            this.permission(node, 1, "verifyDirectoryAncestry", expected.path);
         }
+        return true;
+    }
+    async publishStagedFile(receipt, destination, options) {
+        const signal = options.signal;
+        const guard = options.commitGuard;
+        const ancestors = options.ancestors === undefined ? undefined : snapshotDirectoryAncestry(options.ancestors);
+        const snapshot = (entry) => ({ path: entry.path, stat: { ...entry.stat } });
+        const staging = { parent: snapshot(receipt.parent), directory: snapshot(receipt.directory), file: snapshot(receipt.file) };
+        const parent = { ...options.parent };
+        const expected = options.destination === null ? null : { ...options.destination };
+        const parentPath = destination.slice(0, destination.lastIndexOf("/")) || "/";
+        if (ancestors && ancestors.at(-1)?.path !== parentPath)
+            this.fail("EINVAL", "publishStagedFile", destination);
+        const controls = signal === undefined ? {} : { signal };
+        signal?.throwIfAborted();
+        if (guard !== undefined)
+            runStagingGuard(guard);
+        signal?.throwIfAborted();
+        // All inputs were copied before the guard. Neither outer validation nor
+        // these local checks yield before the stock rename commits.
+        if (ancestors)
+            runStagingGuard(() => this.verifyDirectoryAncestry(ancestors, controls));
         const { directory, file } = this.stagingLocations(staging);
         this.expectEntry(file.node, staging.file.stat, staging.file.path);
         const target = this.entry(destination, "publishStagedFile", true);
-        this.expectEntry(target.parent, options.parent, destination, false);
-        this.expectEntry(target.node, options.destination, destination);
+        this.expectEntry(target.parent, parent, destination, false);
+        this.expectEntry(target.node, expected, destination);
         if (target.parent === directory.node || target.node === directory.node || target.node === file.node)
             this.fail("EINVAL", "publishStagedFile", destination);
-        if (target.node && (target.node.type !== "file" || target.node.nlink !== 1))
+        if (target.node && target.node.type !== "file")
             this.fail("EAGAIN", "publishStagedFile", destination);
-        return MemoryFileSystem.prototype.rename.call(this, staging.file.path, destination, { ...options, noReplace: options.destination === null });
+        return MemoryFileSystem.prototype.rename.call(this, staging.file.path, destination, { ...controls, noReplace: expected === null });
     }
     async removeStagedFile(staging, options = {}) {
         options.signal?.throwIfAborted();
         const { directory, file } = this.stagingLocations(staging);
+        this.removeStagingLocations(staging, directory, file);
+    }
+    removeStagingLocations(staging, directory, file) {
         if (file.node)
             this.expectEntry(file.node, staging.file.stat, staging.file.path);
         const node = directory.node;
@@ -762,8 +1686,10 @@ export class MemoryFileSystem {
         }
         if (node.type !== "directory")
             this.fail("ENOTDIR", "prepareDirectory", path);
-        if (mode !== undefined)
+        if (mode !== undefined) {
             node.mode = typeModes.directory | mode;
+            memoryCaches.get(this.ledger).clearWrites();
+        }
         if (options.atimeMs !== undefined)
             node.atimeMs = options.atimeMs;
         if (options.mtimeMs !== undefined)
@@ -779,11 +1705,20 @@ export class MemoryFileSystem {
         this.expectEntry(location.node, options.expected, path);
         if (location.node && location.node.type !== "file")
             this.fail("EINVAL", "writeFileConditional", path);
-        this.writeData(path, data, { ...(options.mode === undefined ? {} : { mode: options.mode }), flag: options.append ? "a" : "w" }, "writeFileConditional");
-        return Object.freeze(this.snapshot(location.parent.entries.get(location.name)));
+        if (options.atimeMs !== undefined)
+            this.integer(options.atimeMs, "writeFileConditional", path);
+        if (options.mtimeMs !== undefined)
+            this.integer(options.mtimeMs, "writeFileConditional", path);
+        const node = this.writeData(path, data, { ...(options.mode === undefined ? {} : { mode: options.mode }), flag: options.append ? "a" : "w" }, "writeFileConditional");
+        if (options.atimeMs !== undefined)
+            node.atimeMs = options.atimeMs;
+        if (options.mtimeMs !== undefined)
+            node.mtimeMs = options.mtimeMs;
+        return Object.freeze(this.snapshot(node));
     }
     async removeEntryConditional(path, options) {
         options.signal?.throwIfAborted();
+        const returnRemainingStat = options.returnRemainingStat === true;
         const location = this.entry(path, "removeEntryConditional", true);
         this.expectEntry(location.parent, options.parent, path, false);
         this.expectEntry(location.node, options.expected, path);
@@ -798,12 +1733,15 @@ export class MemoryFileSystem {
         if (node.type === "directory" && node.entries.size > 0)
             this.fail("ENOTEMPTY", "removeEntryConditional", path);
         location.parent.entries.delete(location.name);
+        memoryCaches.get(this.ledger).clearWrites();
         this.ledger.release(location.name.length * 2, 1);
         node.nlink--;
         node.ctimeMs = Date.now();
         node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
         this.releaseNode(node);
         this.changed(location.parent);
+        if (returnRemainingStat)
+            return Object.freeze(this.snapshot(node));
     }
     async removeFileConditional(path, options) {
         options.signal?.throwIfAborted();
@@ -815,6 +1753,7 @@ export class MemoryFileSystem {
             this.fail("EINVAL", "removeFileConditional", path);
         this.permission(location.parent, 3, "removeFileConditional", path);
         location.parent.entries.delete(location.name);
+        memoryCaches.get(this.ledger).clearWrites();
         this.ledger.release(location.name.length * 2, 1);
         node.nlink--;
         node.ctimeMs = Date.now();
@@ -841,40 +1780,50 @@ export class MemoryFileSystem {
     }
     async stat(path, options = {}) {
         options.signal?.throwIfAborted();
-        return this.snapshot(this.resolve(path, "stat").node);
+        return this.snapshot(this.resolveNode(path, "stat", true));
     }
     async lstat(path, options = {}) {
         options.signal?.throwIfAborted();
-        const stat = this.snapshot(this.resolve(path, "lstat", { followFinal: false }).node);
+        const stat = this.snapshot(this.resolveNode(path, "lstat", false));
         ownedStats.set(stat, { filesystem: this, path, root: this.root });
         return stat;
     }
     async readdir(path, options = {}) {
         const limit = directoryEntryLimit(options, path);
-        const node = this.resolve(path, "readdir").node;
+        const node = this.resolveNode(path, "readdir", true);
         if (node.type !== "directory")
             this.fail("ENOTDIR", "readdir", path);
         this.permission(node, 4, "readdir", path);
         admitDirectoryEntries(node.entries.size, limit, path);
         node.atimeMs = Date.now();
-        return [...node.entries].map(([name, entry]) => ({ name, type: entry.type }))
-            .sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+        const result = new Array(node.entries.size);
+        let idx = 0;
+        for (const [name, entry] of node.entries) {
+            result[idx++] = { name, type: entry.type };
+        }
+        return result.sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
     }
-    async mkdir(path, options = {}) {
-        options.signal?.throwIfAborted();
-        this.validatePath(path, "mkdir");
-        const mode = this.mode(options.mode, 0o777, "mkdir", path);
-        if (options.recursive) {
-            const node = this.resolve(path, "mkdir", { createDirectories: mode }).node;
-            if (node.type !== "directory")
+    mkdir(path, options = {}) {
+        try {
+            options.signal?.throwIfAborted();
+            this.validatePath(path, "mkdir");
+            const mode = this.mode(options.mode, 0o777, "mkdir", path);
+            if (options.recursive) {
+                const node = this.resolve(path, "mkdir", { createDirectories: mode }).node;
+                if (node.type !== "directory")
+                    this.fail("EEXIST", "mkdir", path);
+                return resolvedVoid;
+            }
+            const location = this.resolve(path.replace(/\/+$/, "") || "/", "mkdir", { allowMissing: true, followFinal: false });
+            if (location.node)
                 this.fail("EEXIST", "mkdir", path);
-            return;
+            this.permission(location.parent, 3, "mkdir", path);
+            this.addNode(location.parent, location.name, () => this.directory(mode), "mkdir", path);
+            return resolvedVoid;
+        }
+        catch (error) {
+            return Promise.reject(error);
         }
-        const location = this.resolve(path.replace(/\/+$/, "") || "/", "mkdir", { allowMissing: true, followFinal: false });
-        if (location.node)
-            this.fail("EEXIST", "mkdir", path);
-        this.permission(location.parent, 3, "mkdir", path);
-        this.addNode(location.parent, location.name, () => this.directory(mode), "mkdir", path);
     }
     async rmdir(path, options = {}) {
         options.signal?.throwIfAborted();
@@ -897,18 +1846,38 @@ export class MemoryFileSystem {
         this.releaseNode(node);
         this.changed(location.parent);
     }
-    async rm(path, options = {}) {
-        options.signal?.throwIfAborted();
-        let location;
+    rm(path, options = {}) {
         try {
-            location = this.entry(path, "rm");
+            options.signal?.throwIfAborted();
+            const bound = activeConditionalMutations.get(this.identityScope);
+            const active = bound?.path === path ? bound : undefined;
+            const ancestors = options.ancestors ?? active?.ancestors;
+            const expectedParent = options.parent ?? active?.parent;
+            const expectedNode = options.expected ?? active?.expected;
+            if (ancestors !== undefined)
+                this.verifyDirectoryAncestry(ancestors, options);
+            let location;
+            try {
+                location = this.entry(path, "rm", expectedNode !== undefined || expectedParent !== undefined);
+            }
+            catch (error) {
+                if (options.force && error instanceof FsError && error.code === "ENOENT")
+                    return resolvedVoid;
+                throw error;
+            }
+            if (expectedParent !== undefined)
+                this.expectEntry(location.parent, expectedParent, path, false);
+            if (expectedNode !== undefined) {
+                if (options.force && !location.node)
+                    return resolvedVoid;
+                this.expectEntry(location.node, expectedNode, path, location.node?.type !== "directory");
+            }
+            this.removeLocation(location, path, "rm", options.recursive === true);
+            return resolvedVoid;
         }
         catch (error) {
-            if (options.force && error instanceof FsError && error.code === "ENOENT")
-                return;
-            throw error;
+            return Promise.reject(error);
         }
-        this.removeLocation(location, path, "rm", options.recursive === true);
     }
     removeLocation(location, path, syscall, recursive) {
         const node = location.node;
@@ -919,28 +1888,40 @@ export class MemoryFileSystem {
         this.permission(location.parent, 3, syscall, path);
         if (node.type === "directory" && !recursive)
             this.fail("EISDIR", syscall, path);
-        const removed = [node];
+        const cache = memoryCaches.get(this.ledger);
+        cache.clearWrites();
+        const removed = cache.removedScratch;
+        removed.length = 0;
+        removed.push(node);
+        let keyChars = 0;
+        let keyEntries = 0;
         for (let index = 0; index < removed.length; index++) {
             const entry = removed[index];
             if (entry.type === "directory" && entry.entries.size > 0) {
                 this.permission(entry, 7, syscall, path);
-                for (const child of entry.entries.values())
+                for (const [name, child] of entry.entries) {
                     removed.push(child);
+                    keyChars += name.length;
+                    keyEntries++;
+                }
             }
         }
         location.parent.entries.delete(location.name);
-        this.ledger.release(location.name.length * 2, 1);
-        for (const entry of removed) {
+        this.ledger.release((location.name.length + keyChars) * 2, 1 + keyEntries);
+        const now = Date.now();
+        for (let i = 0; i < removed.length; i++) {
+            const entry = removed[i];
             if (entry.type === "directory") {
-                for (const name of entry.entries.keys())
-                    this.ledger.release(name.length * 2, 1);
                 entry.entries.clear();
             }
             entry.nlink--;
-            entry.ctimeMs = Date.now();
-            entry.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, entry.revision + 1);
+            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);
         }
+        removed.length = 0;
         this.changed(location.parent);
     }
     unlink(path, options = {}) {
@@ -984,6 +1965,7 @@ export class MemoryFileSystem {
                 this.ledger.release(Math.max(0, nameGrowth), 0);
                 throw error;
             }
+            memoryCaches.get(this.ledger).clearWrites();
             origin.parent.entries.delete(origin.name);
             if (target.node) {
                 this.ledger.release(origin.name.length * 2, 1);
@@ -1029,11 +2011,17 @@ export class MemoryFileSystem {
         options.signal?.throwIfAborted();
         return this.resolve(path, "realpath").path;
     }
-    async access(path, mode = 0, options = {}) {
-        options.signal?.throwIfAborted();
-        if (!Number.isInteger(mode) || mode < 0 || mode > 7)
-            this.fail("EINVAL", "access", path);
-        this.permission(this.resolve(path, "access").node, mode, "access", path);
+    access(path, mode = 0, options = {}) {
+        try {
+            options.signal?.throwIfAborted();
+            if (!Number.isInteger(mode) || mode < 0 || mode > 7)
+                this.fail("EINVAL", "access", path);
+            this.permission(this.resolveNode(path, "access", true), mode, "access", path);
+            return resolvedVoid;
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
     }
     async readlink(path, options = {}) {
         options.signal?.throwIfAborted();
@@ -1078,7 +2066,28 @@ export class MemoryFileSystem {
     async chmod(path, mode, options = {}) {
         options.signal?.throwIfAborted();
         const permissions = this.mode(mode, 0, "chmod", path);
-        const node = this.resolve(path, "chmod").node;
+        const bound = activeConditionalMutations.get(this.identityScope);
+        const active = bound?.path === path ? bound : undefined;
+        const conditional = snapshotConditionalChmod(path, active ? { ...active, ...options } : options);
+        const controls = conditional ?? options;
+        const ancestors = conditional?.ancestors;
+        const expectedParent = conditional?.parent;
+        const expectedNode = conditional?.expected;
+        if (conditional?.commitGuard)
+            runStagingGuard(conditional.commitGuard);
+        controls.signal?.throwIfAborted();
+        if (ancestors !== undefined)
+            this.verifyDirectoryAncestry(ancestors, controls);
+        const location = expectedNode !== undefined || expectedParent !== undefined
+            ? this.entry(path, "chmod", true)
+            : this.resolve(path, "chmod");
+        if (expectedParent !== undefined)
+            this.expectEntry(location.parent, expectedParent, path, false);
+        if (expectedNode !== undefined)
+            this.expectEntry(location.node, expectedNode, path, location.node?.type !== "directory");
+        const node = location.node;
+        if (node.type === "directory")
+            memoryCaches.get(this.ledger).clearWrites();
         node.mode = typeModes[node.type] | permissions;
         node.ctimeMs = Date.now();
         node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
@@ -1239,39 +2248,8 @@ export class MemoryFileSystem {
             },
         };
     }
-    async *readStream(path, options = {}) {
-        options.signal?.throwIfAborted();
-        const start = options.start ?? 0;
-        const 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 node = this.file(path, "readStream");
-        this.permission(node, 4, "readStream", path);
-        this.ledger.reserve(path.length * 2, 1, "readStream", path);
-        node.references++;
-        const allocation = node.allocation;
-        allocation.retain();
-        const data = node.data;
-        try {
-            const end = Math.min(options.endExclusive ?? data.byteLength, data.byteLength);
-            node.atimeMs = Date.now();
-            for (let offset = start; offset < end; offset += chunkSize) {
-                options.signal?.throwIfAborted();
-                yield data.slice(offset, Math.min(offset + chunkSize, end));
-            }
-            options.signal?.throwIfAborted();
-        }
-        finally {
-            allocation.release();
-            this.releaseReference(node, path);
-        }
+    readStream(path, options = {}) {
+        return new MemoryReadStream(this, path, options);
     }
     async writeStream(path, source, options = {}) {
         options.signal?.throwIfAborted();
@@ -1280,7 +2258,9 @@ export class MemoryFileSystem {
         let node;
         try {
             node = this.openWrite(path, options, "writeStream");
+            const guard = options[extractionStreamGuard];
             node.references++;
+            guard?.(node);
             const append = options.flag === "a" || options.flag === "ax";
             let position = 0;
             if (!append) {
@@ -1289,6 +2269,7 @@ export class MemoryFileSystem {
             }
             for await (const chunk of source) {
                 options.signal?.throwIfAborted();
+                guard?.(node);
                 if (!(chunk instanceof Uint8Array))
                     throw new TypeError("Memory files require Uint8Array data");
                 this.writeAt(node, chunk, append ? node.data.byteLength : position, "writeStream", path);
@@ -1306,37 +2287,407 @@ export class MemoryFileSystem {
     }
 }
 const memoryImplementation = Object.getOwnPropertyDescriptors(MemoryFileSystem.prototype);
+const memoryImplementationKeys = Object.keys(memoryImplementation);
+const memoryImplementationDescriptors = memoryImplementationKeys.map(key => memoryImplementation[key]);
+const MEMORY_DESCRIPTOR_CAPABILITIES = Object.freeze({
+    noFollow: true, positionedRead: true, positionedWrite: true, truncate: true, synchronization: "volatile", position: true,
+});
+const memoryDescriptorGetPosition = async (retained) => retained.position;
+const memoryDescriptorStat = async (retained) => retained.fs.snapshot(retained.node);
+const memoryDescriptorRead = async (retained, buffer, position) => {
+    const inode = retained.node;
+    const start = position ?? retained.position;
+    const count = Math.min(buffer.byteLength, Math.max(0, inode.data.byteLength - start));
+    buffer.set(inode.data.subarray(start, start + count));
+    if (position === null)
+        retained.position += count;
+    inode.atimeMs = Date.now();
+    return count;
+};
+const memoryDescriptorWrite = async (retained, buffer, position) => {
+    const inode = retained.node;
+    const start = retained.append ? inode.data.byteLength : position ?? retained.position;
+    const end = start + buffer.byteLength;
+    retained.fs.writeAt(inode, buffer, start, "write", retained.path);
+    if (position === null)
+        retained.position = end;
+    return buffer.byteLength;
+};
+const memoryDescriptorTruncate = async (retained, length) => {
+    retained.fs.resizeNode(retained.node, length, "ftruncate", retained.path);
+};
+const memoryDescriptorSync = async () => { };
+const memoryDescriptorClose = async (retained) => {
+    const inode = retained.node;
+    retained.node = undefined;
+    retained.fs.releaseReference(inode, retained.path);
+};
+const stockDescriptorWriteMethodNames = [
+    "writeStream", "writeFile", "appendFile", "access", "stat", "lstat", "realpath",
+    "openWrite", "prepareWrite", "writeData", "addNode", "replaceData", "releaseReference", "releaseNode",
+    "resolve", "permission", "validatePath", "mode", "bytes", "allocate", "admitSize", "changed", "metadata", "integer", "writeAt", "fail",
+];
+const stockRetainedResizeMethodNames = [
+    "openResizeFile", "truncate", "resizeNode", "snapshot",
+];
 function stockDescriptorWrite(filesystem) {
-    if (Object.getPrototypeOf(filesystem) !== MemoryFileSystem.prototype)
+    if (!isStockMemoryMethods(filesystem, stockDescriptorWriteMethodNames, true))
         return false;
     const owner = ownedStores.get(filesystem);
-    if (!owner || Object.getOwnPropertyDescriptor(filesystem, "root")?.value !== owner.root
-        || Object.getOwnPropertyDescriptor(filesystem, "capabilities")?.value !== owner.capabilities)
+    const capDesc = Object.getOwnPropertyDescriptor(filesystem, "capabilities");
+    return !!capDesc && "value" in capDesc && capDesc.value === owner.capabilities;
+}
+function stockRetainedResize(filesystem) {
+    if (!stockDescriptorWrite(filesystem) || !isStockMemoryMethods(filesystem, stockRetainedResizeMethodNames, false))
         return false;
-    for (const name of ["writeStream", "writeFile", "appendFile", "access", "stat", "lstat", "realpath",
-        "openWrite", "prepareWrite", "writeData", "addNode", "replaceData", "releaseReference", "releaseNode",
-        "resolve", "permission", "validatePath", "mode", "bytes", "allocate", "admitSize", "changed", "metadata", "integer", "writeAt", "fail"]) {
-        const descriptor = Object.getOwnPropertyDescriptor(filesystem, name)
-            ?? Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, name);
-        if (!descriptor || !("value" in descriptor) || descriptor.value !== memoryImplementation[name]?.value)
+    const owner = ownedStores.get(filesystem);
+    const ledgerDesc = Object.getOwnPropertyDescriptor(filesystem, "ledger");
+    return !!ledgerDesc && "value" in ledgerDesc && ledgerDesc.value === owner.ledger;
+}
+export function createMemoryFileSystem(options = {}) {
+    return new MemoryFileSystem(options);
+}
+const missingTargetMethodNames = ["realpath", "lstat", "resolve", "permission", "validatePath", "fail", "snapshot"];
+const deviceFastMethodNames = ["lstat", "readlink", "resolve", "permission", "validatePath", "fail", "snapshot"];
+const readFileFastMethodNames = ["readFile", "file", "resolve", "permission", "validatePath", "fail", "integer"];
+const writeFileFastMethodNames = [
+    "writeFile", "appendFile", "writeData", "prepareWrite", "openWrite", "writeAt",
+    "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++) {
+        const code = value.charCodeAt(i);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && i + 1 < value.length && value.charCodeAt(i + 1) >= 0xdc00 && value.charCodeAt(i + 1) <= 0xdfff) {
+            bytes += 4;
+            i++;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
+function exceedsComponentByteLimit(value) {
+    return value.length > 85 && (value.length > 255 || utf8ByteLength(value) > 255);
+}
+export function isCleanAbsolutePath(path) {
+    const len = path.length;
+    if (len <= 1 || len > 65536 || path.charCodeAt(0) !== 47 || path.charCodeAt(len - 1) === 47)
+        return false;
+    let segStart = 1;
+    let components = 1;
+    for (let i = 1; i < len; i++) {
+        const c = path.charCodeAt(i);
+        if (c === 0)
             return false;
+        if (c === 47) {
+            const segLen = i - segStart;
+            if (segLen === 0)
+                return false;
+            if (segLen === 1 && path.charCodeAt(segStart) === 46)
+                return false;
+            if (segLen === 2 && path.charCodeAt(segStart) === 46 && path.charCodeAt(segStart + 1) === 46)
+                return false;
+            if (++components > 256)
+                return false;
+            segStart = i + 1;
+        }
     }
+    const lastLen = len - segStart;
+    if (lastLen === 1 && path.charCodeAt(segStart) === 46)
+        return false;
+    if (lastLen === 2 && path.charCodeAt(segStart) === 46 && path.charCodeAt(segStart + 1) === 46)
+        return false;
     return true;
 }
-function stockRetainedResize(filesystem) {
-    if (!stockDescriptorWrite(filesystem))
+export function tryResolveMemoryDevicePath(filesystem, path, resizeCreate) {
+    const mem = filesystem;
+    if (!ownedStores.has(mem) || mem.symlinkCount !== 0 || !isStockMemoryMethods(mem, deviceFastMethodNames, false))
+        return undefined;
+    if (!isCleanAbsolutePath(path) || path === "/dev" || path.startsWith("/dev/"))
+        return undefined;
+    let current = mem.root;
+    let start = 1;
+    while (true) {
+        if (((current.mode >> 6) & 1) !== 1)
+            return undefined;
+        const slash = path.indexOf("/", start);
+        if (slash === -1) {
+            const name = path.slice(start);
+            if (exceedsComponentByteLimit(name))
+                return undefined;
+            if (resizeCreate === false && !current.entries.has(name))
+                return undefined;
+            return path;
+        }
+        const name = path.slice(start, slash);
+        if (exceedsComponentByteLimit(name))
+            return undefined;
+        const next = current.entries.get(name);
+        if (!next) {
+            if (resizeCreate !== undefined)
+                return undefined;
+            let remStart = slash + 1;
+            while (true) {
+                const nextSlash = path.indexOf("/", remStart);
+                const seg = nextSlash === -1 ? path.slice(remStart) : path.slice(remStart, nextSlash);
+                if (exceedsComponentByteLimit(seg))
+                    return undefined;
+                if (nextSlash === -1)
+                    return path;
+                remStart = nextSlash + 1;
+            }
+        }
+        if (next.type !== "directory")
+            return undefined;
+        current = next;
+        start = slash + 1;
+    }
+}
+function isStockMemoryMethods(mem, names, checkRootAccessor = true) {
+    const owner = ownedStores.get(mem);
+    if (!owner || Object.getPrototypeOf(mem) !== MemoryFileSystem.prototype)
         return false;
-    const owner = ownedStores.get(filesystem);
-    if (!owner || Object.getOwnPropertyDescriptor(filesystem, "ledger")?.value !== owner.ledger)
+    if (checkRootAccessor) {
+        const rootDesc = Object.getOwnPropertyDescriptor(mem, "root");
+        if (!rootDesc || !("value" in rootDesc) || rootDesc.value !== owner.root)
+            return false;
+    }
+    else if (mem.root !== owner.root) {
         return false;
-    for (const name of ["openResizeFile", "truncate", "resizeNode", "snapshot"]) {
-        const descriptor = Object.getOwnPropertyDescriptor(filesystem, name)
-            ?? Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, name);
-        if (!descriptor || !("value" in descriptor) || descriptor.value !== memoryImplementation[name]?.value)
+    }
+    for (let i = 0; i < names.length; i++) {
+        const name = names[i];
+        if (Object.prototype.hasOwnProperty.call(mem, name)) {
+            const descriptor = Object.getOwnPropertyDescriptor(mem, name);
+            if (!descriptor || !("value" in descriptor) || descriptor.value !== memoryImplementation[name]?.value)
+                return false;
+        }
+        else if (MemoryFileSystem.prototype[name] !== memoryImplementation[name]?.value) {
             return false;
+        }
     }
     return true;
 }
-export function createMemoryFileSystem(options = {}) {
-    return new MemoryFileSystem(options);
+export function tryReadMemoryFileViewSync(filesystem, path, maxBytes, signal) {
+    const mem = filesystem;
+    if (!ownedStores.has(mem) || !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)
+        mem.fail("EFBIG", "readFile", path);
+    node.atimeMs = Date.now();
+    return node.data;
+}
+export function tryGetMemoryDirectoryEntryNamesSync(filesystem, path) {
+    const mem = filesystem;
+    if (!ownedStores.has(mem) || mem.symlinkCount !== 0 || !isStockMemoryMethods(mem, readFileFastMethodNames, false))
+        return undefined;
+    const root = mem.root;
+    if (path === "/") {
+        if (((root.mode >> 6) & 4) !== 4)
+            return undefined;
+        return root.entries;
+    }
+    if (!isCleanAbsolutePath(path) || path === "/dev" || path.startsWith("/dev/"))
+        return undefined;
+    let current = root;
+    let start = 1;
+    while (true) {
+        if (((current.mode >> 6) & 1) !== 1)
+            return undefined;
+        const slash = path.indexOf("/", start);
+        if (slash === -1) {
+            const next = current.entries.get(path.slice(start));
+            if (!next || next.type !== "directory" || ((next.mode >> 6) & 4) !== 4)
+                return undefined;
+            return next.entries;
+        }
+        const next = current.entries.get(path.slice(start, slash));
+        if (!next || next.type !== "directory")
+            return undefined;
+        current = next;
+        start = slash + 1;
+    }
+}
+export function tryWriteMemoryFileSync(filesystem, path, 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) ||
+        !isCleanAbsolutePath(path) ||
+        path === "/dev" ||
+        path.startsWith("/dev/")) {
+        return false;
+    }
+    signal?.throwIfAborted();
+    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;
 }