@effect-vfs/core 0.7.0 → 0.7.1

package/dist/internal/virtualFileSystem.js

@@ -1,12 +1,14 @@
 import * as Arr from "effect/Array";
 import * as ByteSize from "effect/ByteSize";
 import * as Clock from "effect/Clock";
+import * as Context from "effect/Context";
 import * as Crypto from "effect/Crypto";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
-import * as Encoding from "effect/Encoding";
+import * as Hex from "effect/encoding/Hex";
 import * as Exit from "effect/Exit";
 import * as Match from "effect/Match";
+import * as MutableRef from "effect/MutableRef";
 import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
@@ -84,100 +86,115 @@ const encoder = new TextEncoder();
 const accessDue = (metadata, now) => now !== metadata.atimeNs && (metadata.atimeNs <= metadata.mtimeNs || metadata.atimeNs <= metadata.ctimeNs ||
     now - metadata.atimeNs >= RELATIME_INTERVAL_NS);
 const refreshDue = (read) => read.access !== undefined && accessDue(read.access.node.metadata, read.access.now);
-// Builds the next volume value for one transition. Reads see pending writes; a discarded draft leaves the
-// base untouched, so an interrupted or failed transition needs no rollback.
-class Draft {
-    base;
-    owner = Symbol();
-    pending = new Map();
-    opens;
-    nextInode;
-    changed = false;
-    finished;
-    revision;
-    entries;
-    usedBytes;
-    events = [];
-    after = [];
-    removed = [];
-    constructor(base) {
-        this.base = base;
-        this.nextInode = base.nextInode;
-        this.revision = base.revision + 1n;
-        this.entries = base.entries;
-        this.usedBytes = base.usedBytes;
-    }
-    get(ino) {
-        const pending = this.pending.get(ino);
-        return pending !== undefined || this.pending.has(ino) ? pending : InodeTable.get(this.base.inodes, ino);
-    }
-    put(node) {
-        this.changed = true;
-        // SAFETY: callers construct the value they pass, so stamping it in place replaces a spread on every write.
-        const stamped = node;
-        stamped.revision = this.revision;
-        this.pending.set(node.ino, node);
-    }
-    putQuiet(node) {
-        this.pending.set(node.ino, node);
-    }
-    get unchanged() {
-        return this.pending.size === 0 && this.opens === undefined && this.nextInode === this.base.nextInode &&
-            this.entries === this.base.entries && this.usedBytes === this.base.usedBytes;
-    }
-    remove(ino) {
-        this.removed.push(ino);
-        this.pending.set(ino, undefined);
-    }
-    allocate() {
-        const ino = this.nextInode;
-        this.nextInode = Ino(ino + 1);
-        return ino;
-    }
-    // Whether another inode can be allocated. The allocator itself must stay exactly representable, since a live
-    // image refuses one past the largest safe integer, so the last inode it hands out is one below that.
-    get canAllocate() {
-        return this.nextInode < Number.MAX_SAFE_INTEGER;
-    }
-    openCount(ino) {
-        return this.opens?.get(ino) ?? this.base.open.get(ino) ?? 0;
-    }
-    retain(ino) {
-        this.opens = (this.opens ?? new Map()).set(ino, this.openCount(ino) + 1);
-    }
-    release(ino) {
-        const count = this.openCount(ino) - 1;
-        this.opens = (this.opens ?? new Map()).set(ino, count < 0 ? 0 : count);
-        return count;
-    }
-    finish() {
-        if (this.finished !== undefined)
-            return this.finished;
-        const base = this.base;
-        let inodes = base.inodes;
-        for (const [ino, node] of this.pending)
-            inodes = InodeTable.set(inodes, ino, node, this.owner);
-        let open = base.open;
-        if (this.opens !== undefined) {
-            const next = new Map(base.open);
-            for (const [ino, count] of this.opens) {
-                if (count > 0)
-                    next.set(ino, count);
-                else
-                    next.delete(ino);
-            }
-            open = next;
-        }
-        this.finished = {
-            inodes,
-            open,
-            nextInode: this.nextInode,
-            revision: this.changed ? this.revision : base.revision,
-            entries: this.entries,
-            usedBytes: this.usedBytes
+class Draft extends Context.Service()("@effect-vfs/core/internal/virtualFileSystem/Draft", {
+    make: Effect.fnUntraced(function* (base) {
+        const revision = base.revision + 1n;
+        const cell = MutableRef.make({
+            owner: Symbol(),
+            pending: new Map(),
+            opens: undefined,
+            nextInode: base.nextInode,
+            changed: false,
+            finished: undefined,
+            entries: base.entries,
+            usedBytes: base.usedBytes,
+            events: [],
+            after: [],
+            removed: []
+        });
+        const get = (ino) => Effect.sync(() => {
+            const draft = MutableRef.get(cell);
+            return draft.pending.has(ino) ? draft.pending.get(ino) : InodeTable.get(base.inodes, ino);
+        });
+        const openCount = (ino) => Effect.sync(() => MutableRef.get(cell).opens?.get(ino) ?? base.open.get(ino) ?? 0);
+        const put = (node, changed) => Effect.sync(() => {
+            MutableRef.update(cell, (draft) => {
+                // This map belongs only to this transition. Copying it on every inode write makes recursive changes quadratic.
+                draft.pending.set(node.ino, changed ? { ...node, revision } : node);
+                return { ...draft, changed: draft.changed || changed };
+            });
+        });
+        return {
+            revision,
+            get,
+            put: (node) => put(node, true),
+            putQuiet: (node) => put(node, false),
+            unchanged: Effect.sync(() => {
+                const draft = MutableRef.get(cell);
+                return draft.pending.size === 0 && draft.opens === undefined && draft.nextInode === base.nextInode &&
+                    draft.entries === base.entries && draft.usedBytes === base.usedBytes;
+            }),
+            remove: (ino) => Effect.sync(() => {
+                const draft = MutableRef.get(cell);
+                draft.pending.set(ino, undefined);
+                draft.removed.push(ino);
+            }),
+            allocate: Effect.sync(() => {
+                const next = MutableRef.get(cell).nextInode;
+                MutableRef.update(cell, (draft) => ({ ...draft, nextInode: Ino(next + 1) }));
+                return next;
+            }),
+            canAllocate: Effect.sync(() => MutableRef.get(cell).nextInode < Number.MAX_SAFE_INTEGER),
+            openCount,
+            retain: (ino) => Effect.sync(() => {
+                const count = MutableRef.get(cell).opens?.get(ino) ?? base.open.get(ino) ?? 0;
+                MutableRef.update(cell, (draft) => ({ ...draft, opens: new Map(draft.opens).set(ino, count + 1) }));
+            }),
+            release: (ino) => Effect.sync(() => {
+                const count = (MutableRef.get(cell).opens?.get(ino) ?? base.open.get(ino) ?? 0) - 1;
+                MutableRef.update(cell, (draft) => ({ ...draft, opens: new Map(draft.opens).set(ino, Math.max(0, count)) }));
+                return count;
+            }),
+            entries: Effect.sync(() => MutableRef.get(cell).entries),
+            addEntries: (amount) => Effect.sync(() => {
+                MutableRef.update(cell, (draft) => ({ ...draft, entries: draft.entries + amount }));
+            }),
+            usedBytes: Effect.sync(() => MutableRef.get(cell).usedBytes),
+            addUsedBytes: (amount) => Effect.sync(() => {
+                MutableRef.update(cell, (draft) => ({ ...draft, usedBytes: draft.usedBytes + amount }));
+            }),
+            publish: (event) => Effect.sync(() => {
+                MutableRef.get(cell).events.push(event);
+            }),
+            afterInstall: (action) => Effect.sync(() => {
+                MutableRef.get(cell).after.push(action);
+            }),
+            finish: Effect.sync(() => {
+                const draft = MutableRef.get(cell);
+                if (draft.finished !== undefined)
+                    return draft.finished;
+                let inodes = base.inodes;
+                for (const [ino, node] of draft.pending)
+                    inodes = InodeTable.set(inodes, ino, node, draft.owner);
+                let open = base.open;
+                if (draft.opens !== undefined) {
+                    const next = new Map(base.open);
+                    for (const [ino, count] of draft.opens) {
+                        if (count > 0)
+                            next.set(ino, count);
+                        else
+                            next.delete(ino);
+                    }
+                    open = next;
+                }
+                const finished = {
+                    inodes,
+                    open,
+                    nextInode: draft.nextInode,
+                    revision: draft.changed ? revision : base.revision,
+                    entries: draft.entries,
+                    usedBytes: draft.usedBytes
+                };
+                MutableRef.update(cell, (current) => ({ ...current, finished }));
+                return finished;
+            }),
+            actions: Effect.sync(() => {
+                const { events, after, removed } = MutableRef.get(cell);
+                return { events, after, removed };
+            })
         };
-        return this.finished;
-    }
+    })
+}) {
 }
 const objectReferences = new WeakMap();
 const isFileHandle = (value) => Predicate.hasProperty(FileHandleId)(value);
@@ -227,7 +244,7 @@ const observeChanges = Effect.fnUntraced(function* (captured) {
 });
 const randomHex128 = Effect.gen(function* () {
     const crypto = yield* Crypto.Crypto;
-    return Encoding.encodeHex(yield* crypto.randomBytes(16));
+    return Hex.encode(yield* crypto.randomBytes(16));
 }).pipe(Effect.orDie);
 /** @internal */
 export const makeVolume = Effect.fnUntraced(function* (source, options, commitProvider, captureInitial, durability = "memory-only") {
@@ -256,9 +273,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
     const incarnation = VolumeIncarnation.make(yield* randomHex128);
     const epoch = live === undefined ? VolumeEpoch.make(yield* randomHex128) : live.epoch;
     const keySecret = live === undefined ? KeySecret.make(yield* randomHex128) : live.keySecret;
-    const identityBytes = Result.getOrThrow(Encoding.decodeHex(identity));
-    const epochBytes = Result.getOrThrow(Encoding.decodeHex(epoch));
-    const keySecretBytes = Result.getOrThrow(Encoding.decodeHex(keySecret));
+    const identityBytes = Result.getOrThrow(Hex.decode(identity));
+    const epochBytes = Result.getOrThrow(Hex.decode(epoch));
+    const keySecretBytes = Result.getOrThrow(Hex.decode(keySecret));
     const clock = yield* Clock.clockWith(Effect.succeed);
     const initialTime = clock.currentTimeNanosUnsafe();
     if (!isTimestamp(initialTime)) {
@@ -339,91 +356,76 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
     const initialImage = captureInitial === undefined
         ? undefined
         : yield* captureInitial(state, { identity, epoch, keySecret }, limits);
-    let draft;
-    const view = (ino) => draft === undefined ? getNode(state, ino) : draft.get(ino);
+    const view = (ino) => Effect.flatMap(Effect.serviceOption(Draft), (draft) => Option.isSome(draft) ? draft.value.get(ino) : Effect.sync(() => getNode(state, ino)));
     let available = true;
     const checkAvailable = (operation) => Effect.suspend(() => available ? Effect.void : Effect.fail(fsFailure("VolumeUnavailable", operation)));
     const watchCoordinate = (effect) => changing(effect);
     const watchHub = yield* WatchHub.make(watchCoordinate, settings.maxWatchEvents ?? 256);
-    const install = (finished) => {
+    const install = Effect.fnUntraced(function* (finished) {
         const before = state;
-        state = finished.finish();
-        for (const ino of finished.removed)
+        state = yield* finished.finish;
+        const actions = yield* finished.actions;
+        for (const ino of actions.removed)
             tokens.delete(ino);
-        for (const apply of finished.after)
+        for (const apply of actions.after)
             apply();
         const after = state;
-        watchHub.publishUnsafe(() => finished.events.flatMap((events) => Array.from(events(after))), { before, after });
-    };
-    const transition = (change) => Effect.suspend(() => {
-        const current = new Draft(state);
-        draft = current;
-        return Effect.onExit(change, () => Effect.sync(() => {
-            draft = undefined;
-        })).pipe(Effect.map((value) => [value, current]));
+        watchHub.publishUnsafe(() => actions.events.flatMap((events) => Array.from(events(after))), { before, after });
+    });
+    const transition = Effect.fnUntraced(function* (change) {
+        const current = yield* Draft.make(state);
+        const value = yield* Effect.provideService(change, Draft, current);
+        return [value, current];
+    });
+    const applyDirect = Effect.fnUntraced(function* (change) {
+        const current = yield* Draft.make(state);
+        yield* Effect.provideService(change(current), Draft, current);
+        yield* install(current);
     });
-    const applyDirect = (change) => {
-        const current = new Draft(state);
-        draft = current;
-        try {
-            change(current);
-        }
-        finally {
-            draft = undefined;
-        }
-        install(current);
-    };
     // Offers the finished draft's value to the store before installing it. A rejected candidate is discarded and
     // the volume stays available; an uncertain answer stops the volume. A change that is a cleanup runs its
     // release even when the store refuses, since the handle must not stay open.
     const committed = Effect.fnUntraced(function* (op, provider, finished, onStorageFailure) {
-        if (finished.unchanged)
-            return install(finished);
-        const next = finished.finish();
+        if (yield* finished.unchanged)
+            return yield* install(finished);
+        const next = yield* finished.finish;
         if (provider.prepare !== undefined)
             yield* provider.prepare(next);
         const answer = yield* offerCommit(provider, op.operation, next, onStorageFailure !== undefined);
         if (!answer.available)
             available = false;
         if (answer.failure !== undefined) {
-            if (!answer.available)
-                onStorageFailure?.();
+            if (!answer.available && onStorageFailure !== undefined)
+                yield* onStorageFailure();
             return yield* answer.failure;
         }
-        install(finished);
+        yield* install(finished);
     });
     const annotateFailure = (error) => Effect.annotateCurrentSpan({ operation: error.operation, code: error.code });
     // Permit waits stay interruptible. A change and its publication run under every permit; with a store, the
     // change itself stays interruptible and only the commit and installation are not.
     const coordinated = (op, effect, onStorageFailure) => admit(op, changing(commitProvider === undefined
-        ? Effect.uninterruptible(Effect.map(transition(Effect.andThen(checkAvailable(op.operation), effect)), ([value, finished]) => {
-            install(finished);
-            return value;
-        }))
+        ? Effect.uninterruptible(Effect.flatMap(transition(Effect.andThen(checkAvailable(op.operation), effect)), ([value, finished]) => Effect.as(install(finished), value)))
         : Effect.uninterruptibleMask((restore) => Effect.flatMap(restore(transition(Effect.andThen(checkAvailable(op.operation), effect))), ([value, finished]) => Effect.as(committed(op, commitProvider, finished, onStorageFailure), value))))).pipe(Effect.tapError((error) => Schema.is(VfsError)(error) ? annotateFailure(error) : Effect.void));
     const coordinatedRead = (op, effect) => admit(op, observing(Effect.andThen(checkAvailable(op.operation), effect))).pipe(Effect.tapError((error) => Schema.is(VfsError)(error) ? annotateFailure(error) : Effect.void));
-    const refreshAccess = (read) => {
+    const refreshAccess = Effect.fnUntraced(function* (read) {
         if (refreshDue(read)) {
             const { node, now } = read.access;
-            current().putQuiet({ ...node, metadata: { ...node.metadata, atimeNs: now } });
+            const draft = yield* Draft;
+            yield* draft.putQuiet({ ...node, metadata: { ...node.metadata, atimeNs: now } });
         }
         return read.value;
-    };
+    });
     // A read that may refresh an access time. It observes under one permit, so reads run beside each other, and
     // only when the access time is due does it run again as a change. The change repeats every check and the rule,
     // since another read may have refreshed the time meanwhile, and its result is the one returned.
     const accessing = (op, read) => Effect.flatMap(coordinatedRead(op, read), (observed) => refreshDue(observed)
-        ? coordinated(op, Effect.map(read, refreshAccess))
+        ? coordinated(op, Effect.flatMap(read, refreshAccess))
         : Effect.succeed(observed.value));
     const coordinatedCleanup = (effect) => changing(Effect.uninterruptible(effect));
     const shutdown = commitProvider === undefined ? undefined : changing(Effect.sync(() => {
         available = false;
     }));
-    const current = () => {
-        if (draft === undefined)
-            return dieInvariant("Volume mutation outside a transition");
-        return draft;
-    };
     const pathOf = (get, ino) => {
         const names = [];
         let node = get(ino);
@@ -438,19 +440,33 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
         }
         return SLASH_HEX + names.reverse().join(SLASH_HEX);
     };
+    const pathOfCurrent = Effect.fnUntraced(function* (ino) {
+        const names = [];
+        const first = yield* view(ino);
+        if (first?.kind !== "directory" || first.metadata.nlink === 0)
+            return undefined;
+        let node = first;
+        while (node.ino !== ROOT_INO) {
+            names.push(node.name);
+            const parent = yield* view(node.parent);
+            if (parent?.kind !== "directory" || parent.metadata.nlink === 0)
+                return undefined;
+            node = parent;
+        }
+        return SLASH_HEX + names.reverse().join(SLASH_HEX);
+    });
     const entryPath = (prefix, name) => ownedPath(nameBytes(prefix + (prefix === SLASH_HEX ? "" : SLASH_HEX) + name));
-    const publishEntry = (_tag, parent, name, ino) => {
-        current().events.push((installed) => {
-            const prefix = pathOf((at) => getNode(installed, at), parent);
-            return prefix === undefined ? [] : [{ change: { _tag, path: entryPath(prefix, name) }, parent, ino }];
-        });
-    };
-    const publishNode = (ino) => {
-        const target = current().get(ino);
+    const publishEntry = (_tag, parent, name, ino) => Effect.flatMap(Draft, (draft) => draft.publish((installed) => {
+        const prefix = pathOf((at) => getNode(installed, at), parent);
+        return prefix === undefined ? [] : [{ change: { _tag, path: entryPath(prefix, name) }, parent, ino }];
+    }));
+    const publishNode = Effect.fnUntraced(function* (ino) {
+        const draft = yield* Draft;
+        const target = yield* draft.get(ino);
         if (target === undefined)
             return;
         if (target.kind === "directory") {
-            current().events.push((installed) => {
+            yield* draft.publish((installed) => {
                 const directory = getNode(installed, ino);
                 const path = pathOf((at) => getNode(installed, at), ino);
                 return path === undefined || directory?.kind !== "directory"
@@ -460,7 +476,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             return;
         }
         const links = target.links;
-        current().events.push((installed) => {
+        yield* draft.publish((installed) => {
             const events = [];
             for (const link of links) {
                 const prefix = pathOf((at) => getNode(installed, at), link.parent);
@@ -474,7 +490,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             }
             return events;
         });
-    };
+    });
     const pathsOf = (installed, ino) => {
         const node = getNode(installed, ino);
         if (node === undefined)
@@ -573,7 +589,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
     const holdDirectory = (ino) => {
         directoryHolds.set(ino, (directoryHolds.get(ino) ?? 0) + 1);
     };
-    const unholdDirectory = (ino) => {
+    const unholdDirectory = Effect.fnUntraced(function* (ino) {
         const count = (directoryHolds.get(ino) ?? 1) - 1;
         if (count > 0) {
             directoryHolds.set(ino, count);
@@ -581,19 +597,20 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
         }
         directoryHolds.delete(ino);
         const node = getNode(state, ino);
-        if (node?.kind === "directory" && node.metadata.nlink === 0)
-            applyDirect((d) => d.remove(ino));
-    };
-    const releaseDirectory = (reference) => {
+        if (node?.kind === "directory" && node.metadata.nlink === 0) {
+            yield* applyDirect((d) => d.remove(ino));
+        }
+    });
+    const releaseDirectory = Effect.fnUntraced(function* (reference) {
         const ino = reference.ino;
         reference.ino = undefined;
         reference.closed = true;
         if (ino !== undefined)
-            unholdDirectory(ino);
-    };
+            yield* unholdDirectory(ino);
+    });
     const finalizeDirectory = (reference) => Effect.uninterruptible(Effect.suspend(() => reference.closed
         ? Effect.void
-        : coordinatedCleanup(Effect.sync(() => releaseDirectory(reference)))));
+        : coordinatedCleanup(releaseDirectory(reference))));
     const closeReleasedScope = (reference) => Effect.suspend(() => !reference.closed || reference.scope === undefined ? Effect.void : Scope.close(reference.scope, Exit.void));
     const permitted = (node, identity) => {
         const metadata = node.metadata;
@@ -607,33 +624,45 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
     const authorize = (node, identity, bits, op) => identity.privileged || (permitted(node, identity) & bits) === bits
         ? Effect.void
         : Effect.fail(op.fail("AccessDenied"));
-    const reclaim = (d, ino) => {
-        const node = d.get(ino);
+    const reclaim = Effect.fnUntraced(function* (d, ino) {
+        const node = yield* d.get(ino);
         if (node === undefined)
             return;
         if (node.kind === "file") {
-            if (node.links.length > 0 || d.openCount(ino) > 0)
+            if (node.links.length > 0 || (yield* d.openCount(ino)) > 0)
                 return;
-            d.usedBytes -= BigInt(node.data.length);
+            yield* d.addUsedBytes(-BigInt(node.data.length));
         }
         else if (node.kind === "symlink") {
             if (node.links.length > 0)
                 return;
-            d.usedBytes -= BigInt(node.target.length);
+            yield* d.addUsedBytes(-BigInt(node.target.length));
         }
         else if (node.metadata.nlink > 0 || directoryHolds.has(ino))
             return;
-        d.remove(ino);
-    };
-    const atEntryLimit = () => settings.maxEntries !== undefined && current().entries >= settings.maxEntries;
-    const reserveEntry = (op) => atEntryLimit() || !current().canAllocate ? Effect.fail(op.fail("NoSpace")) : Effect.void;
-    const reserveInode = (op) => current().canAllocate ? Effect.void : Effect.fail(op.fail("NoSpace"));
-    const reserveBytes = (op, bytes) => settings.maxBytes !== undefined && bytes > ByteSize.toBigInt(settings.maxBytes) - current().usedBytes
-        ? Effect.fail(op.fail("NoSpace"))
-        : Effect.void;
-    const attach = (parent, name, child, now) => {
-        const d = current();
-        d.put(withEntries({
+        yield* d.remove(ino);
+    });
+    const atEntryLimit = Effect.gen(function* () {
+        const draft = yield* Draft;
+        return settings.maxEntries !== undefined && (yield* draft.entries) >= settings.maxEntries;
+    });
+    const reserveEntry = Effect.fnUntraced(function* (op) {
+        const draft = yield* Draft;
+        if ((yield* atEntryLimit) || !(yield* draft.canAllocate))
+            return yield* op.fail("NoSpace");
+    });
+    const reserveInode = (op) => Effect.flatMap(Draft, (draft) => Effect.flatMap(draft.canAllocate, (available) => available ? Effect.void : Effect.fail(op.fail("NoSpace"))));
+    const reserveBytes = Effect.fnUntraced(function* (op, bytes) {
+        if (settings.maxBytes === undefined)
+            return;
+        const draft = yield* Draft;
+        if (bytes > ByteSize.toBigInt(settings.maxBytes) - (yield* draft.usedBytes)) {
+            return yield* op.fail("NoSpace");
+        }
+    });
+    const attach = Effect.fnUntraced(function* (parent, name, child, now) {
+        const d = yield* Draft;
+        yield* d.put(withEntries({
             ...parent,
             metadata: {
                 ...parent.metadata,
@@ -643,51 +672,49 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             }
         }, (entries) => entries.set(name, child.ino)));
         if (child.kind === "directory")
-            d.put({ ...child, parent: parent.ino, name });
+            yield* d.put({ ...child, parent: parent.ino, name });
         else {
-            d.put({
+            yield* d.put({
                 ...child,
                 links: [...child.links, { parent: parent.ino, name }],
                 metadata: { ...child.metadata, nlink: child.links.length + 1, ctimeNs: now }
             });
         }
-    };
-    const detach = (child, parent, name, now) => {
-        const d = current();
+    });
+    const detach = Effect.fnUntraced(function* (child, parent, name, now) {
+        const d = yield* Draft;
         if (child.kind === "directory") {
-            d.put({ ...child, metadata: { ...child.metadata, nlink: 0, ctimeNs: now } });
+            yield* d.put({ ...child, metadata: { ...child.metadata, nlink: 0, ctimeNs: now } });
         }
         else {
             const links = withoutLink(child.links, parent, name);
-            d.put({ ...child, links, metadata: { ...child.metadata, nlink: links.length, ctimeNs: now } });
+            yield* d.put({ ...child, links, metadata: { ...child.metadata, nlink: links.length, ctimeNs: now } });
         }
-        reclaim(d, child.ino);
-    };
-    const releaseFile = (ref) => {
+        yield* reclaim(d, child.ino);
+    });
+    const releaseFile = Effect.fnUntraced(function* (ref) {
         const ino = ref.ino;
         if (ino !== undefined) {
-            const d = current();
-            d.release(ino);
-            reclaim(d, ino);
+            const d = yield* Draft;
+            yield* d.release(ino);
+            yield* reclaim(d, ino);
         }
         ref.ino = undefined;
         ref.closed = true;
-    };
-    const releaseOpenFile = (ref) => coordinatedCleanup(Effect.sync(() => {
-        if (!ref.closed)
-            applyDirect(() => releaseFile(ref));
-    }));
+    });
+    const releaseOpenFile = (ref) => coordinatedCleanup(Effect.suspend(() => ref.closed ? Effect.void : applyDirect(() => releaseFile(ref))));
     // Explicit close and scope cleanup share one release. A release whose commit fails still completes as
     // cleanup, so the handle never stays open; only an explicit close reports the failure. A close refused
     // admission never entered the volume, so it leaves the handle open for a retry.
-    const closeFile = (ref, op, check) => coordinated(op, Effect.andThen(check, Effect.sync(() => {
+    const closeFile = (ref, op, check) => coordinated(op, Effect.andThen(check, Effect.gen(function* () {
         const ino = ref.ino;
         if (ino !== undefined) {
-            const d = current();
-            d.release(ino);
-            reclaim(d, ino);
+            const d = yield* Draft;
+            yield* d.release(ino);
+            yield* reclaim(d, ino);
         }
-        current().after.push(() => {
+        const d = yield* Draft;
+        yield* d.afterInstall(() => {
             ref.ino = undefined;
             ref.closed = true;
         });
@@ -713,19 +740,16 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
         return yield* coordinate(Effect.suspend(() => closed() ? Effect.interrupt : acquire).pipe(Effect.tap(() => Effect.suspend(() => {
             if (!closed())
                 return Effect.void;
-            releaseAcquired();
-            return Effect.interrupt;
+            return Effect.andThen(releaseAcquired(), Effect.interrupt);
         })))).pipe(Effect.tap(() => Effect.suspend(() => closed() ? Effect.interrupt : Effect.void)), Effect.onError(() => Effect.andThen(finalize, Scope.close(scope, Exit.void))));
     });
-    const bindFile = (ref, ino) => {
-        current().after.push(() => {
-            ref.ino = ino;
-        });
-    };
-    const replaceContent = (file, data, now, publish = true) => {
-        const d = current();
-        d.usedBytes += BigInt(data.length - file.data.length);
-        d.put({
+    const bindFile = (ref, ino) => Effect.flatMap(Draft, (draft) => draft.afterInstall(() => {
+        ref.ino = ino;
+    }));
+    const replaceContent = Effect.fnUntraced(function* (file, data, now, publish = true) {
+        const d = yield* Draft;
+        yield* d.addUsedBytes(BigInt(data.length - file.data.length));
+        yield* d.put({
             ...file,
             data,
             metadata: {
@@ -737,8 +761,8 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             }
         });
         if (publish)
-            publishNode(file.ino);
-    };
+            yield* publishNode(file.ino);
+    });
     const resizeAt = Effect.fnUntraced(function* (file, length, now, op) {
         if (length > BigInt(maxFileBytes))
             return yield* op.fail("FileTooLarge");
@@ -746,22 +770,22 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
         yield* reserveBytes(op, BigInt(size - file.data.length));
         const data = new Uint8Array(size);
         data.set(file.data.subarray(0, size));
-        replaceContent(file, data, now, false);
+        yield* replaceContent(file, data, now, false);
     });
     const resize = Effect.fnUntraced(function* (file, length, op) {
         if (!isLength(length))
             return yield* op.fail("InvalidArgument");
         yield* resizeAt(file, length, yield* timestamp(op), op);
-        publishNode(file.ino);
+        yield* publishNode(file.ino);
     });
     const fileHandle = (ref) => {
-        const get = (op, access) => {
-            const node = ref.ino === undefined ? undefined : view(ref.ino);
-            return node?.kind !== "file" || (access === "read" && ref.access === "write") ||
-                (access === "write" && ref.access === "read")
-                ? Effect.fail(op.fail("InvalidHandle"))
-                : Effect.succeed(node);
-        };
+        const get = Effect.fnUntraced(function* (op, access) {
+            const node = ref.ino === undefined ? undefined : yield* view(ref.ino);
+            if (node?.kind !== "file" || (access === "read" && ref.access === "write") ||
+                (access === "write" && ref.access === "read"))
+                return yield* op.fail("InvalidHandle");
+            return node;
+        });
         const read = (maximum, position) => {
             const op = OpContext.make(position === undefined ? "read" : "pread");
             const readOp = OpContext.make("read");
@@ -783,9 +807,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             // other would start at the same offset.
             if (position !== undefined)
                 return Effect.map(accessing(op, body), ({ bytes, eof }) => ({ bytes, eof }));
-            return coordinated(op, Effect.map(body, (read) => {
-                const { bytes, eof, next } = refreshAccess(read);
-                current().after.push(() => {
+            return coordinated(op, Effect.gen(function* () {
+                const { bytes, eof, next } = yield* refreshAccess(yield* body);
+                const draft = yield* Draft;
+                yield* draft.afterInstall(() => {
                     ref.offset = next;
                 });
                 return { bytes, eof };
@@ -809,9 +834,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 if (offset >= BigInt(maxFileBytes))
                     return yield* writeOp.fail("FileTooLarge");
                 const start = Number(offset);
+                const draft = yield* Draft;
                 const free = settings.maxBytes === undefined
                     ? BigInt(maxFileBytes)
-                    : ByteSize.toBigInt(settings.maxBytes) - current().usedBytes;
+                    : ByteSize.toBigInt(settings.maxBytes) - (yield* draft.usedBytes);
                 const maximumEnd = BigInt(file.data.length) + free;
                 const end = Number(BigInt(maxFileBytes) < maximumEnd ? BigInt(maxFileBytes) : maximumEnd);
                 const count = Math.min(bytes.length, Math.max(0, end - start));
@@ -824,10 +850,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 data.set(file.data);
                 const now = yield* timestamp(writeOp);
                 data.set(bytes.subarray(0, count), start);
-                replaceContent(file, data, now);
+                yield* replaceContent(file, data, now);
                 if (position === undefined) {
                     const next = offset + BigInt(count);
-                    current().after.push(() => {
+                    yield* draft.afterInstall(() => {
                         ref.offset = next;
                     });
                 }
@@ -901,35 +927,38 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             if (known.volume !== volumeIdentity) {
                 return yield* op.fail("ForeignReference");
             }
-            const node = view(known.ino);
+            const node = yield* view(known.ino);
             if (node === undefined || (node.kind === "directory" && node.metadata.nlink === 0)) {
                 return yield* op.fail("StaleReference");
             }
             return node;
         });
-        const callerDirectory = (op) => {
-            const node = reference.ino === undefined ? undefined : view(reference.ino);
-            return node?.kind === "directory" ? Effect.succeed(node) : Effect.fail(op.fail("ClosedCaller"));
-        };
-        const directoryNow = (ino) => {
-            const node = view(ino);
+        const callerDirectory = Effect.fnUntraced(function* (op) {
+            const node = reference.ino === undefined ? undefined : yield* view(reference.ino);
+            if (node?.kind !== "directory")
+                return yield* op.fail("ClosedCaller");
+            return node;
+        });
+        const directoryNow = Effect.fnUntraced(function* (ino) {
+            const node = yield* view(ino);
             if (node?.kind !== "directory") {
                 return dieInvariant("Directory left the inode table during a transition");
             }
             return node;
-        };
-        const nodeNow = (ino) => {
-            const node = view(ino);
+        });
+        const nodeNow = Effect.fnUntraced(function* (ino) {
+            const node = yield* view(ino);
             if (node === undefined)
                 return dieInvariant("Inode left the table during a transition");
             return node;
-        };
+        });
         const creationTimes = (times, now) => ({
             atimeNs: times?.access.kind === "value" ? times.access.nanoseconds : now,
             mtimeNs: times?.modification.kind === "value" ? times.modification.nanoseconds : now
         });
-        const newDirectory = (parent, mode, now, times) => {
-            const ino = current().allocate();
+        const newDirectory = Effect.fnUntraced(function* (parent, mode, now, times) {
+            const draft = yield* Draft;
+            const ino = yield* draft.allocate;
             return {
                 kind: "directory",
                 ino,
@@ -942,9 +971,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 },
                 revision: 0n
             };
-        };
-        const newFile = (parent, data, mode, now, owner, times) => {
-            const ino = current().allocate();
+        });
+        const newFile = Effect.fnUntraced(function* (parent, data, mode, now, owner, times) {
+            const draft = yield* Draft;
+            const ino = yield* draft.allocate;
             return {
                 kind: "file",
                 ino,
@@ -959,9 +989,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 },
                 revision: 0n
             };
-        };
-        const newSymlink = (parent, target, now, times) => {
-            const ino = current().allocate();
+        });
+        const newSymlink = Effect.fnUntraced(function* (parent, target, now, times) {
+            const draft = yield* Draft;
+            const ino = yield* draft.allocate;
             return {
                 kind: "symlink",
                 ino,
@@ -976,14 +1007,14 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 },
                 revision: 0n
             };
-        };
+        });
         const lookup = Effect.fnUntraced(function* (path, base, op, options = {}, referencedBase) {
             const pathOp = op.at(path.input);
             const { allowMissing = false, createMissing, followFinalSymlink = true, parentOnly = false } = options;
             if (reference.ino === undefined) {
                 return yield* pathOp.fail("ClosedCaller");
             }
-            let current = path.absolute ? nodeNow(ROOT_INO) : yield* callerDirectory(pathOp);
+            let current = path.absolute ? (yield* nodeNow(ROOT_INO)) : yield* callerDirectory(pathOp);
             if (!path.absolute && referencedBase !== undefined) {
                 current = referencedBase;
                 yield* authorize(current, identity, EXECUTE, op);
@@ -996,7 +1027,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 if (target.volume !== volumeIdentity) {
                     return yield* pathOp.fail("ForeignHandle");
                 }
-                const directory = target.ino === undefined ? undefined : view(target.ino);
+                const directory = target.ino === undefined ? undefined : (yield* view(target.ino));
                 if (directory?.kind !== "directory") {
                     return yield* pathOp.fail("InvalidHandle");
                 }
@@ -1024,7 +1055,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 if (component === DOT_HEX)
                     continue;
                 if (component === DOT_DOT_HEX) {
-                    current = directoryNow(current.parent);
+                    current = yield* directoryNow(current.parent);
                     parent = undefined;
                     name = undefined;
                     continue;
@@ -1032,7 +1063,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 parent = current;
                 name = component;
                 const childIno = current.entries.get(component);
-                const child = childIno === undefined ? undefined : view(childIno);
+                const child = childIno === undefined ? undefined : (yield* view(childIno));
                 if (child === undefined) {
                     if (allowMissing && index === work.components.length - 1) {
                         return { node: undefined, parent, name };
@@ -1069,7 +1100,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                     work = expanded.success;
                     linked = work.components.length - remaining + Math.max(0, linked - index - 1);
                     if (work.absolute)
-                        current = nodeNow(ROOT_INO);
+                        current = yield* nodeNow(ROOT_INO);
                     index = -1;
                 }
                 else
@@ -1137,7 +1168,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             const resolving = resolve();
             return coordinated(op, Effect.gen(function* () {
                 const resolved = yield* resolving;
-                const node = nodeNow(resolved.ino);
+                const node = yield* nodeNow(resolved.ino);
                 if (expected !== undefined && node.revision !== expected) {
                     return yield* resolved.op.fail("StaleReference", { field: "expected" });
                 }
@@ -1163,11 +1194,11 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 const now = yield* timestamp(op);
                 if (size !== undefined && node.kind === "file")
                     yield* resizeAt(node, size, now, op);
-                const sized = nodeNow(resolved.ino);
+                const sized = yield* nodeNow(resolved.ino);
                 const gid = owner?.gid ?? sized.metadata.gid;
                 const cleared = chowned && sized.kind === "file" ? sized.metadata.mode & ~SET_ID_BITS : sized.metadata.mode;
                 if (chowned || mode !== undefined || timed) {
-                    current().put({
+                    yield* (yield* Draft).put({
                         ...sized,
                         metadata: {
                             ...sized.metadata,
@@ -1180,7 +1211,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                         }
                     });
                 }
-                publishNode(node.ino);
+                yield* publishNode(node.ino);
             }));
         };
         const authorizeRemoval = (parent, child, op) => (parent.metadata.mode & STICKY_BIT) !== 0 && !identity.privileged &&
@@ -1188,7 +1219,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             ? Effect.fail(op.fail("NotPermitted"))
             : Effect.void;
         const claimName = Effect.fnUntraced(function* (entry, trailingSlash = "allowed") {
-            const parent = directoryNow(entry.parent);
+            const parent = yield* directoryNow(entry.parent);
             if (isDotComponent(entry.name)) {
                 return yield* entry.op.fail(entry.addressing === "entry" ? "InvalidArgument" : "AlreadyExists");
             }
@@ -1203,17 +1234,18 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
         const makeDirectory = Effect.fnUntraced(function* (entry, request, op) {
             const name = yield* claimName(entry);
             yield* reserveEntry(entry.op);
-            const parent = directoryNow(entry.parent);
+            const parent = yield* directoryNow(entry.parent);
             const before = parent.revision;
             const now = yield* timestamp(op);
             const mode = request.exactMode
                 ? yield* permittedMode({ kind: "directory", uid: identity.uid, gid: parent.metadata.gid }, request.mode, op)
                 : (request.mode & 0o777 & ~umask) | (request.mode & STICKY_BIT);
-            const child = newDirectory(parent, mode, now, request.times);
-            attach(parent, name, child, now);
-            current().entries += 1;
-            publishEntry("Create", parent.ino, name, child.ino);
-            return { child: child.ino, directory: { before, after: current().revision } };
+            const child = yield* newDirectory(parent, mode, now, request.times);
+            yield* attach(parent, name, child, now);
+            const draft = yield* Draft;
+            yield* draft.addEntries(1);
+            yield* publishEntry("Create", parent.ino, name, child.ino);
+            return { child: child.ino, directory: { before, after: draft.revision } };
         });
         // Creates every missing directory a path names in the running transition, so a failure anywhere discards
         // them all. The mode applies to each directory created and the times to the one in the final position. An
@@ -1229,15 +1261,17 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 const made = yield* Effect.result(makeDirectory(entry, request, op));
                 if (Result.isSuccess(made))
                     return made.success;
-                const existingIno = entry.name === undefined ? undefined : directoryNow(entry.parent).entries.get(entry.name);
-                node = existingIno === undefined ? undefined : view(existingIno);
+                const existingIno = entry.name === undefined
+                    ? undefined
+                    : (yield* directoryNow(entry.parent)).entries.get(entry.name);
+                node = existingIno === undefined ? undefined : (yield* view(existingIno));
                 if (made.failure.code !== "AlreadyExists" || node?.kind !== "directory")
                     return yield* made.failure;
             }
             else {
                 entryOp = op.at(prepared.path.input);
                 const resolved = yield* lookup(prepared.path, prepared.base, op, {
-                    createMissing: (parent, name, final) => Effect.map(makeDirectory({ parent: parent.ino, name, trailingSlash: false, addressing: "path", op: entryOp }, final ? request : { mode: request.mode, exactMode: request.exactMode }, op), (made) => {
+                    createMissing: (parent, name, final) => Effect.flatMap(makeDirectory({ parent: parent.ino, name, trailingSlash: false, addressing: "path", op: entryOp }, final ? request : { mode: request.mode, exactMode: request.exactMode }, op), (made) => {
                         if (!revisionsBefore.has(parent.ino))
                             revisionsBefore.set(parent.ino, made.directory.before);
                         return directoryNow(made.child);
@@ -1247,39 +1281,41 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             }
             if (node?.kind !== "directory")
                 return yield* entryOp.fail("AlreadyExists");
-            const after = directoryNow(node.parent).revision;
+            const after = (yield* directoryNow(node.parent)).revision;
             return { child: node.ino, directory: { before: revisionsBefore.get(node.parent) ?? after, after } };
         });
         const linkNode = Effect.fnUntraced(function* (node, entry, op) {
             const name = yield* claimName(entry, "rejected");
             yield* reserveEntry(entry.op);
-            const parent = directoryNow(entry.parent);
+            const parent = yield* directoryNow(entry.parent);
             const before = parent.revision;
             const now = yield* timestamp(op);
-            attach(parent, name, node, now);
-            current().entries += 1;
-            publishEntry("Create", parent.ino, name, node.ino);
-            return { before, after: current().revision };
+            yield* attach(parent, name, node, now);
+            const draft = yield* Draft;
+            yield* draft.addEntries(1);
+            yield* publishEntry("Create", parent.ino, name, node.ino);
+            return { before, after: draft.revision };
         });
         const makeSymlink = Effect.fnUntraced(function* (entry, target, times, op) {
             const name = yield* claimName(entry, "rejected");
             yield* reserveEntry(entry.op);
             yield* reserveBytes(entry.op, BigInt(target.length));
-            const parent = directoryNow(entry.parent);
+            const parent = yield* directoryNow(entry.parent);
             const before = parent.revision;
             const now = yield* timestamp(op);
-            const child = newSymlink(parent, target, now, times);
-            attach(parent, name, child, now);
-            current().entries += 1;
-            current().usedBytes += BigInt(target.length);
-            publishEntry("Create", parent.ino, name, child.ino);
-            return { child: child.ino, directory: { before, after: current().revision } };
+            const child = yield* newSymlink(parent, target, now, times);
+            yield* attach(parent, name, child, now);
+            const draft = yield* Draft;
+            yield* draft.addEntries(1);
+            yield* draft.addUsedBytes(BigInt(target.length));
+            yield* publishEntry("Create", parent.ino, name, child.ino);
+            return { child: child.ino, directory: { before, after: draft.revision } };
         });
         const removeChild = Effect.fnUntraced(function* (parent, name, child, op) {
             const before = parent.revision;
             const now = yield* timestamp(op);
-            const d = current();
-            d.put(withEntries({
+            const d = yield* Draft;
+            yield* d.put(withEntries({
                 ...parent,
                 metadata: {
                     ...parent.metadata,
@@ -1288,22 +1324,22 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                     ctimeNs: now
                 }
             }, (entries) => entries.delete(name)));
-            publishEntry("Remove", parent.ino, name, child.ino);
-            detach(child, parent.ino, name, now);
-            d.entries -= 1;
+            yield* publishEntry("Remove", parent.ino, name, child.ino);
+            yield* detach(child, parent.ino, name, now);
+            yield* d.addEntries(-1);
             return { before, after: d.revision };
         });
         // Authorizes removing from the entry's directory and returns the named child. Only a path can name a dot
         // entry, and each verb reports it with its own code. Search permission comes before the lookup and write
         // permission after it, as on Linux; `beforeWrite` holds the verb's own checks that Linux makes in between.
         const removalTarget = Effect.fnUntraced(function* (entry, dotNameCode, beforeWrite) {
-            const parent = directoryNow(entry.parent);
+            const parent = yield* directoryNow(entry.parent);
             if (isDotComponent(entry.name)) {
                 return yield* entry.op.fail(entry.addressing === "entry" ? "InvalidArgument" : dotNameCode);
             }
             yield* authorize(parent, identity, EXECUTE, entry.op);
             const childIno = parent.entries.get(entry.name);
-            const child = childIno === undefined ? undefined : view(childIno);
+            const child = childIno === undefined ? undefined : (yield* view(childIno));
             if (child === undefined)
                 return yield* entry.op.fail("NotFound");
             const rejected = beforeWrite?.(child);
@@ -1338,8 +1374,8 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             return yield* removeChild(parent, name, child, op);
         });
         const renameEntry = Effect.fnUntraced(function* (source, destination, op) {
-            const sourceDirectory = directoryNow(source.parent);
-            const destinationDirectory = directoryNow(destination.parent);
+            const sourceDirectory = yield* directoryNow(source.parent);
+            const destinationDirectory = yield* directoryNow(destination.parent);
             const sameDirectory = source.parent === destination.parent;
             const sourceName = source.name;
             const destinationName = destination.name;
@@ -1353,11 +1389,11 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             const sourceBefore = sourceDirectory.revision;
             const destinationBefore = destinationDirectory.revision;
             const childIno = sourceDirectory.entries.get(sourceName);
-            const child = childIno === undefined ? undefined : view(childIno);
+            const child = childIno === undefined ? undefined : (yield* view(childIno));
             if (child === undefined)
                 return yield* source.op.fail("NotFound");
             const replacedIno = destinationDirectory.entries.get(destinationName);
-            const replaced = replacedIno === undefined ? undefined : view(replacedIno);
+            const replaced = replacedIno === undefined ? undefined : (yield* view(replacedIno));
             // A trailing slash on either side asks for a directory; a missing slashed destination is fine when the
             // source is one, as Linux allows.
             if ((source.trailingSlash || destination.trailingSlash) && child.kind !== "directory") {
@@ -1366,24 +1402,29 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             if (destination.trailingSlash && replaced !== undefined && replaced.kind !== "directory") {
                 return yield* destination.op.fail("NotDirectory");
             }
-            const result = () => sameDirectory
-                ? {
-                    _tag: "SameDirectory",
-                    directory: { before: sourceBefore, after: directoryNow(source.parent).revision }
-                }
-                : {
-                    _tag: "DifferentDirectories",
-                    sourceDirectory: { before: sourceBefore, after: directoryNow(source.parent).revision },
-                    destinationDirectory: { before: destinationBefore, after: directoryNow(destination.parent).revision }
-                };
-            for (let ancestor = destinationDirectory;; ancestor = directoryNow(ancestor.parent)) {
+            const result = Effect.fnUntraced(function* () {
+                return sameDirectory
+                    ? {
+                        _tag: "SameDirectory",
+                        directory: { before: sourceBefore, after: (yield* directoryNow(source.parent)).revision }
+                    }
+                    : {
+                        _tag: "DifferentDirectories",
+                        sourceDirectory: { before: sourceBefore, after: (yield* directoryNow(source.parent)).revision },
+                        destinationDirectory: {
+                            before: destinationBefore,
+                            after: (yield* directoryNow(destination.parent)).revision
+                        }
+                    };
+            });
+            for (let ancestor = destinationDirectory;; ancestor = yield* directoryNow(ancestor.parent)) {
                 if (ancestor.ino === child.ino)
                     return yield* destination.op.fail("InvalidArgument");
                 if (ancestor.ino === ROOT_INO)
                     break;
             }
             if (child.ino === replaced?.ino)
-                return result();
+                return yield* result();
             yield* authorize(sourceDirectory, identity, WRITE, source.op);
             yield* authorize(destinationDirectory, identity, WRITE, destination.op);
             yield* authorizeRemoval(sourceDirectory, child, source.op);
@@ -1400,9 +1441,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 }
             }
             const now = yield* timestamp(op);
-            const d = current();
-            publishEntry("Remove", sourceDirectory.ino, sourceName, child.ino);
-            d.put(withEntries({
+            const d = yield* Draft;
+            yield* publishEntry("Remove", sourceDirectory.ino, sourceName, child.ino);
+            yield* d.put(withEntries({
                 ...sourceDirectory,
                 metadata: {
                     ...sourceDirectory.metadata,
@@ -1411,8 +1452,8 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                     ctimeNs: now
                 }
             }, (entries) => entries.delete(sourceName)));
-            const destinationNow = directoryNow(destination.parent);
-            d.put(withEntries({
+            const destinationNow = yield* directoryNow(destination.parent);
+            yield* d.put(withEntries({
                 ...destinationNow,
                 metadata: {
                     ...destinationNow.metadata,
@@ -1421,9 +1462,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                     ctimeNs: now
                 }
             }, (entries) => entries.set(destinationName, child.ino)));
-            const moved = nodeNow(child.ino);
+            const moved = yield* nodeNow(child.ino);
             if (moved.kind === "directory") {
-                d.put({
+                yield* d.put({
                     ...moved,
                     parent: destination.parent,
                     name: destinationName,
@@ -1431,7 +1472,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 });
             }
             else {
-                d.put({
+                yield* d.put({
                     ...moved,
                     links: [
                         ...withoutLink(moved.links, source.parent, sourceName),
@@ -1441,11 +1482,11 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 });
             }
             if (replaced !== undefined) {
-                detach(nodeNow(replaced.ino), destination.parent, destinationName, now);
-                d.entries -= 1;
+                yield* detach(yield* nodeNow(replaced.ino), destination.parent, destinationName, now);
+                yield* d.addEntries(-1);
             }
-            publishEntry("Create", destination.parent, destinationName, child.ino);
-            return result();
+            yield* publishEntry("Create", destination.parent, destinationName, child.ino);
+            return yield* result();
         });
         const openExisting = Effect.fnUntraced(function* (file, request, at, op) {
             yield* authorize(file, identity, request.access === "read" ? READ : request.access === "write" ? WRITE : READ | WRITE, at);
@@ -1454,7 +1495,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
         });
         const openFile = Effect.fnUntraced(function* (entry, found, request, acquired, op) {
             const { name } = entry;
-            const parent = directoryNow(entry.parent);
+            const parent = yield* directoryNow(entry.parent);
             const before = parent.revision;
             let file = found;
             let created = false;
@@ -1481,12 +1522,13 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 const mode = request.exactMode
                     ? yield* permittedMode({ kind: "file", uid: owner?.uid ?? identity.uid, gid: owner?.gid ?? parent.metadata.gid }, request.mode, op)
                     : (request.mode ?? 0o666) & 0o777 & ~umask;
-                file = newFile(parent, new Uint8Array(Number(size)), mode, now, owner, request.times);
-                attach(parent, name, file, now);
-                current().entries += 1;
-                current().usedBytes += size;
+                file = yield* newFile(parent, new Uint8Array(Number(size)), mode, now, owner, request.times);
+                yield* attach(parent, name, file, now);
+                const draft = yield* Draft;
+                yield* draft.addEntries(1);
+                yield* draft.addUsedBytes(size);
                 created = true;
-                publishEntry("Create", parent.ino, name, file.ino);
+                yield* publishEntry("Create", parent.ino, name, file.ino);
             }
             else {
                 if (file.kind === "symlink")
@@ -1495,17 +1537,18 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                     return yield* entry.op.fail("IsDirectory");
                 yield* openExisting(file, request, entry.op, op);
             }
-            current().retain(file.ino);
-            bindFile(acquired, file.ino);
-            return { ino: file.ino, created, directory: { before, after: directoryNow(entry.parent).revision } };
+            yield* (yield* Draft).retain(file.ino);
+            yield* bindFile(acquired, file.ino);
+            return { ino: file.ino, created, directory: { before, after: (yield* directoryNow(entry.parent)).revision } };
         });
-        const releasePending = (opened) => () => {
+        const releasePending = (opened) => () => Effect.gen(function* () {
             const ino = opened();
             if (ino === undefined)
                 return;
-            current().release(ino);
-            reclaim(current(), ino);
-        };
+            const draft = yield* Draft;
+            yield* draft.release(ino);
+            yield* reclaim(draft, ino);
+        });
         const acquireOpenedFile = (ref, op, acquire) => {
             let opened;
             return acquireHandle(ref, (effect) => coordinated(op, effect), acquire((ino) => {
@@ -1521,7 +1564,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 return yield* op.fail("InvalidHandle");
             if (ref.volume !== volumeIdentity)
                 return yield* op.fail("ForeignHandle");
-            const node = ref.ino === undefined ? undefined : view(ref.ino);
+            const node = ref.ino === undefined ? undefined : (yield* view(ref.ino));
             if (node === undefined)
                 return yield* op.fail("InvalidHandle");
             return node;
@@ -1561,7 +1604,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             if (!isAttachedBytes(bytes) || bytes.length === 0 || bytes.length > MAX_NAME_BYTES || bytes.includes(0) ||
                 bytes.includes(SLASH_BYTE))
                 return Result.fail(op.fail("InvalidArgument"));
-            return Result.succeed(Encoding.encodeHex(new Uint8Array(bytes)));
+            return Result.succeed(Hex.encode(new Uint8Array(bytes)));
         };
         const prepareEntry = (input, op) => isEntry(input)
             ? Result.map(entryName(input.name, op), (name) => ({ kind: "entry", directory: input.directory, name }))
@@ -1594,7 +1637,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             }), 
             // Nothing to undo here: the finalizer that follows an interrupted acquisition releases the hold under
             // every permit, where a detached directory may leave the table.
-            () => { }, finalizeDirectory(acquired));
+            () => Effect.void, finalizeDirectory(acquired));
         });
         const fail = (op, cause, field) => op.fail("InvalidArgument", field === undefined ? { cause } : { cause, field });
         const preparedOp = (prepared, op) => prepared.kind === "path" ? op.at(prepared.path.input) : op;
@@ -1656,8 +1699,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 if (node.metadata.nlink === 0)
                     return yield* resolved.op.fail("StaleReference");
                 yield* openExisting(node, chosen, resolved.op, op);
-                current().retain(node.ino);
-                bindFile(acquired, node.ino);
+                const draft = yield* Draft;
+                yield* draft.retain(node.ino);
+                yield* bindFile(acquired, node.ino);
                 opened(node.ino);
                 return fileHandle(acquired);
             }));
@@ -1684,7 +1728,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                     return yield* op.fail("InvalidArgument");
                 yield* authorize(parent, identity, EXECUTE, op);
                 const directIno = parent.entries.get(name);
-                const direct = directIno === undefined ? undefined : view(directIno);
+                const direct = directIno === undefined ? undefined : (yield* view(directIno));
                 if (expected !== undefined) {
                     let expectedIno;
                     if (expected !== null) {
@@ -1739,29 +1783,31 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 };
             }));
         });
-        const walkChildren = (directory, path, depth, up) => {
+        const walkChildren = Effect.fnUntraced(function* (directory, path, depth, up) {
             const listed = referenceFor(directory.ino);
-            return Arr.flatMap(Arr.sort(directory.entries, byEntryName), ([name, childIno]) => {
-                const child = view(childIno);
+            const frames = [];
+            for (const [name, childIno] of Arr.sort(directory.entries, byEntryName)) {
+                const child = yield* view(childIno);
                 if (child === undefined)
-                    return [];
+                    continue;
                 const bytes = nameBytes(name);
-                return [{
-                        ino: child.ino,
-                        kind: child.kind,
-                        name: bytes,
-                        key: name,
-                        path: joinPath(path, bytes),
-                        parent: directory.ino,
-                        up,
-                        depth: depth + 1,
-                        bytes: child.kind === "directory" ? 0n : child.metadata.size,
-                        reference: referenceFor(child.ino),
-                        directory: listed,
-                        listed: false
-                    }];
-            });
-        };
+                frames.push({
+                    ino: child.ino,
+                    kind: child.kind,
+                    name: bytes,
+                    key: name,
+                    path: joinPath(path, bytes),
+                    parent: directory.ino,
+                    up,
+                    depth: depth + 1,
+                    bytes: child.kind === "directory" ? 0n : child.metadata.size,
+                    reference: referenceFor(child.ino),
+                    directory: listed,
+                    listed: false
+                });
+            }
+            return frames;
+        });
         const anchorFrame = (parent, key, root) => ({
             ino: root.ino,
             kind: root.kind,
@@ -1782,13 +1828,12 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             const prepared = prepare(target.path, op);
             if (Result.isFailure(prepared))
                 return Effect.undefined;
-            return ResolvedEntry.fromPath(prepared.success, target.relativeTo, op).pipe(Effect.map((entry) => {
-                const parent = view(entry.parent);
+            return ResolvedEntry.fromPath(prepared.success, target.relativeTo, op).pipe(Effect.flatMap((entry) => Effect.map(view(entry.parent), (parent) => {
                 return entry.name !== undefined && parent?.kind === "directory" &&
                     parent.entries.get(entry.name) === root.ino
                     ? anchorFrame(parent, entry.name, root)
                     : undefined;
-            }), Effect.catch(() => Effect.undefined));
+            })), Effect.catch(() => Effect.undefined));
         };
         const holds = (parent, frame) => parent?.kind === "directory" && parent.metadata.nlink > 0 && parent.entries.get(frame.key) === frame.ino;
         // The node a frame names, reached by name from the walk's root as a path lookup reaches it: every directory on
@@ -1801,13 +1846,13 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             const chain = [];
             for (let link = frame; link !== undefined; link = link.up)
                 chain.push(link);
-            let node = view((chain.at(-1) ?? frame).parent);
+            let node = yield* view((chain.at(-1) ?? frame).parent);
             for (let index = chain.length - 1; index >= 0; index--) {
                 const link = chain[index];
                 if (link === undefined || node?.kind !== "directory" || node.metadata.nlink === 0)
                     return undefined;
                 yield* authorize(node, identity, EXECUTE, at);
-                node = node.entries.get(link.key) === link.ino ? view(link.ino) : undefined;
+                node = node.entries.get(link.key) === link.ino ? (yield* view(link.ino)) : undefined;
             }
             return node;
         });
@@ -1828,7 +1873,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 const at = op.at(locate(frame.path));
                 return Effect.flatMap(reachFrame(frame, at), (node) => node?.kind !== "directory" || node.metadata.nlink === 0
                     ? Effect.succeed([])
-                    : Effect.as(listable(node, at), walkChildren(node, frame.path, frame.depth, frame)));
+                    : Effect.andThen(listable(node, at), walkChildren(node, frame.path, frame.depth, frame)));
             }));
             const exceeded = (frame, field) => makeError({ code: "LimitExceeded", operation: op.operation, field, path: errorPath(locate(frame.path)) });
             const admit = (frame) => {
@@ -1900,10 +1945,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
             let targetAt = preparedOp(prepared, op);
             const first = coordinatedRead(op, Effect.gen(function* () {
                 const entry = yield* resolveEntry(prepared, op);
-                const parent = directoryNow(entry.parent);
+                const parent = yield* directoryNow(entry.parent);
                 yield* authorize(parent, identity, EXECUTE, entry.op);
                 const childIno = entry.name === undefined ? undefined : parent.entries.get(entry.name);
-                const child = childIno === undefined ? undefined : view(childIno);
+                const child = childIno === undefined ? undefined : (yield* view(childIno));
                 if (entry.name === undefined || child === undefined)
                     return yield* entry.op.fail("NotFound");
                 if (child.kind !== "directory")
@@ -1911,16 +1956,16 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 yield* listable(child, entry.op);
                 anchor = anchorFrame(parent, entry.name, child);
                 targetAt = entry.op;
-                return walkChildren(child, new Uint8Array(0), 0, anchor);
+                return yield* walkChildren(child, new Uint8Array(0), 0, anchor);
             })).pipe(Effect.catchIf((error) => force && error.code === "NotFound", () => Effect.succeed([])));
             const seams = yield* VolumeTestSeams;
             const removeFrame = (frame) => {
                 const at = op.at(locate(frame.path));
-                return Effect.andThen(seams.beforeTreeRemoval, coordinated(op, Effect.suspend(() => {
-                    if (anchor !== undefined && !holds(view(anchor.parent), anchor)) {
-                        return force ? Effect.void : Effect.fail(targetAt.fail("NotFound"));
+                return Effect.andThen(seams.beforeTreeRemoval, coordinated(op, Effect.gen(function* () {
+                    if (anchor !== undefined && !holds(yield* view(anchor.parent), anchor)) {
+                        return yield* (force ? Effect.void : Effect.fail(targetAt.fail("NotFound")));
                     }
-                    return Effect.flatMap(frame.up === undefined ? Effect.succeed(view(frame.parent)) : reachFrame(frame.up, at), (parent) => !holds(parent, frame)
+                    return yield* Effect.flatMap(frame.up === undefined ? view(frame.parent) : reachFrame(frame.up, at), (parent) => !holds(parent, frame)
                         ? Effect.fail(at.fail("NotFound"))
                         : removeEntry({
                             parent: parent.ino,
@@ -1950,7 +1995,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 const prepared = yield* Effect.fromResult(prepareEntry(input, op));
                 return yield* coordinatedRead(op, Effect.gen(function* () {
                     const entry = yield* resolveEntry(prepared, op);
-                    const directory = directoryNow(entry.parent);
+                    const directory = yield* directoryNow(entry.parent);
                     if (isDotComponent(entry.name)) {
                         return yield* entry.op.fail(entry.addressing === "entry" ? "InvalidArgument" : "NotFound");
                     }
@@ -1997,7 +2042,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                     const first = coordinatedRead(op, Effect.gen(function* () {
                         const directory = yield* resolveDirectory(target, op);
                         yield* authorize(directory.node, identity, READ, directory.op);
-                        return walkChildren(directory.node, new Uint8Array(0), 0, yield* pathAnchor(target, directory.node, op));
+                        return yield* walkChildren(directory.node, new Uint8Array(0), 0, yield* pathAnchor(target, directory.node, op));
                     }));
                     const plan = {
                         order: chosen.order ?? "pre",
@@ -2033,7 +2078,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                         const pathOp = op.at(target.path);
                         const result = yield* lookup(yield* Effect.fromResult(prepare(target.path, op)), target.relativeTo, op);
                         const directory = result.node?.kind === "directory" ? result.node : result.parent;
-                        const prefix = directory === undefined ? SLASH_HEX : pathOf(view, directory.ino);
+                        const prefix = directory === undefined ? SLASH_HEX : yield* pathOfCurrent(directory.ino);
                         if (prefix === undefined)
                             return yield* pathOp.fail("NotFound");
                         if (result.node?.kind === "directory" || result.name === undefined)
@@ -2041,7 +2086,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                         return ownedPath(nameBytes(prefix + (prefix === SLASH_HEX ? "" : SLASH_HEX) + result.name));
                     }
                     const resolved = yield* resolveTarget(target, op);
-                    const path = pathOf(view, resolved.node.ino);
+                    const path = yield* pathOfCurrent(resolved.node.ino);
                     if (path === undefined)
                         return yield* resolved.op.fail("NotFound");
                     return ownedPath(nameBytes(path));
@@ -2126,7 +2171,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                         parent = directory.node;
                         name = prepared.name;
                         const childIno = parent.entries.get(name);
-                        let child = childIno === undefined ? undefined : view(childIno);
+                        let child = childIno === undefined ? undefined : (yield* view(childIno));
                         if (child?.kind === "symlink" && chosen.replaceFinalSymlink !== true &&
                             chosen.followFinalSymlink !== false) {
                             const resolved = yield* lookup(yield* Effect.fromResult(preparePath(ownedPath(nameBytes(name)), op.operation, undefined)), undefined, op, {
@@ -2161,7 +2206,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                         yield* authorize(parent, identity, WRITE | EXECUTE, entryOp);
                         if (replaced !== undefined)
                             yield* authorizeRemoval(parent, replaced, entryOp);
-                        yield* replaced === undefined ? reserveEntry(entryOp) : reserveInode(entryOp);
+                        yield* (replaced === undefined ? reserveEntry(entryOp) : reserveInode(entryOp));
                     }
                     else {
                         yield* authorize(file, identity, chosen.access === "readWrite" ? READ | WRITE : WRITE, entryOp);
@@ -2186,8 +2231,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                         data.set(captured, position);
                     }
                     const now = yield* timestamp(op);
-                    const d = current();
-                    const node = file ?? newFile(parent, new Uint8Array(0), (chosen.mode ?? 0o666) & 0o777 & ~umask, now);
+                    const d = yield* Draft;
+                    const node = file ??
+                        (yield* newFile(parent, new Uint8Array(0), (chosen.mode ?? 0o666) & 0o777 & ~umask, now));
                     const written = {
                         ...node,
                         data,
@@ -2199,18 +2245,18 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                             ctimeNs: now
                         }
                     };
-                    d.usedBytes += BigInt(size - previous);
+                    yield* d.addUsedBytes(BigInt(size - previous));
                     if (file === undefined) {
                         if (replaced !== undefined)
-                            detach(replaced, parent.ino, name, now);
-                        attach(directoryNow(parent.ino), name, written, now);
+                            yield* detach(replaced, parent.ino, name, now);
+                        yield* attach(yield* directoryNow(parent.ino), name, written, now);
                         if (replaced === undefined)
-                            d.entries += 1;
-                        publishEntry(replaced === undefined ? "Create" : "Update", parent.ino, name, written.ino);
+                            yield* d.addEntries(1);
+                        yield* publishEntry(replaced === undefined ? "Create" : "Update", parent.ino, name, written.ino);
                     }
                     else {
-                        d.put(written);
-                        publishNode(written.ino);
+                        yield* d.put(written);
+                        yield* publishNode(written.ino);
                     }
                 }));
             }),
@@ -2371,18 +2417,17 @@ export const makeVolume = Effect.fnUntraced(function* (source, options, commitPr
                 const statOp = OpContext.make("stat");
                 const handle = Object.freeze({
                     [DirectoryHandleId]: true,
-                    stat: coordinatedRead(statOp, Effect.suspend(() => {
-                        const node = acquired.ino === undefined ? undefined : view(acquired.ino);
-                        return node === undefined
+                    stat: coordinatedRead(statOp, Effect.gen(function* () {
+                        const node = acquired.ino === undefined ? undefined : yield* view(acquired.ino);
+                        return yield* (node === undefined
                             ? Effect.fail(statOp.fail("InvalidHandle"))
-                            : Effect.succeed(withMetadata(node));
+                            : Effect.succeed(withMetadata(node)));
                     })).pipe(Effect.withSpan("DirectoryHandle.stat")),
                     close: coordinatedCleanup(Effect.suspend(() => {
                         if (acquired.ino === undefined) {
                             return Effect.fail(OpContext.make("close").fail("InvalidHandle"));
                         }
-                        releaseDirectory(acquired);
-                        return Effect.void;
+                        return releaseDirectory(acquired);
                     })).pipe(Effect.ensuring(closeReleasedScope(acquired)), Effect.withSpan("DirectoryHandle.close"))
                 });
                 handles.set(handle, acquired);