@kamilio/wire 0.1.9 → 0.1.11

package/node_modules/toolcraft/node_modules/@poe-code/safe-fs/dist/fs/memory/index.js

@@ -0,0 +1,3862 @@
+import { FsError } from "../../contracts/errors.js";
+import { normalizePath, validatePath, pathByteLength } 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 { registerLazyMemoryAtomicView } 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, sourceRef) {
+        this.revision = 0;
+        this.mode = mode;
+        this.ino = ino;
+        this.nlink = 1;
+        this.atimeMs = now;
+        this.mtimeMs = now;
+        this.ctimeMs = now;
+        this.birthtimeMs = now;
+        this.references = 0;
+        this.byteLength = byteLength;
+        this.allocation = allocation;
+        this.view = view;
+        this.sourceRef = sourceRef;
+    }
+    get data() {
+        return this.view ??= (this.byteLength === this.allocation.data.byteLength ? this.allocation.data : this.allocation.data.subarray(0, this.byteLength));
+    }
+    set data(value) {
+        this.view = value;
+        this.byteLength = value.byteLength;
+    }
+}
+Object.assign(MemoryFileNode.prototype, {
+    type: "file",
+    revision: 0,
+    nlink: 1,
+    references: 0,
+    sourceRef: undefined,
+});
+const EMPTY_ALLOC_BYTES = new Uint8Array(0);
+const DUMMY_POOL_LEDGER = new MemoryLedger(normalizeMemoryFileSystemLimits({}));
+const DUMMY_POOL_ALLOCATION = new MemoryAllocation(EMPTY_ALLOC_BYTES, DUMMY_POOL_LEDGER);
+const DUMMY_POOL_FILE_NODE = new MemoryFileNode(0, 0, null, 0, DUMMY_POOL_ALLOCATION, DUMMY_POOL_ALLOCATION.data);
+DUMMY_POOL_FILE_NODE.atimeMs = DUMMY_POOL_FILE_NODE.mtimeMs = DUMMY_POOL_FILE_NODE.ctimeMs = DUMMY_POOL_FILE_NODE.birthtimeMs = 1700000000000;
+const EMPTY_DIR_TABLE = new Int16Array(0);
+const EMPTY_DIR_KEYS = [];
+const EMPTY_DIR_VALS = [];
+class FastDirectoryEntriesMap {
+    // Keep speculative slots local so a failed write cannot pin a tenant globally.
+    _missKey = "";
+    _missSlot = -1;
+    _table = EMPTY_DIR_TABLE;
+    _mask = 0;
+    _keys = EMPTY_DIR_KEYS;
+    _vals = EMPTY_DIR_VALS;
+    _next = 0;
+    size = 0;
+    [Symbol.toStringTag] = "Map";
+    _hash(k) {
+        let h = 5381;
+        for (let i = 0; i < k.length; i++) {
+            h = (((h & 0x1fffff) * 33) ^ k.charCodeAt(i)) & 0x3fffffff;
+        }
+        return h & this._mask;
+    }
+    get(k) {
+        if (this.size === 0)
+            return undefined;
+        let slot = this._hash(k);
+        const mask = this._mask;
+        const table = this._table;
+        const keys = this._keys;
+        while (true) {
+            const idx = table[slot];
+            if (idx === -1)
+                return undefined;
+            if (idx >= 0 && keys[idx] === k)
+                return this._vals[idx];
+            slot = (slot + 1) & mask;
+        }
+    }
+    getForWrite(k) {
+        return this.getForWriteWithHash(k, this._hash(k));
+    }
+    getForWriteWithHash(k, h) {
+        let slot = h & this._mask;
+        if (this.size === 0) {
+            if (this._keys.length === 0) {
+                this._missKey = "";
+                this._missSlot = -1;
+                return undefined;
+            }
+            this._missKey = k;
+            this._missSlot = slot;
+            return undefined;
+        }
+        const mask = this._mask;
+        const table = this._table;
+        const keys = this._keys;
+        let firstDeleted = -1;
+        while (true) {
+            const idx = table[slot];
+            if (idx === -1) {
+                this._missKey = k;
+                this._missSlot = firstDeleted !== -1 ? firstDeleted : slot;
+                return undefined;
+            }
+            if (idx === -2) {
+                if (firstDeleted === -1)
+                    firstDeleted = slot;
+            }
+            else if (keys[idx] === k) {
+                return this._vals[idx];
+            }
+            slot = (slot + 1) & mask;
+        }
+    }
+    getSubstr(s, start, end) {
+        if (this.size === 0)
+            return undefined;
+        const len = end - start;
+        let h = 5381;
+        for (let i = start; i < end; i++) {
+            h = (((h & 0x1fffff) * 33) ^ s.charCodeAt(i)) & 0x3fffffff;
+        }
+        let slot = h & this._mask;
+        const mask = this._mask;
+        const table = this._table;
+        const keys = this._keys;
+        while (true) {
+            const idx = table[slot];
+            if (idx === -1)
+                return undefined;
+            if (idx >= 0) {
+                const k = keys[idx];
+                if (k.length === len) {
+                    let match = true;
+                    for (let i = 0; i < len; i++) {
+                        if (k.charCodeAt(i) !== s.charCodeAt(start + i)) {
+                            match = false;
+                            break;
+                        }
+                    }
+                    if (match)
+                        return this._vals[idx];
+                }
+            }
+            slot = (slot + 1) & mask;
+        }
+    }
+    has(k) {
+        return this.get(k) !== undefined;
+    }
+    _rebuild(newCap) {
+        this._missKey = "";
+        this._missSlot = -1;
+        const newTableLen = newCap * 2;
+        const newMask = newTableLen - 1;
+        const newTable = newCap <= 16384 ? new Int16Array(newTableLen).fill(-1) : new Int32Array(newTableLen).fill(-1);
+        const oldKeys = this._keys;
+        const oldVals = this._vals;
+        const oldNext = this._next;
+        const newKeys = newCap === oldKeys.length ? oldKeys : new Array(newCap).fill("");
+        const newVals = newCap === oldVals.length ? oldVals : new Array(newCap).fill(DUMMY_POOL_FILE_NODE);
+        let writeIdx = 0;
+        for (let i = 0; i < oldNext; i++) {
+            const v = oldVals[i];
+            if (v === DUMMY_POOL_FILE_NODE)
+                continue;
+            const k = oldKeys[i];
+            newKeys[writeIdx] = k;
+            newVals[writeIdx] = v;
+            let h = 5381;
+            for (let c = 0; c < k.length; c++) {
+                h = (((h & 0x1fffff) * 33) ^ k.charCodeAt(c)) & 0x3fffffff;
+            }
+            let slot = h & newMask;
+            while (newTable[slot] !== -1) {
+                slot = (slot + 1) & newMask;
+            }
+            newTable[slot] = writeIdx++;
+        }
+        if (newKeys === oldKeys) {
+            for (let i = writeIdx; i < oldNext; i++) {
+                newKeys[i] = "";
+                newVals[i] = DUMMY_POOL_FILE_NODE;
+            }
+        }
+        this._table = newTable;
+        this._mask = newMask;
+        this._keys = newKeys;
+        this._vals = newVals;
+        this._next = writeIdx;
+    }
+    set(k, v) {
+        const missSlot = k === this._missKey ? this._missSlot : -1;
+        this._missKey = "";
+        this._missSlot = -1;
+        if (missSlot >= 0 && (this._table[missSlot] === -1 || this._table[missSlot] === -2) && this._next < this._keys.length) {
+            const entryIdx = this._next++;
+            this._table[missSlot] = entryIdx;
+            this._keys[entryIdx] = k;
+            this._vals[entryIdx] = v;
+            this.size++;
+            return this;
+        }
+        if (this._next >= this._keys.length) {
+            this._rebuild(this._keys.length === 0 ? 8 : (this.size * 2 <= this._keys.length ? this._keys.length : this._keys.length * 2));
+        }
+        let slot = this._hash(k);
+        const mask = this._mask;
+        const table = this._table;
+        const keys = this._keys;
+        let firstDeleted = -1;
+        while (true) {
+            const idx = table[slot];
+            if (idx === -1) {
+                const targetSlot = firstDeleted !== -1 ? firstDeleted : slot;
+                const entryIdx = this._next++;
+                table[targetSlot] = entryIdx;
+                keys[entryIdx] = k;
+                this._vals[entryIdx] = v;
+                this.size++;
+                return this;
+            }
+            if (idx === -2) {
+                if (firstDeleted === -1)
+                    firstDeleted = slot;
+            }
+            else if (keys[idx] === k) {
+                this._vals[idx] = v;
+                return this;
+            }
+            slot = (slot + 1) & mask;
+        }
+    }
+    delete(k) {
+        this._missKey = "";
+        this._missSlot = -1;
+        if (this.size === 0)
+            return false;
+        let slot = this._hash(k);
+        const mask = this._mask;
+        const table = this._table;
+        const keys = this._keys;
+        while (true) {
+            const idx = table[slot];
+            if (idx === -1)
+                return false;
+            if (idx >= 0 && keys[idx] === k) {
+                if (this.size === 1) {
+                    this.clear();
+                    return true;
+                }
+                table[slot] = -2;
+                keys[idx] = "";
+                this._vals[idx] = DUMMY_POOL_FILE_NODE;
+                // Keep deleted indices until compaction: reusing the tail would let
+                // tombstones fill the table without reaching set()'s rebuild threshold.
+                this.size--;
+                return true;
+            }
+            slot = (slot + 1) & mask;
+        }
+    }
+    clear() {
+        this._missKey = "";
+        this._missSlot = -1;
+        if (this._next > 0) {
+            this._table.fill(-1);
+            for (let i = 0; i < this._next; i++) {
+                this._keys[i] = "";
+                this._vals[i] = DUMMY_POOL_FILE_NODE;
+            }
+            this._next = 0;
+            this.size = 0;
+        }
+    }
+    forEach(callbackfn, thisArg) {
+        const next = this._next;
+        const keys = this._keys;
+        const vals = this._vals;
+        for (let i = 0; i < next; i++) {
+            const v = vals[i];
+            if (v !== DUMMY_POOL_FILE_NODE) {
+                if (thisArg !== undefined)
+                    callbackfn.call(thisArg, v, keys[i], this);
+                else
+                    callbackfn(v, keys[i], this);
+            }
+        }
+    }
+    *keys() {
+        for (let i = 0; i < this._next; i++) {
+            if (this._vals[i] !== DUMMY_POOL_FILE_NODE)
+                yield this._keys[i];
+        }
+    }
+    *values() {
+        for (let i = 0; i < this._next; i++) {
+            const v = this._vals[i];
+            if (v !== DUMMY_POOL_FILE_NODE)
+                yield v;
+        }
+    }
+    *entries() {
+        for (let i = 0; i < this._next; i++) {
+            const v = this._vals[i];
+            if (v !== DUMMY_POOL_FILE_NODE)
+                yield [this._keys[i], v];
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+}
+const SHARED_POOL_CAPACITY = 256;
+const SHARED_DIR_POOL_CAPACITY = 64;
+const sharedFileNodePool = new Array(SHARED_POOL_CAPACITY).fill(DUMMY_POOL_FILE_NODE);
+let sharedFileNodePoolLen = 0;
+const sharedDirectoryNodePool = new Array(SHARED_DIR_POOL_CAPACITY);
+let sharedDirectoryNodePoolLen = 0;
+const sharedRemovedScratch = new Array(SHARED_POOL_CAPACITY).fill(DUMMY_POOL_FILE_NODE);
+let sharedRemovedLen = 0;
+let sharedRemovedKeyChars = 0;
+let sharedRemovedKeyEntries = 0;
+function collectRemovedChild(child, name) {
+    if (sharedRemovedLen < sharedRemovedScratch.length) {
+        sharedRemovedScratch[sharedRemovedLen++] = child;
+    }
+    else {
+        sharedRemovedScratch.push(child);
+        sharedRemovedLen++;
+    }
+    sharedRemovedKeyChars += name.length;
+    sharedRemovedKeyEntries++;
+}
+function replenishSharedMemoryPools() {
+    while (sharedFileNodePoolLen < 112) {
+        sharedFileNodePool[sharedFileNodePoolLen++] = new MemoryFileNode(0, 0, 0, 0, DUMMY_POOL_ALLOCATION, undefined);
+    }
+    while (sharedDirectoryNodePoolLen < 16) {
+        sharedDirectoryNodePool[sharedDirectoryNodePoolLen++] = new MemoryDirectoryNode(0, 0, 0);
+    }
+}
+class MemoryDirectoryNode {
+    constructor(mode, ino, now) {
+        this.revision = 0;
+        this.mode = mode;
+        this.ino = ino;
+        this.nlink = 1;
+        this.references = 0;
+        this.atimeMs = now;
+        this.mtimeMs = now;
+        this.ctimeMs = now;
+        this.birthtimeMs = now;
+        this.entries = new FastDirectoryEntriesMap();
+        this.cachedNlink = 2;
+        this.cachedNlinkRev = 0;
+    }
+}
+Object.assign(MemoryDirectoryNode.prototype, {
+    type: "directory",
+    revision: 0,
+    nlink: 1,
+    references: 0,
+    cachedNlink: 2,
+    cachedNlinkRev: 0,
+});
+const DUMMY_POOL_DIR_NODE = new MemoryDirectoryNode(0, 0, null);
+DUMMY_POOL_DIR_NODE.atimeMs = DUMMY_POOL_DIR_NODE.mtimeMs = DUMMY_POOL_DIR_NODE.ctimeMs = DUMMY_POOL_DIR_NODE.birthtimeMs = 1700000000000;
+class MemoryCache {
+    files = [];
+    directories = [];
+    removedScratch = [];
+    lastFastDirPrefix = "";
+    lastFastDirNode = undefined;
+    lastFastFilePath = "";
+    lastFastFileName = "";
+    lastFastFileNode = undefined;
+    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 sharedAllowMissingNoFollowOptions = Object.freeze({ allowMissing: true, followFinal: false });
+const sharedFastLocation = { node: undefined, parent: DUMMY_POOL_DIR_NODE, name: "", path: "" };
+const resolvedVoid = Promise.resolve();
+const preferredIoBlockSize = 64 * 1024;
+const ext4HtreeEof64 = (1n << 63n) - 1n;
+const extractionStreamGuard = Symbol("extractionStreamGuard");
+const ownedStats = new WeakMap();
+const ownedStores = new WeakMap();
+const receiverCapabilities = 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();
+    let explicit = false;
+    let answer = "unknown";
+    const visited = new Set();
+    for (const [left, right] of [[own, peer], [peer, own]]) {
+        if (!registeredAuthorities.has(left.filesystem) || visited.has(left.filesystem))
+            continue;
+        visited.add(left.filesystem);
+        const comparison = left.filesystem.compareEntry;
+        if (comparison === memoryImplementation.compareEntry?.value)
+            continue;
+        explicit = true;
+        if (!comparison)
+            continue;
+        options.signal?.throwIfAborted();
+        assertCallbackAuthorityAllowed();
+        const result = await comparison.call(left.filesystem, left.path, right.filesystem, right.path, options);
+        options.signal?.throwIfAborted();
+        if (result !== "same" && result !== "distinct" && result !== "unknown") {
+            throw new FsError("EIO", { path: own.path, dest: peer.path, message: "invalid explicit Memory comparison" });
+        }
+        if (result === "unknown")
+            continue;
+        if (answer !== "unknown" && answer !== result) {
+            throw new FsError("EIO", { path: own.path, dest: peer.path, message: "conflicting explicit Memory comparisons" });
+        }
+        answer = result;
+    }
+    if (explicit)
+        return answer;
+    const owner = ownedStores.get(own.filesystem);
+    const observation = ownedStats.get(own.stat);
+    if (!owner?.intact() || observation?.filesystem !== own.filesystem || observation.path !== own.path
+        || observation.root !== owner.root)
+        return "unknown";
+    const qualified = getOwnedS3Entry(peer) ?? getOwnedWebDavEntry(peer);
+    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;
+    }
+}
+const SHARED_STOCK_MEMORY_CAPABILITIES = Object.freeze({
+    read: true, stat: true, readdir: true, realpath: true, access: true, open: true,
+    write: true, append: true, exclusiveCreate: true, explicitDirectories: true, implicitDirectories: false,
+    mkdir: true, recursiveMkdir: true, remove: true, removeDirectory: true, recursiveRemove: true,
+    rename: true, atomicRenameNoReplace: true, copy: true, exclusiveCopy: true, readlink: true, truncate: true,
+    streamingAppend: true, randomAccessWrite: true,
+    readOnly: false,
+    symlinks: true, conditionalChmod: true,
+    hardlinks: true,
+    permissions: true,
+    timestamps: true,
+    atomicRename: true,
+    atomicStagedFileMutation: true, atomicFileStaging: true, retainedStagingCleanup: true, retainedStagingWrite: true, atomicStagingAncestry: true, atomicFileMutation: true, atomicEntryRemoval: true, atomicEntryRemovalReceipt: true, atomicTreeRemoval: true,
+    synchronousDirectoryValidation: true, synchronousStagingResolution: true, synchronousFollowedStagingResolution: true, guardedStagingPublication: true,
+    atomicDirectoryMetadata: true,
+    streamingRead: true,
+    retainedRead: true,
+    retainedResize: true,
+    streamingWrite: true,
+    descriptorWriteStream: true,
+});
+function customMemoryCapabilities(filesystem) {
+    return Object.freeze({
+        ...SHARED_STOCK_MEMORY_CAPABILITIES,
+        get retainedResize() { return stockRetainedResize(filesystem); },
+        get descriptorWriteStream() { return stockDescriptorWrite(filesystem); },
+    });
+}
+export class MemoryFileSystem {
+    capabilitiesFor;
+    get identityScope() {
+        return (this._owner.identityScope ??= Symbol());
+    }
+    get capabilities() {
+        const owner = ownedStores.get(this);
+        if (owner) {
+            if (!owner.customCapabilities) {
+                owner.customCapabilities = customMemoryCapabilities(this);
+                owner.capabilities = owner.customCapabilities;
+            }
+            return owner.customCapabilities;
+        }
+        let caps = receiverCapabilities.get(this);
+        if (!caps) {
+            caps = customMemoryCapabilities(this);
+            receiverCapabilities.set(this, caps);
+        }
+        return caps;
+    }
+    nextInode = 1;
+    ledger;
+    _cache;
+    mutationTick = 0;
+    _owner;
+    root;
+    totalBytes = 0;
+    symlinkCount = 0;
+    _getAtomicView() {
+        const owner = ownedStores.get(this);
+        if (!owner ||
+            Object.getPrototypeOf(this) !== MemoryFileSystem.prototype ||
+            this.root !== owner.root ||
+            this.ledger !== owner.ledger ||
+            this.capabilities !== owner.capabilities) {
+            return undefined;
+        }
+        const proto = MemoryFileSystem.prototype;
+        for (let i = 0; i < memoryImplementationKeys.length; i++) {
+            const name = memoryImplementationKeys[i];
+            const expected = memoryImplementationDescriptors[i];
+            if (name === "capabilities")
+                continue;
+            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 undefined;
+            }
+            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 undefined;
+            }
+        }
+        return owner.atomicView ??= {
+            replaceContents: (source, destination) => {
+                const from = this.entry(source, "overlayAtomicView").node;
+                const to = this.entry(destination, "overlayAtomicView").node;
+                if (from?.type !== "file" || to?.type !== "file" || from === to || from.nlink !== 1)
+                    this.fail("EINVAL", "overlayAtomicView", destination);
+                this.permission(to, 2, "overlayAtomicView", destination);
+                // Exchange owned storage, preserving destination inode/hardlinks and
+                // retained allocation snapshots. Stage cleanup releases the old contents.
+                const allocation = to.allocation, length = to.byteLength;
+                to.allocation = from.allocation;
+                to.byteLength = from.byteLength;
+                from.allocation = allocation;
+                from.byteLength = length;
+                to.view = undefined;
+                from.view = undefined;
+                to.sourceRef = undefined;
+                from.sourceRef = undefined;
+                this.changed(to);
+                this.changed(from);
+            },
+            stat: (path) => {
+                this.validatePath(path, "overlayAtomicView");
+                let node = this.root;
+                for (const component of path.split("/").filter(Boolean)) {
+                    if (component === "." || component === "..")
+                        this.fail("EINVAL", "overlayAtomicView", path);
+                    if (!node)
+                        return undefined;
+                    if (node.type !== "directory")
+                        this.fail("ENOTDIR", "overlayAtomicView", path);
+                    this.permission(node, 1, "overlayAtomicView", path);
+                    node = node.entries.get(component);
+                }
+                return node ? this.snapshot(node) : undefined;
+            },
+            names: (path) => {
+                const node = this.entry(path, "overlayAtomicView").node;
+                if (node.type !== "directory")
+                    this.fail("ENOTDIR", "overlayAtomicView", path);
+                return [...node.entries.keys()];
+            },
+        };
+    }
+    constructor(options = {}) {
+        this.ledger = new MemoryLedger(normalizeMemoryFileSystemLimits(options));
+        if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes) {
+            replenishSharedMemoryPools();
+        }
+        const cache = new MemoryCache();
+        this._cache = cache;
+        memoryCaches.set(this.ledger, cache);
+        this.ledger.reserve(0, 1, "mkdir", "/");
+        this.root = this.directory(0o755);
+        const root = this.root;
+        const owner = {
+            root,
+            ledger: this.ledger,
+            capabilities: SHARED_STOCK_MEMORY_CAPABILITIES,
+            intact: () => this.root === root,
+        };
+        this._owner = owner;
+        ownedStores.set(this, owner);
+        registerLazyMemoryAtomicView(this, memoryImplementation._getAtomicView.value);
+        if (this.compareEntry === memoryImplementation.compareEntry?.value) {
+            registeredAuthorities.add(this);
+            registerEntryAuthority(this, compareOwnedMemory);
+        }
+    }
+    compareEntry(path, peer, peerPath, options = {}) {
+        return compareEntries(this, path, peer, peerPath, options);
+    }
+    canonicalizeMissingTarget(path, options = {}) {
+        options.signal?.throwIfAborted();
+        if (!isStockMemoryMethods(this, missingTargetMethodNames))
+            return undefined;
+        const owner = ownedStores.get(this);
+        if (path !== "")
+            this.validatePath(path, "realpath");
+        return resolveMissingTarget(owner.root, path || ".", options.signal, this.ledger.limits);
+    }
+    async confineExtraction(roots, options = {}) {
+        options.signal?.throwIfAborted();
+        const commitGuard = options.commitGuard;
+        const retained = new Map();
+        for (const root of roots) {
+            this.validatePath(root, "confineExtraction");
+            let path = "";
+            for (const component of root.split("/").filter(Boolean)) {
+                if (component === "." || component === "..")
+                    this.fail("EINVAL", "confineExtraction", root);
+                path += `/${component}`;
+                const node = this.entry(path, "confineExtraction").node;
+                if (node.type !== "directory")
+                    this.fail("ENOTDIR", "confineExtraction", path);
+                retained.set(path, node);
+            }
+            retained.set("/", this.root);
+        }
+        const capabilities = this.capabilities;
+        const allowed = new Set(["mkdir", "rm", "rmdir", "rename", "symlink", "link", "chmod", "utimes", "writeFile", "appendFile", "writeStream", "writeFileConditional", "removeFileConditional", "removeEntryConditional", "prepareDirectory", "createStagedFile", "publishStagedFile", "removeStagedFile"]);
+        const reads = new Set(["access", "capabilitiesFor", "compareEntry", "lstat", "stat", "readFile", "readStream", "readdir", "readlink", "realpath"]);
+        const check = (path, followFinal) => {
+            if (commitGuard)
+                runStagingGuard(commitGuard);
+            if (!roots.some(root => root === "/" || path === root || path.startsWith(`${root}/`)))
+                this.fail("EPERM", "confineExtraction", path);
+            const components = path.split("/").filter(Boolean);
+            if (components.some(component => component === "." || component === ".."))
+                this.fail("EINVAL", "confineExtraction", path);
+            let current = "";
+            for (const [index, component] of components.entries()) {
+                current += `/${component}`;
+                const node = this.entry(current, "confineExtraction", true).node;
+                if (retained.has(current) && node !== retained.get(current))
+                    this.fail("EAGAIN", "confineExtraction", current);
+                if (index < components.length - 1 && node?.type !== "directory")
+                    this.fail("ENOTDIR", "confineExtraction", current);
+                if (followFinal && index === components.length - 1 && node?.type === "symlink")
+                    this.fail("ELOOP", "confineExtraction", current);
+            }
+        };
+        return new Proxy(this, {
+            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;
+                if (reads.has(String(property)))
+                    return value.bind(target);
+                return (...args) => {
+                    if (!allowed.has(String(property)))
+                        throw new FsError("ENOTSUP", { syscall: String(property) });
+                    // Stock mutations resolve and commit synchronously. Streamed writes
+                    // repeat the boundary and file-binding check at each backend mutation.
+                    const paths = property === "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);
+                            } };
+                    }
+                    if (property === "createStagedFile")
+                        return Reflect.apply(value, target, args).then(staging => {
+                            const writer = staging.writer;
+                            if (!writer)
+                                return staging;
+                            return Object.freeze({ ...staging, writer: Object.freeze({
+                                    write: async (bytes, controls = {}) => {
+                                        controls.signal?.throwIfAborted();
+                                        check(staging.file.path, true);
+                                        await writer.write(bytes, controls);
+                                    },
+                                    finish: async (controls = {}) => {
+                                        controls.signal?.throwIfAborted();
+                                        check(staging.file.path, true);
+                                        return writer.finish(controls);
+                                    },
+                                }) });
+                        });
+                    return Reflect.apply(value, target, args);
+                };
+            },
+        });
+    }
+    metadata(mode) {
+        const now = Date.now();
+        return {
+            mode, ino: this.nextInode++, nlink: 1, references: 0, revision: 0,
+            atimeMs: now, mtimeMs: now, ctimeMs: now, birthtimeMs: now,
+        };
+    }
+    directory(mode, now = Date.now()) {
+        const fullMode = typeModes.directory | mode;
+        const ino = this.nextInode++;
+        let pooled;
+        if (sharedDirectoryNodePoolLen > 0) {
+            pooled = sharedDirectoryNodePool[--sharedDirectoryNodePoolLen];
+            sharedDirectoryNodePool[sharedDirectoryNodePoolLen] = DUMMY_POOL_DIR_NODE;
+        }
+        else {
+            pooled = memoryCaches.get(this.ledger)?.directories.pop();
+        }
+        if (pooled) {
+            pooled.mode = fullMode;
+            pooled.ino = ino;
+            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, now = Date.now()) {
+        const bytes = name.length * 2;
+        this.ledger.reserve(bytes, 2, syscall, path);
+        try {
+            const node = this.directory(mode, now);
+            parent.entries.set(name, node);
+            this.changed(parent, now);
+            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;
+        this.ledger.reserve(bytes, 2, syscall, path);
+        try {
+            const node = create();
+            if (node.type === "file")
+                this.admitSize(undefined, node.byteLength, syscall, path);
+            parent.entries.set(name, node);
+            if (node.type === "file")
+                this.totalBytes += node.byteLength;
+            else if (node.type === "symlink")
+                this.symlinkCount++;
+            this.changed(parent);
+            return node;
+        }
+        catch (error) {
+            this.ledger.release(bytes, 2);
+            throw error;
+        }
+    }
+    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") {
+            if (cache.lastFastFileNode === node) {
+                cache.lastFastFilePath = "";
+                cache.lastFastFileName = "";
+                cache.lastFastFileNode = undefined;
+            }
+            this.totalBytes -= node.byteLength;
+            const alloc = node.allocation;
+            node.view = undefined;
+            node.sourceRef = undefined;
+            node.allocation = DUMMY_POOL_ALLOCATION;
+            alloc.release();
+            if (sharedFileNodePoolLen < SHARED_POOL_CAPACITY) {
+                sharedFileNodePool[sharedFileNodePoolLen++] = node;
+            }
+            else if (cache.files.length < 128) {
+                cache.files.push(node);
+            }
+        }
+        else if (node.type === "symlink") {
+            this.symlinkCount--;
+        }
+        else {
+            if (cache.lastFastDirNode === node) {
+                cache.lastFastDirPrefix = "";
+                cache.lastFastDirNode = undefined;
+            }
+            if (node.entries.size === 0) {
+                node.entries.clear();
+                if (sharedDirectoryNodePoolLen < SHARED_DIR_POOL_CAPACITY) {
+                    sharedDirectoryNodePool[sharedDirectoryNodePoolLen++] = node;
+                }
+                else if (cache.directories.length < 32) {
+                    cache.directories.push(node);
+                }
+            }
+        }
+    }
+    releaseReference(node, path) {
+        node.references--;
+        this.ledger.release(path.length * 2, 1);
+        this.releaseNode(node);
+    }
+    replaceData(node, allocation, length = allocation.data.byteLength) {
+        const previous = node.allocation;
+        node.sourceRef = undefined;
+        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);
+        const maxBytes = this.ledger.limits.maxBytes;
+        if (maxBytes !== undefined && length - (node?.byteLength ?? 0) > maxBytes - this.totalBytes) {
+            this.fail("ENOSPC", syscall, path);
+        }
+    }
+    fail(code, syscall, path, dest) {
+        throw new FsError(code, { syscall, path, ...(dest === undefined ? {} : { dest }) });
+    }
+    validatePath(path, syscall) {
+        if (typeof path !== "string" || path.includes("\0"))
+            this.fail("EINVAL", syscall, path);
+        if (path.length === 0)
+            this.fail("ENOENT", syscall, path);
+        if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+            validatePath(path, this.ledger.limits);
+    }
+    permission(node, mask, syscall, path) {
+        if (((node.mode >> 6) & mask) !== mask)
+            this.fail("EACCES", syscall, path);
+    }
+    mode(mode, fallback, syscall, path) {
+        const value = mode ?? fallback;
+        if (!Number.isInteger(value) || value < 0 || value > 0o7777)
+            this.fail("EINVAL", syscall, path);
+        return value;
+    }
+    integer(value, syscall, path) {
+        if (!Number.isSafeInteger(value) || value < 0)
+            this.fail("EINVAL", syscall, path);
+    }
+    changed(node, now = Date.now()) {
+        this.mutationTick = (this.mutationTick + 1) | 0;
+        node.revision = node.revision < 1073741823 ? (node.revision + 1) | 0 : Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+        node.mtimeMs = node.ctimeMs = now;
+    }
+    resolveNode(path, syscall, followFinal = true) {
+        if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+            validatePath(path, this.ledger.limits);
+        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 = fastPrefix.length === 1 ? (path === _lastFileSlice1Path ? _lastFileSlice1Name : (_lastFileSlice1Path = path, _lastFileSlice1Name = path.slice(1))) : path.slice(fastPrefix.length);
+                if (name.length > 0 && !name.includes("/")) {
+                    this.permission(fastDir, 1, syscall, path);
+                    if (exceedsComponentByteLimit(name))
+                        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 = start === 1 ? "/" : path.slice(0, start);
+                    cache.lastFastDirNode = current;
+                    const name = start === 1 ? (path === _lastFileSlice1Path ? _lastFileSlice1Name : (_lastFileSlice1Path = path, _lastFileSlice1Name = path.slice(1))) : path.slice(start);
+                    if (exceedsComponentByteLimit(name))
+                        this.fail("ENAMETOOLONG", syscall, path);
+                    const node = current.entries.get(name);
+                    if (!node)
+                        this.fail("ENOENT", syscall, path);
+                    return node;
+                }
+                const name = slicePathSegment(path, 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 = 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 = slicePathSegment(path, start, path.length);
+                    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 = this.ledger.limits.maxPathBytes - pathByteLength(path);
+        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 > this.ledger.limits.maxPathComponents)
+                    this.fail("ENAMETOOLONG", syscall, path);
+            }
+        }
+        let pending = path.split("/").filter(Boolean);
+        let remainingComponents = this.ledger.limits.maxPathComponents - 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();
+            const current = stack[stack.length - 1].node;
+            if (current.type !== "directory")
+                this.fail("ENOTDIR", syscall, path);
+            if (!(component === "" && pending.length === 0 && options.resizeCreate !== undefined))
+                this.permission(current, 1, syscall, path);
+            if (component === "." || component === "")
+                continue;
+            if (component === "..") {
+                if (stack.length > 1)
+                    stack.pop();
+                continue;
+            }
+            if (exceedsComponentByteLimit(component))
+                this.fail("ENAMETOOLONG", syscall, path);
+            if (options.resizeCreate === true && pending.length === 1 && pending[0] === "")
+                this.fail("EISDIR", syscall, path);
+            let node = current.entries.get(component);
+            if (!node && options.createDirectories !== undefined) {
+                this.permission(current, 3, syscall, path);
+                const mode = options.createDirectories;
+                node = this.addNode(current, component, () => this.directory(mode), syscall, path);
+            }
+            if (!node) {
+                if (options.allowMissing && pending.length === 0) {
+                    return { node, parent: current, name: component, path: [...stack.map((entry) => entry.name), component].join("/") };
+                }
+                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);
+                if (pathByteLength(node.target) > remainingPathUnits)
+                    this.fail("ENAMETOOLONG", syscall, path);
+                remainingPathUnits -= pathByteLength(node.target);
+                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] === "")
+                    target.pop();
+                pending = target.concat(pending);
+                if (node.target.startsWith("/"))
+                    stack.splice(1);
+                continue;
+            }
+            stack.push({ node, name: component });
+        }
+        const entry = stack[stack.length - 1];
+        return {
+            node: entry.node,
+            parent: (stack[stack.length - 2]?.node ?? this.root),
+            name: entry.name,
+            path: stack.map((part) => part.name).join("/") || "/",
+        };
+    }
+    file(path, syscall) {
+        if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+            validatePath(path, this.ledger.limits);
+        if (this.symlinkCount === 0 && path.charCodeAt(0) === 47 && path.length > 1 && path.indexOf("/", 1) === -1 && !path.includes("\0")) {
+            const name = path === _lastFileSlice1Path ? _lastFileSlice1Name : (_lastFileSlice1Path = path, _lastFileSlice1Name = path.slice(1));
+            if (name !== "." && name !== "..") {
+                this.permission(this.root, 1, syscall, path);
+                if (exceedsComponentByteLimit(name))
+                    this.fail("ENAMETOOLONG", syscall, path);
+                const node = this.root.entries.get(name);
+                if (!node)
+                    this.fail("ENOENT", syscall, path);
+                if (node.type !== "file")
+                    this.fail("EISDIR", syscall, path);
+                return node;
+            }
+        }
+        const cache = memoryCaches.get(this.ledger);
+        if (this.symlinkCount === 0 && isCleanAbsolutePath(path)) {
+            const fastDir = cache.lastFastDirNode;
+            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);
+        return node;
+    }
+    entry(path, syscall, allowMissing = false) {
+        this.validatePath(path, syscall);
+        const location = this.resolve(path.replace(/\/+$/, "") || "/", syscall, { followFinal: false, allowMissing });
+        if (path.endsWith("/") && location.node && location.node.type !== "directory")
+            this.fail("ENOTDIR", syscall, path);
+        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,
+            ...(hasRev ? { revision: node.revision } : {}),
+            preferredIoBlockSize: 4096,
+            size,
+            mode: node.mode,
+            ...(hasScope ? { 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,
+        };
+    }
+    bytes(data, syscall, path) {
+        const allocation = this.allocate(data.byteLength, syscall, path);
+        try {
+            allocation.data.set(data);
+            return allocation;
+        }
+        catch (error) {
+            allocation.release();
+            throw error;
+        }
+    }
+    allocate(length, syscall, path) {
+        this.ledger.fileSize(length, syscall, path);
+        this.ledger.reserve(length, 0, syscall, path);
+        if (length === 0) {
+            return DUMMY_POOL_ALLOCATION;
+        }
+        // Views can outlive files: never recycle their backing buffers across owners.
+        try {
+            return new MemoryAllocation(new Uint8Array(length), this.ledger);
+        }
+        catch (cause) {
+            this.ledger.release(length, 0);
+            throw new FsError("EFBIG", { syscall, path, cause });
+        }
+    }
+    open(path, options) {
+        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",
+            });
+            let node = location.node;
+            if (node) {
+                if (admitted.creation === "exclusive")
+                    this.fail("EEXIST", "open", path);
+                if (node.type === "symlink" && admitted.noFollow)
+                    this.fail("ELOOP", "open", path);
+                if (node.type !== "file")
+                    this.fail("EISDIR", "open", path);
+                this.permission(node, admitted.access === "read" ? 4 : admitted.access === "write" ? 2 : 6, "open", path);
+            }
+            else {
+                this.permission(location.parent, 3, "open", path);
+            }
+            this.ledger.reserve(path.length * 2, 1, "open", path);
+            try {
+                node ??= this.openWrite(path, {}, "open", { location, mode: admitted.mode, append: false });
+                if (admitted.truncate)
+                    this.resizeNode(node, 0, "open", path);
+            }
+            catch (error) {
+                this.ledger.release(path.length * 2, 1);
+                throw error;
+            }
+            node.references++;
+            const resource = { fs: this, path, append: admitted.append, node, position: 0 };
+            return {
+                resource,
+                getPosition: memoryDescriptorGetPosition,
+                stat: memoryDescriptorStat,
+                read: memoryDescriptorRead,
+                write: memoryDescriptorWrite,
+                truncate: memoryDescriptorTruncate,
+                sync: memoryDescriptorSync,
+                close: memoryDescriptorClose,
+            };
+        });
+    }
+    prepareWrite(path, options, syscall) {
+        const flag = options.flag ?? "w";
+        if (!["w", "wx", "a", "ax"].includes(flag))
+            this.fail("EINVAL", syscall, path);
+        const mode = this.mode(options.mode, 0o666, syscall, path);
+        const exclusive = flag === "wx" || flag === "ax";
+        const location = this.resolve(path, syscall, { followFinal: !exclusive, allowMissing: true });
+        if (location.node) {
+            if (exclusive)
+                this.fail("EEXIST", syscall, path);
+            if (location.node.type !== "file")
+                this.fail("EISDIR", syscall, path);
+            this.permission(location.node, 2, syscall, path);
+        }
+        else {
+            this.permission(location.parent, 3, syscall, path);
+        }
+        return { location, mode, append: flag === "a" || flag === "ax" };
+    }
+    openWrite(path, options, syscall, target = this.prepareWrite(path, options, syscall)) {
+        const { location, mode } = target;
+        if (location.node)
+            return location.node;
+        return this.addNode(location.parent, location.name, () => {
+            const allocation = new MemoryAllocation(new Uint8Array(), this.ledger);
+            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) {
+        if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+            validatePath(path, this.ledger.limits);
+        if (!(data instanceof Uint8Array))
+            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?.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);
+        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;
+                    let pooled;
+                    if (sharedFileNodePoolLen > 0) {
+                        pooled = sharedFileNodePool[--sharedFileNodePoolLen];
+                        sharedFileNodePool[sharedFileNodePoolLen] = DUMMY_POOL_FILE_NODE;
+                    }
+                    else {
+                        pooled = memoryCaches.get(this.ledger).files.pop();
+                    }
+                    if (pooled) {
+                        pooled.mode = fileMode;
+                        pooled.ino = this.nextInode++;
+                        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;
+                        pooled.sourceRef = pooled.data.subarray(0);
+                        return pooled;
+                    }
+                    return new MemoryFileNode(fileMode, this.nextInode++, now, length, allocation, view, (view ?? allocation.data).subarray(0, length));
+                }, syscall, path);
+            }
+            catch (error) {
+                allocation.release();
+                throw error;
+            }
+        }
+        const copied = this.bytes(data, syscall, path);
+        try {
+            this.replaceData(current, copied);
+            this.changed(current);
+            return current;
+        }
+        catch (error) {
+            copied.release();
+            throw error;
+        }
+    }
+    writeAt(node, data, position, syscall, path) {
+        this.writeAtRange(node, data, data.byteLength, position, syscall, path, Date.now());
+    }
+    writeAtRange(node, data, dataLen, position, syscall, path, now) {
+        if (dataLen === 0) {
+            this.changed(node, now);
+            return;
+        }
+        const end = position + dataLen;
+        this.ledger.fileSize(end, syscall, path);
+        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);
+            let capacity;
+            if (this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && this.ledger.limits.maxBytes === undefined) {
+                capacity = curLen === 0 && length >= 8192 && length <= 65536 ? (length <= 16384 ? 16384 : 65536) : Math.max(length, curLen * 2, 64);
+            }
+            else {
+                const baseCap = curLen === 0 && length >= 8192 && length <= 65536 &&
+                    this.ledger.limits.maxFileBytes >= 65536 &&
+                    this.ledger.availableBytes >= 65536 &&
+                    (this.ledger.limits.maxBytes === undefined || this.ledger.limits.maxBytes - this.totalBytes >= 65536)
+                    ? 65536
+                    : Math.max(length, curLen * 2, 64);
+                capacity = Math.min(baseCap, this.ledger.limits.maxFileBytes, this.ledger.availableBytes);
+            }
+            allocation = this.allocate(capacity, syscall, path);
+        }
+        try {
+            const storage = allocation.data;
+            if (allocation !== node.allocation && curLen > 0) {
+                storage.set((node.view ?? node.allocation.data).subarray(0, curLen));
+            }
+            if (position > curLen)
+                storage.fill(0, curLen, position);
+            const source = data;
+            if (dataLen === data.byteLength) {
+                storage.set(data, position);
+            }
+            else if (typeof source.copy === "function") {
+                source.copy(storage, position, 0, dataLen);
+            }
+            else {
+                for (let i = 0; i < dataLen; i++)
+                    storage[position + i] = data[i];
+            }
+        }
+        catch (error) {
+            if (allocation !== node.allocation)
+                allocation.release();
+            throw error;
+        }
+        if (allocation !== node.allocation)
+            this.replaceData(node, allocation, length);
+        else {
+            this.totalBytes += length - curLen;
+            node.byteLength = length;
+            node.view = length === allocation.data.byteLength ? allocation.data : undefined;
+        }
+        node.sourceRef = undefined;
+        this.changed(node, now);
+    }
+    writeMemoryFileFast(path, data, append, mode) {
+        if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+            validatePath(path, this.ledger.limits);
+        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 & 0o100) !== 0 &&
+            (cache.lastFastFileNode.mode & 0o200) !== 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 & 0o100) !== 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 & 0o100) !== 0) {
+                        cache.lastFastDirPrefix = path.slice(0, start);
+                        cache.lastFastDirNode = parent;
+                    }
+                    break;
+                }
+                const seg = slicePathSegment(path, 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.getForWrite ? parent.entries.getForWrite(name) : 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 > 0 && length < 64 && this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes ? 64 : 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 = capacity === length ? allocation.data : undefined;
+                    let node;
+                    if (sharedFileNodePoolLen > 0) {
+                        node = sharedFileNodePool[--sharedFileNodePoolLen];
+                        sharedFileNodePool[sharedFileNodePoolLen] = DUMMY_POOL_FILE_NODE;
+                    }
+                    else {
+                        node = cache.files.pop();
+                    }
+                    if (node) {
+                        node.mode = fileMode;
+                        node.ino = this.nextInode++;
+                        node.nlink = 1;
+                        node.references = 0;
+                        node.revision = 0;
+                        node.atimeMs = now;
+                        node.mtimeMs = now;
+                        node.ctimeMs = now;
+                        node.birthtimeMs = now;
+                        node.byteLength = length;
+                        node.view = view;
+                        node.allocation = allocation;
+                        node.sourceRef = node.data.subarray(0);
+                    }
+                    else {
+                        node = new MemoryFileNode(fileMode, this.nextInode++, now, length, allocation, view, (view ?? allocation.data).subarray(0, length));
+                    }
+                    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;
+        }
+    }
+    writeMemoryFilesInDirBatchFast(firstFileName, dirPrefix, fileNames, nameHashes, payloads, totalNameBytes, payloadBytesSum, mode) {
+        const batchCount = fileNames.length;
+        const cache = this._cache;
+        if (batchCount > 0 &&
+            dirPrefix === cache.lastFastDirPrefix &&
+            cache.lastFastDirNode !== undefined &&
+            cache.lastFastDirNode.nlink !== 0 &&
+            (cache.lastFastDirNode.mode & 0o300) === 0o300 &&
+            this.ledger.hasInfiniteRetained &&
+            this.ledger.hasInfiniteFileBytes &&
+            this.ledger.limits.maxBytes === undefined &&
+            sharedFileNodePoolLen >= batchCount) {
+            const parent = cache.lastFastDirNode;
+            const entries = parent.entries;
+            if (entries.size === 1 &&
+                entries._next === 1 &&
+                entries._keys[0] === firstFileName &&
+                1 + batchCount <= entries._keys.length) {
+                this.ledger.reserve(totalNameBytes, 2 * batchCount, "writeFile", fileNames[batchCount - 1]);
+                this.totalBytes += payloadBytesSum;
+                const now = Date.now();
+                const fileMode = typeModes.file | mode;
+                let ino = this.nextInode;
+                this.nextInode = ino + batchCount;
+                let nextIdx = 1;
+                entries._missKey = "";
+                entries._next = 1 + batchCount;
+                entries.size = 1 + batchCount;
+                const table = entries._table;
+                const mask = table.length - 1;
+                const keys = entries._keys;
+                const vals = entries._vals;
+                for (let k = 0; k < batchCount; k++) {
+                    const name = fileNames[k];
+                    const data = payloads[k];
+                    const node = sharedFileNodePool[--sharedFileNodePoolLen];
+                    sharedFileNodePool[sharedFileNodePoolLen] = DUMMY_POOL_FILE_NODE;
+                    node.mode = fileMode;
+                    node.ino = ino++;
+                    if (node.nlink !== 1)
+                        node.nlink = 1;
+                    if (node.references !== 0)
+                        node.references = 0;
+                    if (node.revision !== 0)
+                        node.revision = 0;
+                    node.atimeMs = now;
+                    node.mtimeMs = now;
+                    node.ctimeMs = now;
+                    node.birthtimeMs = now;
+                    node.byteLength = data.byteLength;
+                    node.view = new Uint8Array(data);
+                    node.allocation = DUMMY_POOL_ALLOCATION;
+                    node.sourceRef = node.data.subarray(0);
+                    const entryIdx = nextIdx++;
+                    keys[entryIdx] = name;
+                    vals[entryIdx] = node;
+                    let slot = nameHashes[k] & mask;
+                    while (table[slot] !== -1)
+                        slot = (slot + 1) & mask;
+                    table[slot] = entryIdx;
+                }
+                this.mutationTick = (this.mutationTick + 1) | 0;
+                parent.revision = parent.revision < 1073741000 ? (parent.revision + batchCount) | 0 : Math.min(Number.MAX_SAFE_INTEGER + 1, parent.revision + batchCount);
+                parent.mtimeMs = parent.ctimeMs = now;
+                cache.lastFastFilePath = "";
+                cache.lastFastFileName = fileNames[batchCount - 1];
+                cache.lastFastFileNode = vals[nextIdx - 1];
+                return;
+            }
+        }
+        for (let k = 0; k < batchCount; k++) {
+            this.writeMemoryFileInDirFast(dirPrefix, fileNames[k], payloads[k], false, mode, nameHashes[k]);
+        }
+    }
+    writeMemoryFileInDirFast(dirPrefix, name, data, append, mode, nameHash) {
+        if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+            validatePath(dirPrefix + name, this.ledger.limits);
+        const cache = this._cache;
+        if (!append &&
+            dirPrefix === cache.lastFastDirPrefix &&
+            cache.lastFastDirNode !== undefined &&
+            cache.lastFastDirNode.nlink !== 0 &&
+            (cache.lastFastDirNode.mode & 0o300) === 0o300 &&
+            name.length <= 85 &&
+            this.ledger.hasInfiniteRetained &&
+            this.ledger.hasInfiniteFileBytes &&
+            this.ledger.limits.maxBytes === undefined &&
+            sharedFileNodePoolLen > 0) {
+            const parent = cache.lastFastDirNode;
+            const entries = parent.entries;
+            const existing = nameHash !== undefined ? entries.getForWriteWithHash(name, nameHash) : entries.getForWrite(name);
+            if (existing === undefined && entries._next < entries._keys.length) {
+                this.ledger.reserve(name.length * 2, 2, "writeFile", name);
+                const now = Date.now();
+                const length = data.byteLength;
+                const node = sharedFileNodePool[--sharedFileNodePoolLen];
+                sharedFileNodePool[sharedFileNodePoolLen] = DUMMY_POOL_FILE_NODE;
+                node.mode = typeModes.file | mode;
+                node.ino = this.nextInode++;
+                if (node.nlink !== 1)
+                    node.nlink = 1;
+                if (node.references !== 0)
+                    node.references = 0;
+                if (node.revision !== 0)
+                    node.revision = 0;
+                node.atimeMs = now;
+                node.mtimeMs = now;
+                node.ctimeMs = now;
+                node.birthtimeMs = now;
+                node.byteLength = length;
+                node.view = new Uint8Array(data);
+                node.allocation = DUMMY_POOL_ALLOCATION;
+                node.sourceRef = node.data.subarray(0);
+                const entryIdx = entries._next++;
+                entries._table[entries._missSlot] = entryIdx;
+                entries._keys[entryIdx] = name;
+                entries._vals[entryIdx] = node;
+                entries.size++;
+                entries._missKey = "";
+                this.totalBytes += length;
+                this.mutationTick = (this.mutationTick + 1) | 0;
+                parent.revision = parent.revision < 1073741823 ? (parent.revision + 1) | 0 : Math.min(Number.MAX_SAFE_INTEGER + 1, parent.revision + 1);
+                parent.mtimeMs = parent.ctimeMs = now;
+                cache.lastFastFilePath = "";
+                cache.lastFastFileName = name;
+                cache.lastFastFileNode = node;
+                return;
+            }
+        }
+        const syscall = append ? "appendFile" : "writeFile";
+        try {
+            if (append &&
+                dirPrefix === cache.lastFastDirPrefix &&
+                name === cache.lastFastFileName &&
+                cache.lastFastFileNode !== undefined &&
+                cache.lastFastFileNode.nlink !== 0 &&
+                cache.lastFastDirNode !== undefined &&
+                cache.lastFastDirNode.nlink !== 0 &&
+                (cache.lastFastDirNode.mode & 0o100) !== 0 &&
+                (cache.lastFastFileNode.mode & 0o200) !== 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 & 0o100) !== 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 ? slicePathSegment(dirPrefix, start, dirPrefix.length) : slicePathSegment(dirPrefix, 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 & 0o100) !== 0) {
+                    cache.lastFastDirPrefix = dirPrefix;
+                    cache.lastFastDirNode = parent;
+                }
+            }
+            const existing = parent.entries.getForWrite ? parent.entries.getForWrite(name) : 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 zeroCopyConst = this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && this.ledger.limits.maxBytes === undefined;
+                const capacity = zeroCopyConst ? 0 : (length > 0 && length < 64 && this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes ? 64 : length);
+                const allocation = zeroCopyConst ? DUMMY_POOL_ALLOCATION : this.allocate(capacity, syscall, name);
+                try {
+                    if (!zeroCopyConst)
+                        allocation.data.set(data);
+                    this.ledger.reserve(nameBytes, 2, syscall, name);
+                    try {
+                        const now = Date.now();
+                        const fileMode = typeModes.file | mode;
+                        const view = zeroCopyConst ? new Uint8Array(data) : (capacity === length ? allocation.data : undefined);
+                        let node;
+                        if (sharedFileNodePoolLen > 0) {
+                            node = sharedFileNodePool[--sharedFileNodePoolLen];
+                            sharedFileNodePool[sharedFileNodePoolLen] = DUMMY_POOL_FILE_NODE;
+                        }
+                        else {
+                            node = cache.files.pop();
+                        }
+                        if (node) {
+                            node.mode = fileMode;
+                            node.ino = this.nextInode++;
+                            if (node.nlink !== 1)
+                                node.nlink = 1;
+                            if (node.references !== 0)
+                                node.references = 0;
+                            if (node.revision !== 0)
+                                node.revision = 0;
+                            node.atimeMs = now;
+                            node.mtimeMs = now;
+                            node.ctimeMs = now;
+                            node.birthtimeMs = now;
+                            node.byteLength = length;
+                            node.view = view;
+                            node.allocation = allocation;
+                            node.sourceRef = node.data.subarray(0);
+                        }
+                        else {
+                            node = new MemoryFileNode(fileMode, this.nextInode++, now, length, allocation, view, (view ?? allocation.data).subarray(0, length));
+                        }
+                        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 && options.maxBytes !== Infinity)
+            this.integer(options.maxBytes, "readFile", path);
+        const node = this.file(path, "readFile");
+        this.permission(node, 4, "readFile", path);
+        if (options.maxBytes !== undefined && node.data.byteLength > options.maxBytes)
+            this.fail("EFBIG", "readFile", path);
+        node.atimeMs = Date.now();
+        return new Uint8Array(node.data);
+    }
+    expectEntry(node, expected, path, unchanged = true) {
+        if (expected === null) {
+            if (node)
+                this.fail("EAGAIN", "fileStaging", path);
+            return;
+        }
+        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 (!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");
+        this.expectEntry(parent.node, staging.parent.stat, staging.parent.path, false);
+        if (parent.node.type !== "directory")
+            this.fail("ENOTDIR", "fileStaging", staging.parent.path);
+        const directory = this.entry(staging.directory.path, "fileStaging");
+        this.expectEntry(directory.node, staging.directory.stat, staging.directory.path, false);
+        if (directory.parent !== parent.node || directory.node.type !== "directory" || (directory.node.mode & 0o777) !== 0o700)
+            this.fail("EAGAIN", "fileStaging", staging.directory.path);
+        const file = this.entry(staging.file.path, "fileStaging", true);
+        if (file.parent !== directory.node || !["file", "symlink"].includes(staging.file.stat.type))
+            this.fail("EAGAIN", "fileStaging", staging.file.path);
+        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);
+        if (location.node)
+            this.fail("EEXIST", "createStagedFile", directoryPath);
+        this.expectEntry(location.parent, options.parent, directoryPath, false);
+        this.permission(location.parent, 3, "createStagedFile", directoryPath);
+        const mode = this.mode(options.mode, content.type === "file" ? 0o666 : 0o777, "createStagedFile", directoryPath);
+        for (const time of [options.atimeMs, options.mtimeMs])
+            if (time !== undefined && !Number.isFinite(time))
+                this.fail("EINVAL", "createStagedFile", directoryPath);
+        if (content.type === "file" && !(content.data instanceof Uint8Array))
+            throw new TypeError("Staged files require Uint8Array data");
+        if (content.type === "file")
+            this.admitSize(undefined, content.data.byteLength, "createStagedFile", directoryPath);
+        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);
+        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;
+        try {
+            if (content.type === "file")
+                allocation = this.bytes(content.data, "createStagedFile", directoryPath);
+            directory = this.directory(0o700);
+            file = content.type === "file"
+                ? (() => { 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;
+            if (options.mtimeMs !== undefined)
+                file.mtimeMs = options.mtimeMs;
+            directory.entries.set(name, file);
+            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 + cleanupBytes, 4 + cleanupUnits);
+            throw error;
+        }
+        this.changed(location.parent);
+        const receipt = (path, node) => Object.freeze({ path, stat: Object.freeze(this.snapshot(node)) });
+        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, ...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 };
+        let expected = staging.file.stat;
+        let writing = true;
+        const receipt = () => ({ ...staging, file: { ...staging.file, stat: expected } });
+        const ownedCleanup = createStagingCleanup(staging.directory.path, options => {
+            options.signal?.throwIfAborted();
+            const state = retained;
+            if (state.parent.nlink === 0 || state.parent.entries.get(directoryName) !== state.directory)
+                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(receipt(), {
+                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);
+        });
+        const cleanup = Object.freeze({
+            remove: (options) => { writing = false; return ownedCleanup.remove(options); },
+            close: () => { writing = false; return ownedCleanup.close(); },
+        });
+        if (file.type !== "file")
+            return { cleanup };
+        const inspect = (options) => {
+            options.signal?.throwIfAborted();
+            if (!retained || !writing)
+                this.fail("EBADF", "stagedWrite", staging.file.path);
+            const location = this.stagingLocations(receipt());
+            if (location.file.node !== retained.file)
+                this.fail("EAGAIN", "stagedWrite", staging.file.path);
+            this.expectEntry(retained.file, expected, staging.file.path);
+            this.permission(retained.parent, 3, "stagedWrite", staging.parent.path);
+            this.permission(retained.directory, 3, "stagedWrite", staging.directory.path);
+            return retained.file;
+        };
+        return { cleanup, writer: Object.freeze({
+                write: async (bytes, options = {}) => {
+                    const node = inspect(options);
+                    if (!(bytes instanceof Uint8Array))
+                        throw new TypeError("Staged writes require Uint8Array data");
+                    this.writeAt(node, bytes, node.byteLength, "stagedWrite", staging.file.path);
+                    expected = Object.freeze(this.snapshot(node));
+                },
+                finish: async (options = {}) => {
+                    const node = inspect(options);
+                    this.changed(node);
+                    // changed updates modification time; archive creation metadata is final.
+                    node.atimeMs = staging.file.stat.atimeMs;
+                    node.mtimeMs = staging.file.stat.mtimeMs;
+                    writing = false;
+                    expected = Object.freeze(this.snapshot(node));
+                    return expected;
+                },
+            }) };
+    }
+    async prepareDirectoryAncestry(ancestors, options = {}) {
+        const entries = snapshotDirectoryAncestry(ancestors);
+        const controls = options.signal === undefined ? {} : { signal: options.signal };
+        controls.signal?.throwIfAborted();
+        return () => this.verifyDirectoryAncestry(entries, controls);
+    }
+    async prepareStagingResolution(path, options = {}) {
+        const followFinal = options.followFinalSymlink === true;
+        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, 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, 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 preserveIdentity = options.preserveIdentity === true;
+        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, 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")
+            this.fail("EAGAIN", "publishStagedFile", destination);
+        if (preserveIdentity) {
+            if (this.capabilities.atomicStagedFileMutation !== true)
+                this.fail("ENOTSUP", "publishStagedFile", destination);
+            if (file.node?.type !== "file" || target.node?.type !== "file" || expected === null)
+                this.fail("EINVAL", "publishStagedFile", destination);
+            this.permission(file.parent, 3, "publishStagedFile", staging.file.path);
+            this.permission(target.parent, 3, "publishStagedFile", destination);
+            this.permission(target.node, 2, "publishStagedFile", destination);
+            // Provider-owned storage is copied directly, without assembling an archive
+            // in caller memory. Preserve retained staging readers and independent writes.
+            this.admitSize(target.node, file.node.byteLength, "publishStagedFile", destination);
+            const allocation = this.allocate(file.node.byteLength, "publishStagedFile", destination);
+            try {
+                for (let offset = 0; offset < file.node.byteLength; offset += 65536) {
+                    allocation.data.set(file.node.data.subarray(offset, offset + 65536), offset);
+                }
+            }
+            catch (error) {
+                allocation.release();
+                throw error;
+            }
+            // No awaits or overridable operations occur between admission and commit.
+            const now = Date.now();
+            this.replaceData(target.node, allocation);
+            this.changed(target.node, now);
+            target.node.atimeMs = file.node.atimeMs;
+            target.node.mtimeMs = file.node.mtimeMs;
+            file.parent.entries.delete(file.name);
+            this.ledger.release(file.name.length * 2, 1);
+            file.node.nlink--;
+            file.node.ctimeMs = now;
+            file.node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, file.node.revision + 1);
+            this.releaseNode(file.node);
+            this.changed(file.parent, now);
+            memoryCaches.get(this.ledger).clearWrites();
+            return;
+        }
+        return MemoryFileSystem.prototype.rename.call(this, staging.file.path, destination, { ...controls, noReplace: expected === null });
+    }
+    async publishStagedFileSet(receipt, destination, options) {
+        if (options.preserveIdentity)
+            this.fail("ENOTSUP", "publishStagedFileSet", destination);
+        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 companions = options.companions.map(entry => ({ path: entry.path, expected: entry.expected === null ? null : { ...entry.expected }, remove: entry.remove }));
+        const syscall = "publishStagedFileSet";
+        const parentPath = destination.slice(0, destination.lastIndexOf("/")) || "/";
+        const paths = new Set([destination]);
+        const canonical = (path) => path.startsWith("/") && path.slice(1).split("/").every(part => part !== "" && part !== "." && part !== "..");
+        if (!canonical(destination) || ancestors && ancestors.at(-1)?.path !== parentPath)
+            this.fail("EINVAL", syscall, destination);
+        for (const entry of companions) {
+            if (!canonical(entry.path) || paths.has(entry.path) || (entry.path.slice(0, entry.path.lastIndexOf("/")) || "/") !== parentPath)
+                this.fail("EINVAL", syscall, entry.path);
+            paths.add(entry.path);
+        }
+        signal?.throwIfAborted();
+        if (guard !== undefined)
+            runStagingGuard(guard);
+        signal?.throwIfAborted();
+        if (ancestors)
+            this.verifyDirectoryAncestry(ancestors, signal === undefined ? {} : { signal });
+        const { directory, file } = this.stagingLocations(staging);
+        this.expectEntry(file.node, staging.file.stat, staging.file.path);
+        const target = this.entry(destination, syscall, true);
+        this.expectEntry(target.parent, parent, destination, false);
+        this.expectEntry(target.node, expected, destination);
+        const node = file.node;
+        if (node.type !== "file" || target.parent === directory.node || target.node === node)
+            this.fail("EINVAL", syscall, destination);
+        if (target.node && target.node.type !== "file")
+            this.fail("EAGAIN", syscall, destination);
+        this.permission(file.parent, 3, syscall, staging.file.path);
+        this.permission(target.parent, 3, syscall, destination);
+        const retired = [];
+        for (const companion of companions) {
+            const location = this.entry(companion.path, syscall, true);
+            if (location.parent !== target.parent || location.node === node)
+                this.fail("EINVAL", syscall, companion.path);
+            this.expectEntry(location.node, companion.expected, companion.path);
+            if (location.node && location.node.type !== "file")
+                this.fail("EAGAIN", syscall, companion.path);
+            if (companion.remove && location.node)
+                retired.push(location);
+        }
+        const now = Date.now();
+        const published = { ...this.snapshot(node), ctimeMs: now, revision: Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1) };
+        // Admission and all source-set checks precede the single synchronous commit.
+        // No calls to overridable async mutations can interleave a partial result.
+        const nameGrowth = target.node ? 0 : (target.name.length - file.name.length) * 2;
+        this.ledger.reserve(Math.max(0, nameGrowth), 0, syscall, destination);
+        try {
+            target.parent.entries.set(target.name, node);
+        }
+        catch (error) {
+            this.ledger.release(Math.max(0, nameGrowth), 0);
+            throw error;
+        }
+        memoryCaches.get(this.ledger).clearWrites();
+        file.parent.entries.delete(file.name);
+        const unlink = (entry) => {
+            entry.node.nlink--;
+            entry.node.ctimeMs = now;
+            entry.node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, entry.node.revision + 1);
+            this.releaseNode(entry.node);
+        };
+        if (target.node) {
+            this.ledger.release(file.name.length * 2, 1);
+            unlink(target);
+        }
+        else if (nameGrowth < 0)
+            this.ledger.release(-nameGrowth, 0);
+        for (const entry of retired) {
+            entry.parent.entries.delete(entry.name);
+            this.ledger.release(entry.name.length * 2, 1);
+            unlink(entry);
+        }
+        this.changed(file.parent, now);
+        this.changed(target.parent, now);
+        node.ctimeMs = now;
+        node.revision = published.revision;
+        return published;
+    }
+    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;
+        if (node.entries.size !== (file.node ? 1 : 0))
+            this.fail("ENOTEMPTY", "removeStagedFile", staging.directory.path);
+        this.permission(directory.parent, 3, "removeStagedFile", staging.directory.path);
+        this.permission(node, 3, "removeStagedFile", staging.file.path);
+        directory.parent.entries.delete(directory.name);
+        if (file.node) {
+            node.entries.delete(file.name);
+            this.ledger.release(file.name.length * 2, 1);
+            file.node.nlink--;
+            file.node.ctimeMs = Date.now();
+            file.node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, file.node.revision + 1);
+            this.releaseNode(file.node);
+        }
+        this.ledger.release(directory.name.length * 2, 1);
+        node.nlink = 0;
+        node.ctimeMs = Date.now();
+        node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+        this.releaseNode(node);
+        this.changed(directory.parent);
+    }
+    async prepareDirectory(path, options) {
+        options.signal?.throwIfAborted();
+        const location = this.entry(path, "prepareDirectory", true);
+        this.expectEntry(location.parent, options.parent, path, false);
+        this.expectEntry(location.node, options.expected, path, false);
+        const mode = options.mode === undefined ? undefined : this.mode(options.mode, 0, "prepareDirectory", path);
+        for (const time of [options.atimeMs, options.mtimeMs])
+            if (time !== undefined && !Number.isFinite(time))
+                this.fail("EINVAL", "prepareDirectory", path);
+        let node = location.node;
+        if (!node) {
+            this.permission(location.parent, 3, "prepareDirectory", path);
+            node = this.addNode(location.parent, location.name, () => this.directory(mode ?? 0o777), "prepareDirectory", path);
+        }
+        if (node.type !== "directory")
+            this.fail("ENOTDIR", "prepareDirectory", path);
+        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)
+            node.mtimeMs = options.mtimeMs;
+        node.ctimeMs = Date.now();
+        node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+        return Object.freeze(this.snapshot(node));
+    }
+    async writeFileConditional(path, data, options) {
+        options.signal?.throwIfAborted();
+        const location = this.entry(path, "writeFileConditional", true);
+        this.expectEntry(location.parent, options.parent, path, false);
+        this.expectEntry(location.node, options.expected, path);
+        if (location.node && location.node.type !== "file")
+            this.fail("EINVAL", "writeFileConditional", path);
+        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);
+        const node = location.node;
+        if (this.terminalDot(path))
+            this.fail("EINVAL", "removeEntryConditional", path);
+        if (node === this.root)
+            this.fail("EBUSY", "removeEntryConditional", path);
+        if (node.type !== "file" && node.type !== "symlink" && node.type !== "directory")
+            this.fail("EINVAL", "removeEntryConditional", path);
+        this.permission(location.parent, 3, "removeEntryConditional", path);
+        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();
+        const location = this.entry(path, "removeFileConditional", true);
+        this.expectEntry(location.parent, options.parent, path, false);
+        this.expectEntry(location.node, options.expected, path);
+        const node = location.node;
+        if (node.type !== "file")
+            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();
+        node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+        this.releaseNode(node);
+        this.changed(location.parent);
+    }
+    async removeTreeConditional(path, options) {
+        options.signal?.throwIfAborted();
+        const location = this.entry(path, "removeTreeConditional", true);
+        this.expectEntry(location.parent, options.parent, path, false);
+        this.expectEntry(location.node, options.expected, path, false);
+        if (location.node?.type !== "directory")
+            this.fail("ENOTDIR", "removeTreeConditional", path);
+        this.removeLocation(location, path, "removeTreeConditional", true);
+    }
+    async writeFile(path, data, options = {}) {
+        options.signal?.throwIfAborted();
+        this.writeData(path, data, options, "writeFile");
+    }
+    async appendFile(path, data, options = {}) {
+        options.signal?.throwIfAborted();
+        this.writeData(path, data, { ...options, flag: "a" }, "appendFile");
+    }
+    async stat(path, options = {}) {
+        options.signal?.throwIfAborted();
+        return this.snapshot(this.resolveNode(path, "stat", true));
+    }
+    async lstat(path, options = {}) {
+        options.signal?.throwIfAborted();
+        const stat = this.snapshot(this.resolveNode(path, "lstat", false));
+        ownedStats.set(stat, { filesystem: this, path, root: this.root });
+        return stat;
+    }
+    async *iterateDirectory(path, options = {}) {
+        options.signal?.throwIfAborted();
+        const root = this.root, node = this.resolveNode(path, "iterateDirectory", true);
+        if (node.type !== "directory")
+            this.fail("ENOTDIR", "iterateDirectory", path);
+        this.permission(node, 4, "iterateDirectory", path);
+        const revision = node.revision, ino = node.ino;
+        const check = () => {
+            options.signal?.throwIfAborted();
+            if (this.root !== root || node.ino !== ino || node.revision !== revision || this.resolveNode(path, "iterateDirectory", true) !== node)
+                this.fail("EBUSY", "iterateDirectory", path);
+            this.permission(node, 4, "iterateDirectory", path);
+        };
+        node.atimeMs = Date.now();
+        for (const [name, entry] of node.entries) {
+            check();
+            yield { name, type: entry.type };
+        }
+        check();
+    }
+    async readdir(path, options = {}) {
+        const limit = directoryEntryLimit(options, path);
+        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();
+        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);
+    }
+    tryMkdirFastSync(path, recursive, mode) {
+        try {
+            this.validatePath(path, "mkdir");
+            const resolvedMode = this.mode(mode, 0o777, "mkdir", path);
+            if (recursive) {
+                const node = this.resolve(path, "mkdir", { createDirectories: resolvedMode }).node;
+                return node.type === "directory";
+            }
+            const location = this.resolve(path.replace(/\/+$/, "") || "/", "mkdir", { allowMissing: true, followFinal: false });
+            if (location.node)
+                return false;
+            this.permission(location.parent, 3, "mkdir", path);
+            this.addNode(location.parent, location.name, () => this.directory(resolvedMode), "mkdir", path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    tryRmFastSync(path, recursive, force) {
+        if (activeConditionalMutations.has(this.identityScope))
+            return false;
+        try {
+            let location;
+            try {
+                location = this.entry(path, "rm", false);
+            }
+            catch (error) {
+                if (force && error instanceof FsError && error.code === "ENOENT")
+                    return true;
+                return false;
+            }
+            this.removeLocation(location, path, "rm", recursive);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    mkdir(path, options = {}) {
+        try {
+            options.signal?.throwIfAborted();
+            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);
+            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);
+        }
+    }
+    async rmdir(path, options = {}) {
+        options.signal?.throwIfAborted();
+        const location = this.entry(path, "rmdir");
+        const node = location.node;
+        if (this.terminalDot(path))
+            this.fail("EINVAL", "rmdir", path);
+        if (node === this.root)
+            this.fail("EBUSY", "rmdir", path);
+        if (node.type !== "directory")
+            this.fail("ENOTDIR", "rmdir", path);
+        this.permission(location.parent, 3, "rmdir", path);
+        if (node.entries.size > 0)
+            this.fail("ENOTEMPTY", "rmdir", path);
+        location.parent.entries.delete(location.name);
+        this.ledger.release(location.name.length * 2, 1);
+        node.nlink = 0;
+        node.ctimeMs = Date.now();
+        node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+        this.releaseNode(node);
+        this.changed(location.parent);
+    }
+    rm(path, options = {}) {
+        try {
+            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) {
+            return Promise.reject(error);
+        }
+    }
+    removeLocation(location, path, syscall, recursive, now = Date.now()) {
+        const node = location.node;
+        if (this.terminalDot(path))
+            this.fail("EINVAL", syscall, path);
+        if (node === this.root)
+            this.fail("EBUSY", syscall, path);
+        this.permission(location.parent, 3, syscall, path);
+        if (node.type === "directory" && !recursive)
+            this.fail("EISDIR", syscall, path);
+        const cache = memoryCaches.get(this.ledger);
+        cache.clearWrites();
+        const removed = sharedRemovedScratch;
+        sharedRemovedLen = 1;
+        removed[0] = node;
+        sharedRemovedKeyChars = 0;
+        sharedRemovedKeyEntries = 0;
+        try {
+            for (let index = 0; index < sharedRemovedLen; index++) {
+                const entry = removed[index];
+                if (entry.type === "directory" && entry.entries.size > 0) {
+                    this.permission(entry, 7, syscall, path);
+                    entry.entries.forEach(collectRemovedChild);
+                }
+            }
+            location.parent.entries.delete(location.name);
+            this.ledger.release((location.name.length + sharedRemovedKeyChars) * 2, 1 + sharedRemovedKeyEntries);
+            const totalRemoved = sharedRemovedLen;
+            for (let i = 0; i < totalRemoved; i++) {
+                const entry = removed[i];
+                removed[i] = DUMMY_POOL_FILE_NODE;
+                if (entry.type === "directory") {
+                    entry.entries.clear();
+                }
+                entry.nlink--;
+                if (entry.nlink !== 0 || entry.references !== 0) {
+                    entry.ctimeMs = now;
+                    entry.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, entry.revision + 1);
+                }
+                this.releaseNode(entry);
+            }
+        }
+        finally {
+            for (let i = 0; i < sharedRemovedLen; i++)
+                removed[i] = DUMMY_POOL_FILE_NODE;
+            sharedRemovedLen = 0;
+        }
+        this.changed(location.parent, now);
+    }
+    unlink(path, options = {}) {
+        // Do not allow an untyped recursive option to widen final-entry removal.
+        return this.rm(path, { ...(options.signal === undefined ? {} : { signal: options.signal }) });
+    }
+    async rename(source, destination, options = {}) {
+        options.signal?.throwIfAborted();
+        try {
+            const origin = this.entry(source, "rename");
+            const target = this.entry(destination, "rename", true);
+            const node = origin.node;
+            if (this.terminalDot(source) || this.terminalDot(destination))
+                this.fail("EINVAL", "rename", source, destination);
+            if (node === this.root || target.node === this.root)
+                this.fail("EBUSY", "rename", source, destination);
+            if (destination.endsWith("/") && node.type !== "directory")
+                this.fail("ENOTDIR", "rename", source, destination);
+            if (options.noReplace && target.node)
+                this.fail("EEXIST", "rename", source, destination);
+            if (target.node === node)
+                return;
+            if (node.type === "directory" && target.path.startsWith(`${origin.path}/`))
+                this.fail("EINVAL", "rename", source, destination);
+            this.permission(origin.parent, 3, "rename", source);
+            this.permission(target.parent, 3, "rename", destination);
+            if (target.node) {
+                if (node.type === "directory" && target.node.type !== "directory")
+                    this.fail("ENOTDIR", "rename", source, destination);
+                if (node.type !== "directory" && target.node.type === "directory")
+                    this.fail("EISDIR", "rename", source, destination);
+                if (target.node.type === "directory" && target.node.entries.size > 0)
+                    this.fail("ENOTEMPTY", "rename", source, destination);
+            }
+            const nameGrowth = target.node ? 0 : (target.name.length - origin.name.length) * 2;
+            this.ledger.reserve(Math.max(0, nameGrowth), 0, "rename", source);
+            try {
+                target.parent.entries.set(target.name, node);
+            }
+            catch (error) {
+                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);
+                target.node.nlink--;
+                target.node.ctimeMs = Date.now();
+                target.node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, target.node.revision + 1);
+                this.releaseNode(target.node);
+            }
+            else if (nameGrowth < 0)
+                this.ledger.release(-nameGrowth, 0);
+            this.changed(origin.parent);
+            this.changed(target.parent);
+            node.ctimeMs = Date.now();
+            node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+        }
+        catch (error) {
+            if (error instanceof FsError)
+                throw new FsError(error.code, { syscall: "rename", path: source, dest: destination, cause: error });
+            throw error;
+        }
+    }
+    async copyFile(source, destination, options = {}) {
+        options.signal?.throwIfAborted();
+        try {
+            const origin = this.file(source, "copyFile");
+            this.permission(origin, 4, "copyFile", source);
+            const target = this.resolve(destination, "copyFile", { followFinal: !options.exclusive, allowMissing: true });
+            if (target.node && options.exclusive)
+                this.fail("EEXIST", "copyFile", source, destination);
+            if (target.node === origin)
+                this.fail("EINVAL", "copyFile", source, destination);
+            const node = this.writeData(destination, origin.data, { mode: origin.mode & 0o7777, flag: options.exclusive ? "wx" : "w" }, "copyFile");
+            node.mode = origin.mode;
+            origin.atimeMs = Date.now();
+        }
+        catch (error) {
+            if (error instanceof FsError)
+                throw new FsError(error.code, { syscall: "copyFile", path: source, dest: destination, cause: error });
+            throw error;
+        }
+    }
+    async realpath(path, options = {}) {
+        options.signal?.throwIfAborted();
+        return this.resolve(path, "realpath").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();
+        const node = this.resolve(path, "readlink", { followFinal: false }).node;
+        if (node.type !== "symlink")
+            this.fail("EINVAL", "readlink", path);
+        return node.target;
+    }
+    async symlink(target, path, options = {}) {
+        options.signal?.throwIfAborted();
+        this.validatePath(target, "symlink");
+        const location = this.resolve(path, "symlink", { followFinal: false, allowMissing: true });
+        if (location.node)
+            this.fail("EEXIST", "symlink", path);
+        this.permission(location.parent, 3, "symlink", path);
+        this.addNode(location.parent, location.name, () => ({
+            ...this.metadata(typeModes.symlink | 0o777), type: "symlink", target,
+        }), "symlink", path, target.length * 2);
+    }
+    async link(existingPath, newPath, options = {}) {
+        options.signal?.throwIfAborted();
+        const node = this.resolve(existingPath, "link", { followFinal: false }).node;
+        if (node.type === "directory")
+            this.fail("EPERM", "link", existingPath, newPath);
+        const target = this.resolve(newPath, "link", { followFinal: false, allowMissing: true });
+        if (target.node)
+            this.fail("EEXIST", "link", existingPath, newPath);
+        this.permission(target.parent, 3, "link", newPath);
+        this.ledger.reserve(target.name.length * 2, 1, "link", newPath);
+        try {
+            target.parent.entries.set(target.name, node);
+        }
+        catch (error) {
+            this.ledger.release(target.name.length * 2, 1);
+            throw error;
+        }
+        node.nlink++;
+        node.ctimeMs = Date.now();
+        node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+        this.changed(target.parent);
+    }
+    async chmod(path, mode, options = {}) {
+        options.signal?.throwIfAborted();
+        const permissions = this.mode(mode, 0, "chmod", path);
+        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);
+    }
+    async utimes(path, atimeMs, mtimeMs, options = {}) {
+        options.signal?.throwIfAborted();
+        if (!Number.isFinite(atimeMs) || !Number.isFinite(mtimeMs))
+            this.fail("EINVAL", "utimes", path);
+        const node = this.resolve(path, "utimes").node;
+        node.atimeMs = atimeMs;
+        node.mtimeMs = mtimeMs;
+        node.ctimeMs = Date.now();
+        node.revision = Math.min(Number.MAX_SAFE_INTEGER + 1, node.revision + 1);
+    }
+    async truncate(path, length = 0, options = {}) {
+        options.signal?.throwIfAborted();
+        this.integer(length, "truncate", path);
+        const node = this.file(path, "truncate");
+        this.permission(node, 2, "truncate", path);
+        this.resizeNode(node, length, "truncate", path);
+    }
+    resizeNode(node, length, syscall, path) {
+        this.admitSize(node, length, syscall, path);
+        const data = this.allocate(length, syscall, path);
+        try {
+            data.data.set(node.data.subarray(0, length));
+        }
+        catch (error) {
+            data.release();
+            throw error;
+        }
+        this.replaceData(node, data);
+        this.changed(node);
+    }
+    async openResizeFile(path, options = {}) {
+        options.signal?.throwIfAborted();
+        if (!stockRetainedResize(this))
+            throw new FsError("ENOTSUP", { syscall: "openResizeFile", path });
+        const location = this.resolve(path, "openResizeFile", { allowMissing: options.create === true, resizeCreate: options.create ?? false });
+        let mode = 0o666;
+        if (location.node) {
+            if (location.node.type !== "file")
+                this.fail("EISDIR", "openResizeFile", path);
+            this.permission(location.node, 2, "openResizeFile", path);
+        }
+        else {
+            this.permission(location.parent, 3, "openResizeFile", path);
+            mode = this.mode(options.mode, mode, "openResizeFile", path);
+        }
+        this.ledger.reserve(path.length * 2, 1, "openResizeFile", path);
+        let node;
+        try {
+            node = this.openWrite(path, {}, "openResizeFile", { location, mode, append: false });
+            node.references++;
+        }
+        catch (error) {
+            this.ledger.release(path.length * 2, 1);
+            throw error;
+        }
+        const snapshot = this.snapshot.bind(this);
+        const integer = this.integer.bind(this);
+        const resizeNode = this.resizeNode.bind(this);
+        const releaseReference = this.releaseReference.bind(this);
+        let closing;
+        const current = (signal, syscall) => {
+            signal?.throwIfAborted();
+            if (!node)
+                throw new FsError("EBADF", { syscall, path });
+            return node;
+        };
+        return {
+            async stat(options = {}) { return snapshot(current(options.signal, "fstat")); },
+            async seekEnd(options = {}) { return BigInt(current(options.signal, "lseek").data.byteLength); },
+            async truncate(length, options = {}) {
+                const file = current(options.signal, "ftruncate");
+                integer(length, "ftruncate", path);
+                resizeNode(file, length, "ftruncate", path);
+            },
+            close() {
+                if (!closing) {
+                    const retained = node;
+                    node = undefined;
+                    closing = Promise.resolve().then(() => { if (retained)
+                        releaseReference(retained, path); });
+                }
+                return closing;
+            },
+        };
+    }
+    async openReadFile(path, options = {}) {
+        const signal = options.signal;
+        signal?.throwIfAborted();
+        const allowDirectory = options.allowDirectory === true;
+        signal?.throwIfAborted();
+        const unsupported = () => { throw new FsError("ENOTSUP", { syscall: "openReadFile", path }); };
+        const owner = ownedStores.get(this);
+        if (!owner || Object.getPrototypeOf(this) !== MemoryFileSystem.prototype
+            || Object.getOwnPropertyDescriptor(this, "root")?.value !== owner.root
+            || Object.getOwnPropertyDescriptor(this, "ledger")?.value !== owner.ledger)
+            unsupported();
+        for (const name of ["openReadFile", "readFile", "readStream", "stat", "lstat", "realpath", "access",
+            "file", "resolve", "permission", "validatePath", "fail", "snapshot", "integer", "releaseReference", "releaseNode"]) {
+            const descriptor = Object.getOwnPropertyDescriptor(this, name)
+                ?? Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, name);
+            if (!descriptor || !("value" in descriptor) || descriptor.value !== memoryImplementation[name]?.value)
+                unsupported();
+        }
+        const capabilities = Object.getOwnPropertyDescriptor(this, "capabilities");
+        const retainedRead = capabilities === undefined
+            ? Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, "capabilities")?.get === memoryImplementation.capabilities?.get
+            : capabilities.value?.retainedRead;
+        signal?.throwIfAborted();
+        if (retainedRead !== true)
+            unsupported();
+        const selected = allowDirectory ? this.resolve(path, "openReadFile").node : this.file(path, "openReadFile");
+        if (selected.type !== "file" && selected.type !== "directory")
+            this.fail("EISDIR", "openReadFile", path);
+        let node = selected;
+        this.permission(node, 4, "openReadFile", path);
+        signal?.throwIfAborted();
+        this.ledger.reserve(path.length * 2, 1, "openReadFile", path);
+        node.references++;
+        const snapshot = this.snapshot.bind(this);
+        const integer = this.integer.bind(this);
+        const releaseReference = this.releaseReference.bind(this);
+        let closing;
+        const current = (signal, syscall) => {
+            signal?.throwIfAborted();
+            if (!node)
+                throw new FsError("EBADF", { syscall, path });
+            return node;
+        };
+        return {
+            async stat(options = {}) {
+                return snapshot(current(options.signal, "fstat"));
+            },
+            async seekEnd(options = {}) {
+                const file = current(options.signal, "lseek");
+                return file.type === "directory" ? ext4HtreeEof64 : BigInt(file.data.byteLength);
+            },
+            async read(position, maxBytes, options = {}) {
+                const file = current(options.signal, "read");
+                integer(position, "read", path);
+                integer(maxBytes, "read", path);
+                if (maxBytes === 0 || maxBytes > Number.MAX_SAFE_INTEGER - position) {
+                    throw new FsError("EINVAL", { syscall: "read", path });
+                }
+                if (file.type === "directory")
+                    throw new FsError("EISDIR", { syscall: "read", path });
+                const bytes = file.data.slice(position, position + maxBytes);
+                file.atimeMs = Date.now();
+                return bytes;
+            },
+            close() {
+                if (node) {
+                    releaseReference(node, path);
+                    node = undefined;
+                }
+                closing ??= Promise.resolve();
+                return closing;
+            },
+        };
+    }
+    readStream(path, options = {}) {
+        return new MemoryReadStream(this, path, options);
+    }
+    async writeStream(path, source, options = {}) {
+        options.signal?.throwIfAborted();
+        this.validatePath(path, "writeStream");
+        this.ledger.reserve(path.length * 2, 1, "writeStream", path);
+        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) {
+                this.replaceData(node, new MemoryAllocation(new Uint8Array(), this.ledger));
+                this.changed(node);
+            }
+            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);
+                if (!append)
+                    position += chunk.byteLength;
+            }
+            options.signal?.throwIfAborted();
+        }
+        finally {
+            if (node)
+                this.releaseReference(node, path);
+            else
+                this.ledger.release(path.length * 2, 1);
+        }
+    }
+}
+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 (!isStockMemoryMethods(filesystem, stockDescriptorWriteMethodNames, true))
+        return false;
+    const owner = ownedStores.get(filesystem);
+    const capDesc = Object.getOwnPropertyDescriptor(filesystem, "capabilities");
+    return (capDesc === undefined && Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, "capabilities")?.get === memoryImplementation.capabilities?.get) || (!!capDesc && "value" in capDesc && capDesc.value === owner.capabilities);
+}
+function stockRetainedResize(filesystem) {
+    if (!stockDescriptorWrite(filesystem) || !isStockMemoryMethods(filesystem, stockRetainedResizeMethodNames, false))
+        return false;
+    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;
+    }
+    reset(fs, path, node, append) {
+        this.fs = fs;
+        this.path = path;
+        this.node = node;
+        this.append = append;
+        this.position = 0;
+        this.closed = false;
+    }
+    writeRangeSync(src, len, signal) {
+        signal?.throwIfAborted();
+        if (this.closed)
+            throw new FsError("EBADF", { syscall: "write", path: this.path });
+        if (len === 0)
+            return;
+        const pos = this.append ? this.node.byteLength : this.position;
+        const now = Date.now();
+        this.fs.writeAtRange(this.node, src, len, pos, "write", this.path, now);
+        if (!this.append)
+            this.position = pos + len;
+    }
+    writeImmutableSync(immutableData, signal) {
+        signal?.throwIfAborted();
+        if (this.closed)
+            throw new FsError("EBADF", { syscall: "write", path: this.path });
+        const len = immutableData.byteLength;
+        if (len === 0)
+            return;
+        const mem = this.fs;
+        if (!this.append &&
+            this.position === 0 &&
+            this.node.byteLength === 0 &&
+            this.node.allocation === DUMMY_POOL_ALLOCATION &&
+            mem.ledger.hasInfiniteRetained &&
+            mem.ledger.hasInfiniteFileBytes &&
+            mem.ledger.limits.maxBytes === undefined) {
+            const now = Date.now();
+            this.node.byteLength = len;
+            this.node.view = immutableData;
+            this.node.sourceRef = immutableData;
+            this.position = len;
+            mem.totalBytes += len;
+            mem.changed(this.node, now);
+            return;
+        }
+        this.writeRangeSync(immutableData, len, signal);
+    }
+    writeSync(chunk, signal) {
+        this.writeRangeSync(chunk, chunk.byteLength, signal);
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const fs = this.fs;
+        const node = this.node;
+        const path = this.path;
+        this.fs = undefined;
+        this.node = DUMMY_POOL_FILE_NODE;
+        this.path = "";
+        if (node.nlink > 0 && node.references === 1) {
+            node.references = 0;
+            fs.ledger.release(path.length * 2, 1);
+        }
+        else {
+            fs.releaseReference(node, path);
+        }
+        if (redirectHandlePool.handle === undefined) {
+            redirectHandlePool.handle = this;
+        }
+    }
+}
+const redirectHandlePool = { handle: undefined };
+let _lastRedirectSlice1Path = "";
+let _lastRedirectSlice1Name = "";
+let _lastFileSlice1Path = "";
+let _lastFileSlice1Name = "";
+export function tryOpenMemoryRedirectHandleSync(filesystem, path, append, mode, signal) {
+    const mem = filesystem;
+    const owner = mem._owner ?? ownedStores.get(mem);
+    if (!owner ||
+        mem.symlinkCount !== 0 ||
+        mem.capabilities !== owner.capabilities ||
+        (activeConditionalMutations.size > 0 && activeConditionalMutations.has(mem.identityScope)) ||
+        !isStockMemoryMethods(mem, openRedirectFastMethodNames, false) ||
+        !isCleanAbsolutePath(path) ||
+        path === "/" ||
+        path === "/dev" ||
+        path.startsWith("/dev/")) {
+        return undefined;
+    }
+    signal?.throwIfAborted();
+    validatePath(path, owner.ledger.limits);
+    const validMode = (mode & 0o777) === mode
+        ? mode
+        : mem.mode(mode, 0o666, "open", path);
+    const memInternal = mem;
+    let parent = memInternal.root;
+    let start = 1;
+    let name = "";
+    while (true) {
+        memInternal.permission(parent, 1, "open", path);
+        const slash = path.indexOf("/", start);
+        if (slash === -1) {
+            name = start === 1
+                ? (path === _lastRedirectSlice1Path ? _lastRedirectSlice1Name : (_lastRedirectSlice1Path = path, _lastRedirectSlice1Name = path.slice(1)))
+                : path.slice(start);
+            if (exceedsComponentByteLimit(name))
+                memInternal.fail("ENAMETOOLONG", "open", path);
+            break;
+        }
+        const seg = slicePathSegment(path, start, slash);
+        if (exceedsComponentByteLimit(seg))
+            memInternal.fail("ENAMETOOLONG", "open", path);
+        const next = parent.entries.get(seg);
+        if (!next)
+            memInternal.fail("ENOENT", "open", path);
+        if (next.type !== "directory")
+            memInternal.fail("ENOTDIR", "open", path);
+        parent = next;
+        start = slash + 1;
+    }
+    const existing = parent.entries.getForWrite(name);
+    const ledger = memInternal.ledger;
+    let node;
+    if (existing !== undefined) {
+        if (existing.type !== "file")
+            memInternal.fail("EISDIR", "open", path);
+        memInternal.permission(existing, 2, "open", path);
+        ledger.reserve(path.length * 2, 1, "open", path);
+        node = existing;
+        if (!append) {
+            try {
+                memInternal.resizeNode(node, 0, "open", path);
+            }
+            catch (error) {
+                ledger.release(path.length * 2, 1);
+                throw error;
+            }
+        }
+        node.references++;
+    }
+    else {
+        memInternal.permission(parent, 3, "open", path);
+        const refBytes = path.length * 2;
+        const nameBytes = name.length * 2;
+        if (ledger.hasInfiniteRetained && ledger.hasInfiniteFileBytes) {
+            ledger.reserve(refBytes + nameBytes, 3, "open", path);
+        }
+        else {
+            ledger.reserve(refBytes, 1, "open", path);
+            try {
+                ledger.fileSize(0, "open", path);
+                ledger.reserve(nameBytes, 2, "open", path);
+            }
+            catch (error) {
+                ledger.release(refBytes, 1);
+                throw error;
+            }
+        }
+        const cache = mem._cache;
+        cache.clearWrites();
+        const now = Date.now();
+        const fileMode = typeModes.file | validMode;
+        let newNode;
+        if (sharedFileNodePoolLen > 0) {
+            newNode = sharedFileNodePool[--sharedFileNodePoolLen];
+            sharedFileNodePool[sharedFileNodePoolLen] = DUMMY_POOL_FILE_NODE;
+        }
+        else {
+            newNode = cache.files.pop();
+        }
+        if (newNode) {
+            newNode.mode = fileMode;
+            newNode.ino = memInternal.nextInode++;
+            if (newNode.nlink !== 1)
+                newNode.nlink = 1;
+            newNode.references = 1;
+            if (newNode.revision !== 0)
+                newNode.revision = 0;
+            newNode.atimeMs = now;
+            newNode.mtimeMs = now;
+            newNode.ctimeMs = now;
+            newNode.birthtimeMs = now;
+            newNode.byteLength = 0;
+            newNode.view = EMPTY_ALLOC_BYTES;
+            newNode.allocation = DUMMY_POOL_ALLOCATION;
+        }
+        else {
+            newNode = new MemoryFileNode(fileMode, memInternal.nextInode++, now, 0, DUMMY_POOL_ALLOCATION, EMPTY_ALLOC_BYTES);
+            newNode.references = 1;
+        }
+        const prevNlink = parent.cachedNlinkRev === parent.revision ? parent.cachedNlink : (parent.entries.size === 0 ? 2 : undefined);
+        const entries = parent.entries;
+        if (entries._missKey === name && entries._next < entries._keys.length) {
+            const entryIdx = entries._next++;
+            entries._table[entries._missSlot] = entryIdx;
+            entries._keys[entryIdx] = name;
+            entries._vals[entryIdx] = newNode;
+            entries.size++;
+            entries._missKey = "";
+        }
+        else {
+            entries.set(name, newNode);
+        }
+        mem.mutationTick = (mem.mutationTick + 1) | 0;
+        parent.revision = parent.revision < 1073741823 ? (parent.revision + 1) | 0 : Math.min(Number.MAX_SAFE_INTEGER + 1, parent.revision + 1);
+        parent.mtimeMs = parent.ctimeMs = now;
+        if (prevNlink !== undefined) {
+            parent.cachedNlink = prevNlink;
+            parent.cachedNlinkRev = parent.revision;
+        }
+        node = newNode;
+    }
+    const handle = redirectHandlePool.handle;
+    if (handle !== undefined) {
+        redirectHandlePool.handle = undefined;
+        handle.reset(mem, path, node, append);
+        return handle;
+    }
+    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;
+}
+export function tryResolveMemoryDevicePath(filesystem, path, resizeCreate) {
+    const mem = filesystem;
+    if (!ownedStores.has(mem) || mem.symlinkCount !== 0 || !isStockMemoryMethods(mem, deviceFastMethodNames, false))
+        return undefined;
+    validatePath(path, ownedStores.get(mem).ledger.limits);
+    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 = slicePathSegment(path, start, path.length);
+            if (exceedsComponentByteLimit(name))
+                return undefined;
+            if (resizeCreate === false && !current.entries.has(name))
+                return undefined;
+            return path;
+        }
+        const name = slicePathSegment(path, 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 ? slicePathSegment(path, remStart, path.length) : slicePathSegment(path, 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;
+    }
+}
+const cachedMethodValuesMap = /* @__PURE__ */ new WeakMap();
+function getExpectedMethodValues(names) {
+    let vals = cachedMethodValuesMap.get(names);
+    if (!vals) {
+        vals = names.map(name => memoryImplementation[name]?.value);
+        cachedMethodValuesMap.set(names, vals);
+    }
+    return vals;
+}
+const hasOwn = Object.prototype.hasOwnProperty;
+function isStockMemoryMethods(mem, names, checkRootAccessor = true) {
+    const owner = mem?._owner ?? ownedStores.get(mem);
+    if (!owner || Object.getPrototypeOf(mem) !== MemoryFileSystem.prototype || ownedStores.get(mem) !== owner)
+        return false;
+    if (checkRootAccessor) {
+        const rootDesc = Object.getOwnPropertyDescriptor(mem, "root");
+        if (!rootDesc || !("value" in rootDesc) || rootDesc.value !== owner.root)
+            return false;
+    }
+    else if (mem.root !== owner.root) {
+        return false;
+    }
+    const vals = getExpectedMethodValues(names);
+    const proto = MemoryFileSystem.prototype;
+    for (let i = 0; i < names.length; i++) {
+        const name = names[i];
+        const expected = vals[i];
+        if (hasOwn.call(mem, name)) {
+            const descriptor = Object.getOwnPropertyDescriptor(mem, name);
+            if (!descriptor || !("value" in descriptor) || descriptor.value !== expected)
+                return false;
+        }
+        else if (proto[name] !== expected) {
+            return false;
+        }
+    }
+    return true;
+}
+let lastReadViewData;
+let lastReadViewSourceRef;
+export function getLastReadMemoryFileSourceRef(view) {
+    const ref = view === lastReadViewData?.deref() ? lastReadViewSourceRef?.deref() : undefined;
+    lastReadViewData = undefined;
+    lastReadViewSourceRef = undefined;
+    return ref;
+}
+export function tryReadMemoryFileViewSync(filesystem, path, maxBytes, signal, captureSourceRef = false, beforeRead) {
+    // A capture belongs only to the most recent read, including failed/fallback reads.
+    lastReadViewData = undefined;
+    lastReadViewSourceRef = undefined;
+    const mem = filesystem;
+    if (mem._owner === undefined || !isStockMemoryMethods(mem, readFileFastMethodNames, false))
+        return undefined;
+    signal?.throwIfAborted();
+    beforeRead?.();
+    if (maxBytes !== undefined && maxBytes !== Infinity)
+        mem.integer(maxBytes, "readFile", path);
+    const node = mem.file(path, "readFile");
+    mem.permission(node, 4, "readFile", path);
+    const data = node.data;
+    if (maxBytes !== undefined && data.byteLength > maxBytes)
+        mem.fail("EFBIG", "readFile", path);
+    node.atimeMs = Date.now();
+    if (captureSourceRef && node.revision === 0) {
+        lastReadViewData = new WeakRef(data);
+        lastReadViewSourceRef = node.sourceRef === undefined ? undefined : new WeakRef(node.sourceRef);
+    }
+    return data;
+}
+let segCache0 = "";
+let segCache1 = "";
+let segCache2 = "";
+let segCache3 = "";
+let segCacheCursor = 0;
+function slicePathSegment(path, start, end) {
+    const len = end - start;
+    if (len <= 0)
+        return "";
+    if (len === 1)
+        return String.fromCharCode(path.charCodeAt(start));
+    if (len <= 16) {
+        const c0 = path.charCodeAt(start);
+        if (segCache0.length === len && segCache0.charCodeAt(0) === c0) {
+            let ok = true;
+            for (let i = 1; i < len; i++)
+                if (path.charCodeAt(start + i) !== segCache0.charCodeAt(i)) {
+                    ok = false;
+                    break;
+                }
+            if (ok)
+                return segCache0;
+        }
+        if (segCache1.length === len && segCache1.charCodeAt(0) === c0) {
+            let ok = true;
+            for (let i = 1; i < len; i++)
+                if (path.charCodeAt(start + i) !== segCache1.charCodeAt(i)) {
+                    ok = false;
+                    break;
+                }
+            if (ok)
+                return segCache1;
+        }
+        if (segCache2.length === len && segCache2.charCodeAt(0) === c0) {
+            let ok = true;
+            for (let i = 1; i < len; i++)
+                if (path.charCodeAt(start + i) !== segCache2.charCodeAt(i)) {
+                    ok = false;
+                    break;
+                }
+            if (ok)
+                return segCache2;
+        }
+        if (segCache3.length === len && segCache3.charCodeAt(0) === c0) {
+            let ok = true;
+            for (let i = 1; i < len; i++)
+                if (path.charCodeAt(start + i) !== segCache3.charCodeAt(i)) {
+                    ok = false;
+                    break;
+                }
+            if (ok)
+                return segCache3;
+        }
+        const sliced = path.slice(start, end);
+        const slot = segCacheCursor;
+        segCacheCursor = (slot + 1) & 3;
+        if (slot === 0)
+            segCache0 = sliced;
+        else if (slot === 1)
+            segCache1 = sliced;
+        else if (slot === 2)
+            segCache2 = sliced;
+        else
+            segCache3 = sliced;
+        return sliced;
+    }
+    return path.slice(start, end);
+}
+export function tryGetMemoryDirectoryEntryNamesSync(filesystem, path) {
+    const mem = filesystem;
+    const owner = ownedStores.get(mem);
+    if (!owner || mem.symlinkCount !== 0 || !isStockMemoryMethods(mem, readFileFastMethodNames, false))
+        return undefined;
+    validatePath(path, owner.ledger.limits);
+    const root = mem.root;
+    if (path === "/") {
+        if (((root.mode >> 6) & 5) !== 5)
+            return undefined;
+        return root.entries;
+    }
+    if (!isCleanAbsolutePath(path) || path === "/dev" || path.startsWith("/dev/"))
+        return undefined;
+    const cache = memoryCaches.get(owner.ledger);
+    const fastDir = cache?.lastFastDirNode;
+    const fastPrefix = cache?.lastFastDirPrefix;
+    if (fastDir !== undefined &&
+        fastDir.nlink !== 0 &&
+        ((fastDir.mode >> 6) & 5) === 5 &&
+        fastPrefix !== undefined &&
+        (fastPrefix === path || (fastPrefix.length === path.length + 1 && fastPrefix.charCodeAt(path.length) === 47 && fastPrefix.startsWith(path)))) {
+        return fastDir.entries;
+    }
+    let current = root;
+    let start = 1;
+    while (true) {
+        if (((current.mode >> 6) & 1) !== 1)
+            return undefined;
+        const slash = path.indexOf("/", start);
+        if (slash === -1) {
+            const next = current.entries.getSubstr(path, start, path.length);
+            if (!next || next.type !== "directory" || ((next.mode >> 6) & 5) !== 5)
+                return undefined;
+            return next.entries;
+        }
+        const next = current.entries.getSubstr(path, 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, dirPrefixHint) {
+    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();
+    validatePath(path, owner.ledger.limits);
+    const validMode = mem.mode(mode, 0o777, "mkdir", path);
+    if (recursive) {
+        let current = owner.root;
+        let start = 1;
+        while (true) {
+            mem.permission(current, 1, "mkdir", path);
+            const slash = path.indexOf("/", start);
+            const seg = slash === -1 ? slicePathSegment(path, start, path.length) : slicePathSegment(path, start, slash);
+            if (exceedsComponentByteLimit(seg))
+                mem.fail("ENAMETOOLONG", "mkdir", path);
+            let next = current.entries.get(seg);
+            if (!next) {
+                mem.permission(current, 3, "mkdir", path);
+                next = mem.addDirectoryNode(current, seg, validMode, "mkdir", path, Date.now());
+            }
+            else if (next.type !== "directory") {
+                mem.fail(slash === -1 ? "EEXIST" : "ENOTDIR", "mkdir", path);
+            }
+            if (slash === -1) {
+                if (dirPrefixHint !== undefined) {
+                    mem._cache.lastFastDirPrefix = dirPrefixHint;
+                    mem._cache.lastFastDirNode = next;
+                }
+                break;
+            }
+            current = next;
+            start = slash + 1;
+        }
+        return true;
+    }
+    const location = mem.resolve(path, "mkdir", sharedAllowMissingNoFollowOptions);
+    if (location.node)
+        mem.fail("EEXIST", "mkdir", path);
+    mem.permission(location.parent, 3, "mkdir", path);
+    mem.addDirectoryNode(location.parent, location.name, validMode, "mkdir", path, Date.now());
+    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();
+    validatePath(path, owner.ledger.limits);
+    let current = owner.root;
+    let start = 1;
+    let targetNode;
+    let targetName = "";
+    while (true) {
+        mem.permission(current, 1, "rm", path);
+        const slash = path.indexOf("/", start);
+        if (slash === -1) {
+            targetName = slicePathSegment(path, start, path.length);
+            if (exceedsComponentByteLimit(targetName))
+                mem.fail("ENAMETOOLONG", "rm", path);
+            targetNode = current.entries.get(targetName);
+            if (!targetNode)
+                return true;
+            break;
+        }
+        const seg = slicePathSegment(path, start, slash);
+        if (exceedsComponentByteLimit(seg))
+            mem.fail("ENAMETOOLONG", "rm", path);
+        const next = current.entries.get(seg);
+        if (!next)
+            return true;
+        if (next.type !== "directory")
+            mem.fail("ENOTDIR", "rm", path);
+        current = next;
+        start = slash + 1;
+    }
+    sharedFastLocation.node = targetNode;
+    sharedFastLocation.parent = current;
+    sharedFastLocation.name = targetName;
+    sharedFastLocation.path = path;
+    try {
+        mem.removeLocation(sharedFastLocation, path, "rm", true, Date.now());
+    }
+    finally {
+        sharedFastLocation.node = undefined;
+        sharedFastLocation.parent = DUMMY_POOL_DIR_NODE;
+        sharedFastLocation.name = "";
+        sharedFastLocation.path = "";
+    }
+    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;
+}
+const _memHooks = (globalThis.__safeBashMemHooks ??= { protos: new Set(), byProto: new Map() });
+_memHooks.protos.add(MemoryFileSystem.prototype);
+_memHooks.byProto.set(MemoryFileSystem.prototype, {
+    tryGetMemoryDirectoryEntryNamesSync,
+    tryReadMemoryFileViewSync,
+    tryResolveMemoryDevicePath,
+    tryOpenMemoryRedirectHandleSync,
+    tryWriteMemoryFileSync,
+    tryMkdirMemorySync,
+    tryRmRfMemorySync,
+    tryWriteMemoryFileInDirSync,
+});
+_memHooks.isCleanAbsolutePath = isCleanAbsolutePath;
+_memHooks.bindConditionalMutation = bindConditionalMutation;