@effect-vfs/core 0.3.1 → 0.5.0

package/dist/internal/virtualFileSystem.js

@@ -1,10 +1,12 @@
 // Runtime definitions and cohesive live virtual filesystem engine.
 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 Exit from "effect/Exit";
+import * as Order from "effect/Order";
 import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
@@ -12,14 +14,16 @@ import * as Semaphore from "effect/Semaphore";
 import { BytePath } from "../BytePath.js";
 import { ImageError } from "../Snapshot.js";
 import { CanonicalBase64 } from "./canonicalBase64.js";
+import { ConfigurationError, decodeConfiguration, FsCode as FsCodeSchema, FsError } from "./errors.js";
 import * as Image from "./image.js";
+import * as LiveImage from "./liveImage.js";
 import * as MetadataDomain from "./metadata.js";
-import { ConfigurationError, decodeConfiguration, FsCode as FsCodeSchema, FsError } from "./virtualFileSystem/errors.js";
-import * as Content from "./virtualFileSystem/overlayContent.js";
-import { compareOverlay } from "./virtualFileSystem/overlayDiff.js";
-import { DOT_DOT_HEX, DOT_HEX, inputBytes, isAttachedBytes, isDotComponent, MAX_NAME_BYTES, nameBytes, ownedPath, preparePath, SLASH_BYTE, SLASH_HEX, strictString } from "./virtualFileSystem/path.js";
-import * as TestHooks from "./virtualFileSystem/testHooks.js";
-import * as WatchHub from "./virtualFileSystem/watchHub.js";
+import * as Content from "./overlayContent.js";
+import { compareOverlay } from "./overlayDiff.js";
+import { DOT_DOT_HEX, DOT_HEX, inputBytes, isAttachedBytes, isDotComponent, MAX_NAME_BYTES, nameBytes, ownedPath, preparePath, SLASH_BYTE, SLASH_HEX, strictString } from "./path.js";
+import { makeStagedState } from "./stagedState.js";
+import * as TestHooks from "./testHooks.js";
+import * as WatchHub from "./watchHub.js";
 /** @internal */
 export const VolumeId = Symbol("@effect-vfs/core/Volume");
 /** @internal */
@@ -60,9 +64,34 @@ export const RootCallerOptions = Schema.Struct({
     identity: Schema.optionalKey(Identity),
     umask: Schema.optionalKey(Schema.Natural.check(Schema.isLessThanOrEqualTo(0o777)))
 });
+const Hex128 = Schema.String.check(Schema.isPattern(/^[0-9a-f]{32}$/));
+/** @internal */
+export const VolumeDurability = Schema.Literals([
+    "memory-only",
+    "survives-process-crash",
+    "survives-operating-system-crash",
+    "survives-power-loss"
+]);
+const durabilityRank = {
+    "memory-only": 0,
+    "survives-process-crash": 1,
+    "survives-operating-system-crash": 2,
+    "survives-power-loss": 3
+};
+/** @internal */
+export const VolumeDurabilityOrder = Order.mapInput(Order.Number, (durability) => durabilityRank[durability]);
+/** @internal */
+export const isVolumeDurabilityAtLeast = (actual, required) => VolumeDurabilityOrder(actual, required) >= 0;
+/** @internal */
+export const VolumeIdentity = Hex128.pipe(Schema.brand("@effect-vfs/core/VolumeIdentity"));
+/** @internal */
+export const VolumeIncarnation = Hex128.pipe(Schema.brand("@effect-vfs/core/VolumeIncarnation"));
 /** @internal */
 export const VolumeOptions = Schema.Struct({
+    identity: Schema.optionalKey(VolumeIdentity),
     maxEntries: Schema.optionalKey(Schema.Natural),
+    maxPendingOperations: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))),
+    maxWatchEvents: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(2))),
     maxBytes: Schema.optionalKey(Schema.ByteSize),
     maxFileBytes: Schema.optionalKey(Schema.ByteSize.check(Schema.makeFilter((size) => ByteSize.isLessThanOrEqualTo(size, ByteSize.bytes(0xffffffff)) ? undefined : "must be at most 4294967295 bytes"))),
     maxPathBytes: Schema.optionalKey(Schema.ByteSize.check(Schema.makeFilter((size) => ByteSize.isGreaterThanOrEqualTo(size, ByteSize.bytes(1)) ? undefined : "must be at least 1 byte")))
@@ -107,6 +136,49 @@ export const OpenSettings = Schema.Struct({
     truncate: Schema.optionalKey(Schema.Boolean),
     followFinalSymlink: Schema.optionalKey(Schema.Boolean)
 });
+/** @internal */
+export const DirectoryChange = Schema.Struct({
+    before: Schema.BigInt,
+    after: Schema.BigInt
+});
+/** @internal */
+export const RenameReferenceResult = Schema.TaggedUnion({
+    SameDirectory: { directory: DirectoryChange },
+    DifferentDirectories: {
+        sourceDirectory: DirectoryChange,
+        destinationDirectory: DirectoryChange
+    }
+});
+/** @internal */
+export const MkdirReferenceSettings = Schema.Struct({
+    mode: Schema.optionalKey(Mode),
+    exactMode: Schema.optionalKey(Schema.Boolean),
+    times: Schema.optionalKey(Times)
+});
+/** @internal */
+export const SymlinkReferenceSettings = Schema.Struct({
+    times: Schema.optionalKey(Times)
+});
+/** @internal */
+export const OpenReferenceSettings = Schema.Struct({
+    access: Schema.Literals(["read", "write", "readWrite"]),
+    append: Schema.optionalKey(Schema.Boolean),
+    truncate: Schema.optionalKey(Schema.Boolean)
+});
+/** @internal */
+export const OpenChildReferenceSettings = Schema.Struct({
+    ...OpenSettings.fields,
+    times: Schema.optionalKey(Times),
+    initialSize: Schema.optionalKey(Schema.BigInt),
+    exactMode: Schema.optionalKey(Schema.Boolean),
+    owner: Schema.optionalKey(OwnerUpdate),
+    expectedChild: Schema.optionalKey(Schema.NullOr(Schema.Struct({
+        reference: Schema.declare((input) => Predicate.hasProperty(ObjectReferenceId)(input) && input[ObjectReferenceId] === true),
+        revision: Schema.BigInt,
+        atimeNs: MetadataDomain.Timestamp,
+        mtimeNs: MetadataDomain.Timestamp
+    })))
+});
 const WriteFileSettings = Schema.Struct({
     ...OpenSettings.fields,
     replaceFinalSymlink: Schema.optionalKey(Schema.Boolean),
@@ -116,6 +188,10 @@ const decodeOwnerUpdate = Schema.decodeResult(OwnerUpdate, { onExcessProperty: "
 const decodeTimes = Schema.decodeResult(Times, { onExcessProperty: "error" });
 const decodeWriteFileSettings = Schema.decodeResult(WriteFileSettings, { onExcessProperty: "error" });
 const decodeOpenSettings = Schema.decodeResult(OpenSettings, { onExcessProperty: "error" });
+const decodeMkdirReferenceSettings = Schema.decodeResult(MkdirReferenceSettings, { onExcessProperty: "error" });
+const decodeSymlinkReferenceSettings = Schema.decodeResult(SymlinkReferenceSettings, { onExcessProperty: "error" });
+const decodeOpenReferenceSettings = Schema.decodeResult(OpenReferenceSettings, { onExcessProperty: "error" });
+const decodeOpenChildReferenceSettings = Schema.decodeResult(OpenChildReferenceSettings, { onExcessProperty: "error" });
 /** @internal */
 export const OverlayNodeKind = Schema.Literals(["directory", "file", "symlink"]);
 /** @internal */
@@ -154,9 +230,6 @@ export const OverlayChangesOptions = Schema.Struct({
     includeTimestamps: Schema.optionalKey(Schema.Boolean)
 });
 /** @internal */
-export class CurrentFileSystem extends Context.Service()("@effect-vfs/core/CurrentFileSystem") {
-}
-/** @internal */
 export const FixtureMetadata = Schema.Struct({
     uid: Schema.optionalKey(Schema.Natural),
     gid: Schema.optionalKey(Schema.Natural),
@@ -196,6 +269,68 @@ export const Fixture = Schema.Struct({
     rootMetadata: Schema.optionalKey(FixtureMetadata),
     entries: Schema.Array(FixtureEntry)
 });
+/** @internal */
+export const captureLiveImage = Effect.fnUntraced(function* (state, identity, limits) {
+    const records = [];
+    const visited = new Set();
+    const pending = [state.root, ...state.retainedFiles.values()];
+    for (let index = 0; index < pending.length; index++) {
+        if (index % WALK_YIELD_INTERVAL === 0)
+            yield* Effect.yieldNow;
+        const node = pending[index];
+        if (node === undefined || visited.has(node.metadata.ino))
+            continue;
+        visited.add(node.metadata.ino);
+        const common = {
+            ino: node.metadata.ino,
+            revision: node.revision,
+            metadata: {
+                ...storedMetadata(node.metadata),
+                nlink: node.metadata.nlink,
+                size: node.metadata.size
+            }
+        };
+        if (node.lineage !== undefined)
+            common.lineage = node.lineage;
+        if (node.kind === "directory") {
+            const entries = [];
+            for (const [name, child] of node.entries) {
+                entries.push({ name: CanonicalBase64.encode(nameBytes(name)), target: child.metadata.ino });
+                pending.push(child);
+            }
+            records.push(LiveImage.Record.cases.directory.make({ ...common, entries }));
+        }
+        else if (node.kind === "file") {
+            records.push(LiveImage.Record.cases.file.make({ ...common, data: CanonicalBase64.encode(node.data.bytes) }));
+        }
+        else {
+            records.push(LiveImage.Record.cases.symlink.make({ ...common, target: CanonicalBase64.encode(node.target) }));
+        }
+    }
+    const storedLimits = {};
+    if (limits.maxEntries !== undefined)
+        storedLimits.maxEntries = limits.maxEntries;
+    if (limits.maxBytes !== undefined)
+        storedLimits.maxBytes = ByteSize.toBigInt(limits.maxBytes);
+    if (limits.maxFileBytes !== undefined)
+        storedLimits.maxFileBytes = ByteSize.toBigInt(limits.maxFileBytes);
+    if (limits.maxPathBytes !== undefined)
+        storedLimits.maxPathBytes = ByteSize.toBigInt(limits.maxPathBytes);
+    const document = {
+        format: "effect-vfs-live",
+        version: 1,
+        identity,
+        root: state.root.metadata.ino,
+        nextInode: state.nextInode,
+        revisionCounter: state.revisionCounter,
+        entries: state.entries,
+        usedBytes: state.usedBytes,
+        limits: storedLimits,
+        retainedFiles: [...state.retainedFiles.keys()],
+        records
+    };
+    return yield* LiveImage.encode(document);
+});
 const objectReferences = new WeakMap();
 const isFileHandle = (value) => Predicate.hasProperty(FileHandleId)(value);
 // Only a PathInput target names a path; a handle-based call has none to report in its error.
@@ -228,14 +363,34 @@ const storedMetadata = (metadata) => ({
 /** @internal */
 export const VolumeSource = Data.taggedEnum();
 const UpdateChange = Schema.TaggedStruct("Update", { path: BytePath });
+const RescanChange = Schema.TaggedStruct("Rescan", { path: BytePath });
 // Each execution constructs a fresh volume and captures its Clock.
 /** @internal */
-export const makeVolume = Effect.fnUntraced(function* (source, options) {
+export const makeVolume = Effect.fnUntraced(function* (source, options, commitProvider, captureInitial, durability = "memory-only") {
     const image = "image" in source ? source.image : undefined;
-    const decoded = decodeConfiguration(VolumeOptions, options === undefined ? {} : options);
+    const live = Predicate.isTagged("Live")(source) ? source.document : undefined;
+    let restoredOptions = options;
+    if (live !== undefined) {
+        const recovered = { identity: VolumeIdentity.make(live.identity) };
+        if (live.limits.maxEntries !== undefined)
+            recovered.maxEntries = live.limits.maxEntries;
+        if (live.limits.maxBytes !== undefined)
+            recovered.maxBytes = ByteSize.bytes(live.limits.maxBytes);
+        if (live.limits.maxFileBytes !== undefined)
+            recovered.maxFileBytes = ByteSize.bytes(live.limits.maxFileBytes);
+        if (live.limits.maxPathBytes !== undefined)
+            recovered.maxPathBytes = ByteSize.bytes(live.limits.maxPathBytes);
+        restoredOptions = recovered;
+    }
+    const decoded = decodeConfiguration(VolumeOptions, restoredOptions === undefined ? {} : restoredOptions);
     if (Result.isFailure(decoded))
         return yield* decoded.failure;
     const settings = { ...decoded.success };
+    const crypto = yield* Crypto.Crypto;
+    const identity = settings.identity === undefined
+        ? VolumeIdentity.make(Encoding.encodeHex(yield* crypto.randomBytes(16)))
+        : VolumeIdentity.make(settings.identity);
+    const incarnation = VolumeIncarnation.make(Encoding.encodeHex(yield* crypto.randomBytes(16)));
     const clock = yield* Clock.clockWith(Effect.succeed);
     const initialTime = clock.currentTimeNanosUnsafe();
     if (!isTimestamp(initialTime)) {
@@ -248,28 +403,177 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             : Effect.fail(new FsError({ code: "InvalidArgument", operation: operation }));
     });
     const volumeIdentity = Symbol();
+    let activeStage;
+    const fileReferences = new Set();
+    const directoryReferences = new Set();
+    // A capability holds a cell instead of a particular node object. Publication can replace
+    // the node behind the cell without replacing the capability held by a caller.
+    const cells = new WeakMap();
+    const cellFor = (node) => {
+        const existing = cells.get(node);
+        if (existing !== undefined)
+            return existing;
+        const previous = activeStage?.previous.get(node);
+        const retained = previous === undefined ? undefined : cells.get(previous);
+        if (retained !== undefined) {
+            cells.set(node, retained);
+            return retained;
+        }
+        let current = node;
+        const cell = {
+            get node() {
+                return activeStage?.nodes.get(current) ?? current;
+            },
+            set node(next) {
+                current = next;
+            }
+        };
+        cells.set(node, cell);
+        return cell;
+    };
+    const makeFileReference = (access, append) => {
+        const live = { cell: undefined, closed: false, offset: 0n };
+        let reference;
+        const record = () => {
+            if (activeStage === undefined)
+                return live;
+            let staged = activeStage.files.get(reference);
+            if (staged === undefined) {
+                staged = { ...live };
+                activeStage.files.set(reference, staged);
+                const pending = staged;
+                activeStage.apply.push(() => {
+                    Object.assign(live, pending);
+                    if (live.cell === undefined)
+                        fileReferences.delete(reference);
+                    else
+                        fileReferences.add(reference);
+                });
+            }
+            return staged;
+        };
+        reference = {
+            volume: volumeIdentity,
+            get file() {
+                const node = record().cell?.node;
+                return node?.kind === "file" ? node : undefined;
+            },
+            set file(file) {
+                record().cell = file === undefined ? undefined : cellFor(file);
+                if (activeStage === undefined) {
+                    if (file === undefined)
+                        fileReferences.delete(reference);
+                    else
+                        fileReferences.add(reference);
+                }
+            },
+            get closed() {
+                return record().closed;
+            },
+            set closed(value) {
+                record().closed = value;
+            },
+            get offset() {
+                return record().offset;
+            },
+            set offset(value) {
+                record().offset = value;
+            },
+            access,
+            append
+        };
+        return reference;
+    };
+    const makeDirectoryReference = (directory) => {
+        const live = {
+            cell: directory === undefined ? undefined : cellFor(directory),
+            closed: false
+        };
+        let reference;
+        const record = () => {
+            if (activeStage === undefined)
+                return live;
+            let staged = activeStage.directories.get(reference);
+            if (staged === undefined) {
+                staged = { ...live };
+                activeStage.directories.set(reference, staged);
+                const pending = staged;
+                activeStage.apply.push(() => {
+                    Object.assign(live, pending);
+                    if (live.cell === undefined || live.cell.node === state.root)
+                        directoryReferences.delete(reference);
+                    else
+                        directoryReferences.add(reference);
+                });
+            }
+            return staged;
+        };
+        reference = {
+            volume: volumeIdentity,
+            get directory() {
+                const node = record().cell?.node;
+                return node?.kind === "directory" ? node : undefined;
+            },
+            set directory(directory) {
+                record().cell = directory === undefined ? undefined : cellFor(directory);
+                if (activeStage === undefined) {
+                    if (directory === undefined || directory === state.root)
+                        directoryReferences.delete(reference);
+                    else
+                        directoryReferences.add(reference);
+                }
+            },
+            get closed() {
+                return record().closed;
+            },
+            set closed(value) {
+                record().closed = value;
+            }
+        };
+        if (directory !== undefined && directory !== state.root && activeStage === undefined) {
+            directoryReferences.add(reference);
+        }
+        return reference;
+    };
     const gate = Semaphore.makeUnsafe(1);
-    let revisionCounter = 0n;
-    const nextRevision = () => ++revisionCounter;
-    const root = {
-        kind: "directory",
-        lineage: image?.root,
-        parent: undefined,
-        entries: new Map(),
-        metadata: directoryMetadata(1n, 0, 0, 0o755, initialTime),
-        revision: nextRevision(),
-        objectReference: undefined
+    const maxPendingOperations = settings.maxPendingOperations ?? 64;
+    let admitted = 0;
+    const admit = (operation, effect) => Effect.suspend(() => {
+        if (admitted >= maxPendingOperations + 1) {
+            return Effect.fail(new FsError({ code: "VolumeBusy", operation }));
+        }
+        admitted += 1;
+        return effect.pipe(Effect.ensuring(Effect.sync(() => {
+            admitted -= 1;
+        })));
+    });
+    let state = {
+        root: {
+            kind: "directory",
+            lineage: image?.root,
+            parent: undefined,
+            entries: new Map(),
+            metadata: directoryMetadata(1n, 0, 0, 0o755, initialTime),
+            revision: 1n,
+            objectReference: undefined
+        },
+        retainedFiles: new Map(),
+        revisionCounter: 1n,
+        nextInode: 2n,
+        entries: 0,
+        usedBytes: 0n
     };
-    let nextInode = 2n;
-    let entries = 0;
-    let usedBytes = 0n;
+    const nextRevision = () => ++state.revisionCounter;
     // The schema caps this value at uint32, so this boundary conversion is exact.
     const maxFileBytes = Number(ByteSize.toBigInt(settings.maxFileBytes ?? ByteSize.bytes(0xffffffff)));
-    // Permit waits stay interruptible. State transitions and resource registration do not.
-    const coordinated = (effect) => gate.withPermit(Effect.uninterruptible(effect));
-    // Read-only walks hold the permit but mutate nothing, so abandoning one midway loses only
-    // local state. Interruptible so a cancelled snapshot actually stops.
-    const coordinatedRead = (effect) => gate.withPermit(effect);
+    const limits = Object.freeze({
+        maxBytes: settings.maxBytes,
+        maxFileBytes: ByteSize.bytes(maxFileBytes),
+        maxEntries: settings.maxEntries,
+        maxPathBytes: settings.maxPathBytes,
+        maxPendingOperations: settings.maxPendingOperations ?? 64,
+        maxWatchEvents: settings.maxWatchEvents ?? 256
+    });
     if (image !== undefined) {
         const incoming = new Map();
         let content = 0n;
@@ -294,7 +598,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             const metadata = {
                 ...record.metadata,
                 kind: record._tag,
-                ino: record.id === image.root ? 1n : nextInode++,
+                ino: record.id === image.root ? 1n : state.nextInode++,
                 nlink: Image.Record.guards.directory(record) ? 2 : 0,
                 size: 0n,
                 atimeNs: record.metadata.atimeNs,
@@ -304,7 +608,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             };
             if (Image.Record.guards.directory(record)) {
                 const node = record.id === image.root
-                    ? root
+                    ? state.root
                     : {
                         kind: "directory",
                         lineage: record.id,
@@ -360,10 +664,191 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     node.metadata = { ...node.metadata, nlink: node.metadata.nlink + 1 };
             }
         }
-        entries = count;
-        usedBytes = content;
+        state.entries = count;
+        state.usedBytes = content;
     }
-    const watchHub = yield* WatchHub.make(coordinated);
+    if (live !== undefined) {
+        const incoming = new Map();
+        for (const record of live.records) {
+            const metadata = {
+                ...record.metadata,
+                kind: record._tag,
+                ino: record.ino
+            };
+            if (LiveImage.Record.guards.directory(record)) {
+                incoming.set(record.ino, {
+                    kind: "directory",
+                    lineage: record.lineage,
+                    parent: undefined,
+                    entries: new Map(),
+                    metadata,
+                    revision: record.revision,
+                    objectReference: undefined
+                });
+            }
+            else if (LiveImage.Record.guards.file(record)) {
+                incoming.set(record.ino, {
+                    kind: "file",
+                    lineage: record.lineage,
+                    data: Content.make(yield* CanonicalBase64.decode(record.data)),
+                    openCount: 0,
+                    metadata,
+                    revision: record.revision,
+                    objectReference: undefined
+                });
+            }
+            else {
+                incoming.set(record.ino, {
+                    kind: "symlink",
+                    lineage: record.lineage,
+                    target: yield* CanonicalBase64.decode(record.target),
+                    metadata,
+                    revision: record.revision,
+                    objectReference: undefined
+                });
+            }
+        }
+        for (const record of live.records) {
+            if (!LiveImage.Record.guards.directory(record))
+                continue;
+            const parent = incoming.get(record.ino);
+            if (parent?.kind !== "directory")
+                return yield* new ImageError({ code: "InvalidStructure" });
+            for (const entry of record.entries) {
+                const child = incoming.get(entry.target);
+                if (child === undefined)
+                    return yield* new ImageError({ code: "InvalidStructure" });
+                parent.entries.set(Encoding.encodeHex(yield* CanonicalBase64.decode(entry.name)), child);
+                if (child.kind === "directory")
+                    child.parent = parent;
+            }
+        }
+        const root = incoming.get(live.root);
+        if (root?.kind !== "directory")
+            return yield* new ImageError({ code: "InvalidStructure" });
+        state.root = root;
+        state.nextInode = live.nextInode;
+        state.revisionCounter = live.revisionCounter;
+        state.entries = live.entries;
+        state.usedBytes = live.usedBytes;
+        // A previous process's handles no longer exist. Their zero-link files
+        // remain in the stored image but are reclaimed from this runtime state.
+        for (const ino of live.retainedFiles) {
+            const orphan = incoming.get(ino);
+            if (orphan?.kind !== "file")
+                return yield* new ImageError({ code: "InvalidStructure" });
+            state.usedBytes -= BigInt(orphan.data.bytes.length);
+        }
+    }
+    if (captureInitial !== undefined)
+        yield* captureInitial(state, identity, limits);
+    const contexts = new WeakMap();
+    const copyState = (current) => Effect.sync(() => {
+        const nodes = new Map();
+        const copyDirectory = (node) => {
+            const existing = nodes.get(node);
+            if (existing?.kind === "directory")
+                return existing;
+            const copy = { ...node, entries: new Map(), metadata: { ...node.metadata }, parent: undefined };
+            nodes.set(node, copy);
+            copy.parent = node.parent === undefined ? undefined : copyDirectory(node.parent);
+            for (const [name, child] of node.entries)
+                copy.entries.set(name, copyNode(child));
+            return copy;
+        };
+        const copyNode = (node) => {
+            if (node.kind === "directory")
+                return copyDirectory(node);
+            const existing = nodes.get(node);
+            if (existing !== undefined)
+                return existing;
+            const copy = { ...node, metadata: { ...node.metadata } };
+            nodes.set(node, copy);
+            return copy;
+        };
+        const candidate = { ...current, root: copyDirectory(current.root), retainedFiles: new Map() };
+        for (const [ino, file] of current.retainedFiles) {
+            const copy = copyNode(file);
+            if (copy.kind === "file")
+                candidate.retainedFiles.set(ino, copy);
+        }
+        // Open resources keep zero-link objects alive after the namespace stops reaching them.
+        for (const reference of fileReferences) {
+            const file = reference.file;
+            if (file !== undefined)
+                copyNode(file);
+        }
+        for (const reference of directoryReferences) {
+            const directory = reference.directory;
+            if (directory !== undefined)
+                copyDirectory(directory);
+        }
+        contexts.set(candidate, {
+            nodes,
+            previous: new Map([...nodes].map(([prior, next]) => [next, prior])),
+            files: new Map(),
+            directories: new Map(),
+            invalidated: new Set(),
+            events: [],
+            apply: []
+        });
+        return candidate;
+    });
+    const staged = commitProvider === undefined ? undefined : makeStagedState(state, copyState, commitProvider, (candidate, events) => {
+        const context = contexts.get(candidate);
+        if (context === undefined)
+            throw new Error("Missing staged engine state");
+        state = candidate;
+        for (const [previous, next] of context.nodes) {
+            const cell = cells.get(previous);
+            if (cell !== undefined) {
+                cell.node = next;
+                cells.set(next, cell);
+            }
+        }
+        for (const apply of context.apply)
+            apply();
+        for (const reference of context.invalidated) {
+            reference.active = false;
+            reference.cell = undefined;
+        }
+        for (const event of events)
+            event();
+    });
+    if (staged !== undefined)
+        commitProvider?.onReady?.(staged.shutdown);
+    // Permit waits stay interruptible. Changes and their publication run under one permit.
+    const coordinated = (operation, effect, onStorageFailure) => admit(operation, staged === undefined
+        ? gate.withPermit(Effect.uninterruptible(effect))
+        : staged.mutate(operation, (candidate, emit) => Effect.gen(function* () {
+            const previous = state;
+            const context = contexts.get(candidate);
+            if (context === undefined)
+                return yield* Effect.die("Missing staged engine state");
+            state = candidate;
+            activeStage = context;
+            const result = yield* Effect.exit(effect);
+            state = previous;
+            activeStage = undefined;
+            if (Exit.isFailure(result))
+                return yield* Effect.failCause(result.cause);
+            for (const event of context.events)
+                emit(event);
+            return result.value;
+        }), onStorageFailure));
+    // Pure observations share the permit without making a candidate or calling the provider.
+    const coordinatedRead = (operation, effect) => admit(operation, staged === undefined ? gate.withPermit(effect) : staged.read(operation, () => effect));
+    const coordinatedCleanup = (effect) => staged === undefined
+        ? gate.withPermit(Effect.uninterruptible(effect))
+        : staged.coordinate(Effect.uninterruptible(effect));
+    const watchCoordinate = (effect) => staged === undefined ? gate.withPermit(effect) : staged.coordinate(effect);
+    const watchHub = yield* WatchHub.make(watchCoordinate, settings.maxWatchEvents ?? 256, () => RescanChange.make({ path: ownedPath(new Uint8Array([47])) }), staged?.checkAvailable("watch"));
+    const queuePublish = (publish) => {
+        if (activeStage === undefined)
+            publish();
+        else
+            activeStage.events.push(publish);
+    };
     const directoryHex = (directory) => {
         const names = [];
         let current = directory;
@@ -378,10 +863,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
         return SLASH_HEX + names.reverse().join(SLASH_HEX);
     };
     const publishEntry = (_tag, parent, name) => {
-        watchHub.publishUnsafe(() => {
+        queuePublish(() => watchHub.publishUnsafe(() => {
             const prefix = directoryHex(parent);
             return { _tag, path: ownedPath(nameBytes(prefix + (prefix === SLASH_HEX ? "" : SLASH_HEX) + name)) };
-        });
+        }));
     };
     const publishNode = (target) => {
         // Directories are never hard linked, so one name reaches them and the parent chain resolves it.
@@ -391,12 +876,12 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             // The file scan below stops on the same signal, and `lookup` already reads it as NotFound.
             if (target.metadata.nlink === 0)
                 return;
-            watchHub.publishUnsafe(() => UpdateChange.make({ path: ownedPath(nameBytes(directoryHex(target))) }));
+            queuePublish(() => watchHub.publishUnsafe(() => UpdateChange.make({ path: ownedPath(nameBytes(directoryHex(target))) })));
             return;
         }
-        watchHub.publishManyUnsafe(() => {
+        queuePublish(() => watchHub.publishManyUnsafe(() => {
             const changes = [];
-            const pending = [[root, SLASH_HEX]];
+            const pending = [[state.root, SLASH_HEX]];
             // nlink counts the names bound to this node, so the scan stops once it has found them all.
             while (pending.length > 0 && changes.length < target.metadata.nlink) {
                 const next = pending.pop();
@@ -413,11 +898,11 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 }
             }
             return changes;
-        });
+        }));
     };
     const captureSnapshot = Effect.fnUntraced(function* () {
-        const ids = new Map([[root, "0"]]);
-        const pending = [root];
+        const ids = new Map([[state.root, "0"]]);
+        const pending = [state.root];
         const records = [];
         for (let index = 0; index < pending.length; index++) {
             if (index % WALK_YIELD_INTERVAL === 0)
@@ -453,7 +938,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
     });
     const observeChanges = Effect.fnUntraced(function* () {
         const observation = [];
-        const paths = [[root, new Uint8Array([SLASH_BYTE])]];
+        const paths = [[state.root, new Uint8Array([SLASH_BYTE])]];
         for (let index = 0; index < paths.length; index++) {
             if (index % WALK_YIELD_INTERVAL === 0)
                 yield* Effect.yieldNow;
@@ -496,7 +981,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
         if (node.objectReference !== undefined)
             return node.objectReference;
         const reference = Object.freeze({ [ObjectReferenceId]: true });
-        objectReferences.set(reference, { volume: volumeIdentity, node });
+        objectReferences.set(reference, { volume: volumeIdentity, cell: cellFor(node), active: true });
         node.objectReference = reference;
         return reference;
     };
@@ -505,11 +990,17 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
         if (reference === undefined)
             return;
         const state = objectReferences.get(reference);
-        if (state !== undefined)
-            state.node = undefined;
+        if (state !== undefined) {
+            if (activeStage === undefined) {
+                state.active = false;
+                state.cell = undefined;
+            }
+            else
+                activeStage.invalidated.add(state);
+        }
         node.objectReference = undefined;
     };
-    const release = (reference) => coordinated(Effect.sync(() => {
+    const release = (reference) => coordinatedCleanup(Effect.sync(() => {
         reference.directory = undefined;
         reference.closed = true;
     }));
@@ -530,13 +1021,14 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
     };
     const reclaim = (file) => {
         if (file.metadata.nlink === 0 && file.openCount === 0) {
-            usedBytes -= BigInt(file.data.bytes.length);
+            state.usedBytes -= BigInt(file.data.bytes.length);
             file.data = Content.empty();
+            state.retainedFiles.delete(file.metadata.ino);
             invalidateReference(file);
         }
     };
     // Whether the volume's entry quota leaves room for one more name.
-    const atEntryLimit = () => settings.maxEntries !== undefined && entries >= settings.maxEntries;
+    const atEntryLimit = () => settings.maxEntries !== undefined && state.entries >= settings.maxEntries;
     // A new subdirectory's ".." entry is a second link to the parent; other node kinds add none.
     const attach = (parent, name, node, now) => {
         parent.entries.set(name, node);
@@ -558,10 +1050,13 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
         else {
             node.metadata = { ...node.metadata, nlink: node.metadata.nlink - 1, ctimeNs: now };
             advanceRevision(node);
-            if (node.kind === "file")
+            if (node.kind === "file") {
+                if (node.metadata.nlink === 0 && node.openCount > 0)
+                    state.retainedFiles.set(node.metadata.ino, node);
                 reclaim(node);
+            }
             else if (node.metadata.nlink === 0) {
-                usedBytes -= BigInt(node.target.length);
+                state.usedBytes -= BigInt(node.target.length);
                 invalidateReference(node);
             }
         }
@@ -574,9 +1069,19 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
         }
         ref.closed = true;
     };
+    const finalizeFile = (ref) => Effect.suspend(() => ref.closed
+        ? Effect.void
+        : ref.file === undefined
+            ? Effect.sync(() => {
+                ref.closed = true;
+            })
+            : coordinated("close", Effect.sync(() => releaseFile(ref)), () => releaseFile(ref)).pipe(Effect.catch(() => coordinatedCleanup(Effect.sync(() => {
+                if (!ref.closed)
+                    releaseFile(ref);
+            })))));
     // Replacing a payload clears setuid and setgid, and charges the volume for the size delta.
-    const replaceContent = (file, data, now) => {
-        usedBytes += BigInt(data.length - file.data.bytes.length);
+    const replaceContent = (file, data, now, publish = true) => {
+        state.usedBytes += BigInt(data.length - file.data.bytes.length);
         file.data = Content.make(data);
         file.metadata = {
             ...file.metadata,
@@ -586,9 +1091,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             ctimeNs: now
         };
         advanceRevision(file);
-        publishNode(file);
+        if (publish)
+            publishNode(file);
     };
-    const resize = Effect.fnUntraced(function* (file, length, operation) {
+    const resize = Effect.fnUntraced(function* (file, length, operation, publish = true) {
         if (!Predicate.isBigInt(length) || length < 0n) {
             return yield* new FsError({ code: "InvalidArgument", operation: operation });
         }
@@ -596,19 +1102,19 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             return yield* new FsError({ code: "FileTooLarge", operation: operation });
         const size = Number(length);
         if (settings.maxBytes !== undefined &&
-            BigInt(size - file.data.bytes.length) > ByteSize.toBigInt(settings.maxBytes) - usedBytes) {
+            BigInt(size - file.data.bytes.length) > ByteSize.toBigInt(settings.maxBytes) - state.usedBytes) {
             return yield* new FsError({ code: "NoSpace", operation: operation });
         }
         const data = new Uint8Array(size);
         data.set(file.data.bytes.subarray(0, size));
-        replaceContent(file, data, yield* timestamp(operation));
+        replaceContent(file, data, yield* timestamp(operation), publish);
     });
     const fileHandle = (ref) => {
         const get = (operation, access) => ref.file === undefined || (access === "read" && ref.access === "write") ||
             (access === "write" && ref.access === "read")
             ? Effect.fail(new FsError({ code: "InvalidHandle", operation: operation }))
             : Effect.succeed(ref.file);
-        const read = Effect.fnUntraced(function* (maximum, position) {
+        const read = (maximum, position) => coordinated(position === undefined ? "read" : "pread", Effect.gen(function* () {
             const file = yield* get(position === undefined ? "read" : "pread", "read");
             if (!isNatural(maximum))
                 return yield* new FsError({ code: "InvalidArgument", operation: "read" });
@@ -624,12 +1130,12 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             if (position === undefined)
                 ref.offset += BigInt(data.length);
             return data;
-        }, coordinated);
+        }));
         const write = Effect.fnUntraced(function* (input, position) {
             if (!isAttachedBytes(input))
                 return yield* new FsError({ code: "InvalidArgument", operation: "write" });
             const bytes = new Uint8Array(input);
-            return yield* coordinated(Effect.gen(function* () {
+            return yield* coordinated(position === undefined ? "write" : "pwrite", Effect.gen(function* () {
                 const file = yield* get(position === undefined ? "write" : "pwrite", "write");
                 const offset = position ?? (ref.append ? file.metadata.size : ref.offset);
                 if (!Predicate.isBigInt(offset) || offset < 0n || offset > MAX_FILE_OFFSET) {
@@ -643,7 +1149,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 const start = Number(offset);
                 const free = settings.maxBytes === undefined
                     ? BigInt(maxFileBytes)
-                    : ByteSize.toBigInt(settings.maxBytes) - usedBytes;
+                    : ByteSize.toBigInt(settings.maxBytes) - state.usedBytes;
                 const maximumEnd = BigInt(file.data.bytes.length) + free;
                 const end = Number(BigInt(maxFileBytes) < maximumEnd ? BigInt(maxFileBytes) : maximumEnd);
                 const count = Math.min(bytes.length, Math.max(0, end - start));
@@ -677,12 +1183,16 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 return yield* write(bytes, offset);
             }),
             seek: Effect.fn("FileHandle.seek")(function* (offset, mode) {
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinatedRead("seek", Effect.uninterruptible(Effect.gen(function* () {
                     const file = yield* get("seek");
                     if (!Predicate.isBigInt(offset) || !isSeekMode(mode)) {
                         return yield* new FsError({ code: "InvalidArgument", operation: "seek" });
                     }
-                    let next = mode === "current" ? ref.offset + offset : mode === "end" ? file.metadata.size + offset : offset;
+                    let next = mode === "current"
+                        ? ref.offset + offset
+                        : mode === "end"
+                            ? file.metadata.size + offset
+                            : offset;
                     if (next < 0n || next > MAX_FILE_OFFSET) {
                         return yield* new FsError({ code: "InvalidArgument", operation: "seek" });
                     }
@@ -694,21 +1204,24 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     }
                     ref.offset = next;
                     return next;
-                }));
+                })));
             }),
             truncate: Effect.fn("FileHandle.truncate")(function* (length) {
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinated("truncate", Effect.gen(function* () {
                     yield* resize(yield* get("truncate", "write"), length, "truncate");
                 }));
             }),
-            stat: coordinated(Effect.gen(function* () {
+            stat: coordinatedRead("stat", Effect.gen(function* () {
                 return { ...(yield* get("stat")).metadata };
             })).pipe(Effect.withSpan("FileHandle.stat")),
-            sync: coordinated(Effect.suspend(() => Effect.asVoid(get("sync")))).pipe(Effect.withSpan("FileHandle.sync")),
-            close: coordinated(Effect.gen(function* () {
+            sync: coordinatedRead("sync", Effect.suspend(() => Effect.asVoid(get("sync")))).pipe(Effect.withSpan("FileHandle.sync")),
+            close: coordinated("close", Effect.gen(function* () {
                 yield* get("close");
                 releaseFile(ref);
-            })).pipe(Effect.withSpan("FileHandle.close"))
+            }), () => releaseFile(ref)).pipe(Effect.catch((error) => coordinatedCleanup(Effect.sync(() => {
+                if (!ref.closed)
+                    releaseFile(ref);
+            })).pipe(Effect.andThen(Effect.fail(error)))), Effect.withSpan("FileHandle.close"))
         });
         files.set(handle, ref);
         return handle;
@@ -725,17 +1238,44 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             if (state.volume !== volumeIdentity) {
                 return yield* new FsError({ code: "ForeignReference", operation: operation });
             }
-            if (state.node === undefined)
+            if (!state.active || activeStage?.invalidated.has(state)) {
                 return yield* new FsError({ code: "StaleReference", operation: operation });
-            return state.node;
+            }
+            const node = state.cell?.node;
+            if (node === undefined)
+                return yield* new FsError({ code: "StaleReference", operation });
+            return node;
+        });
+        const referencedName = Effect.fnUntraced(function* (input, operation) {
+            if (!isAttachedBytes(input) || input.length === 0 || input.length > MAX_NAME_BYTES || input.includes(0) ||
+                input.includes(SLASH_BYTE))
+                return yield* new FsError({ code: "InvalidArgument", operation });
+            const name = Encoding.encodeHex(new Uint8Array(input));
+            if (isDotComponent(name))
+                return yield* new FsError({ code: "InvalidArgument", operation });
+            return name;
+        });
+        const referencedDirectory = Effect.fnUntraced(function* (target, operation) {
+            const node = yield* referencedNode(target, operation);
+            if (node.kind !== "directory")
+                return yield* new FsError({ code: "NotDirectory", operation });
+            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 lookup = Effect.fnUntraced(function* (path, base, operation, options = {}) {
+        const lookup = Effect.fnUntraced(function* (path, base, operation, options = {}, referencedBase) {
             const { followFinalSymlink = true, allowMissing = false, parentOnly = false } = options;
             if (reference.directory === undefined) {
                 return yield* new FsError({ code: "ClosedCaller", operation: operation, path: path.input });
             }
-            let current = path.absolute ? root : reference.directory;
-            if (!path.absolute && base !== undefined) {
+            let current = path.absolute ? state.root : reference.directory;
+            if (!path.absolute && referencedBase !== undefined) {
+                current = referencedBase;
+                yield* authorize(current, identity, EXECUTE, operation);
+            }
+            else if (!path.absolute && base !== undefined) {
                 const target = handles.get(base);
                 if (target === undefined) {
                     return yield* new FsError({ code: "InvalidHandle", operation: operation, path: path.input });
@@ -804,7 +1344,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     }
                     work = expanded.success;
                     if (work.absolute)
-                        current = root;
+                        current = state.root;
                     index = -1;
                 }
                 else
@@ -836,11 +1376,11 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
         const acquireDirectory = Effect.fnUntraced(function* (input, options, operation) {
             const prepared = preparePath(input, operation, settings.maxPathBytes);
             const base = options?.relativeTo;
-            const acquired = { volume: volumeIdentity, directory: undefined, closed: false };
+            const acquired = makeDirectoryReference();
             // Register before retaining a directory. Closed scopes can run this immediately,
             // so registration must not happen while holding the volume permit.
             yield* Effect.addFinalizer(() => release(acquired));
-            return yield* coordinated(Effect.gen(function* () {
+            return yield* coordinatedRead(operation, Effect.uninterruptible(Effect.gen(function* () {
                 if (acquired.closed)
                     return yield* Effect.interrupt;
                 const path = yield* Effect.fromResult(prepared);
@@ -848,12 +1388,12 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 yield* authorize(directory, identity, EXECUTE, operation, input);
                 acquired.directory = directory;
                 return acquired;
-            }));
+            })));
         });
         const list = Effect.fnUntraced(function* (input, options) {
             const prepared = preparePath(input, "readDirectory", settings.maxPathBytes);
             const base = options?.relativeTo;
-            return yield* coordinated(Effect.gen(function* () {
+            return yield* coordinated("readDirectory", Effect.gen(function* () {
                 const directory = yield* locate(yield* Effect.fromResult(prepared), base, "readDirectory");
                 yield* authorize(directory, identity, READ, "readDirectory", input);
                 const result = [...directory.entries.keys()].map(nameBytes);
@@ -864,7 +1404,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
         const readTarget = Effect.fnUntraced(function* (input, options) {
             const prepared = preparePath(input, "readLink", settings.maxPathBytes);
             const base = options?.relativeTo;
-            return yield* coordinated(Effect.gen(function* () {
+            return yield* coordinatedRead("readLink", Effect.gen(function* () {
                 const node = yield* resolveNode(yield* Effect.fromResult(prepared), base, "readLink", {
                     followFinalSymlink: false
                 });
@@ -877,7 +1417,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
         const canonical = Effect.fnUntraced(function* (input, options) {
             const prepared = preparePath(input, "realPath", settings.maxPathBytes);
             const base = options?.relativeTo;
-            return yield* coordinated(Effect.gen(function* () {
+            return yield* coordinatedRead("realPath", Effect.gen(function* () {
                 const result = yield* lookup(yield* Effect.fromResult(prepared), base, "realPath");
                 const components = [];
                 if (result.node?.kind !== "directory" && result.name !== undefined)
@@ -886,8 +1426,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 while (directory !== undefined && directory.parent !== undefined) {
                     const parent = directory.parent;
                     const entry = [...parent.entries].find(([, child]) => child === directory);
-                    if (entry === undefined)
+                    if (entry === undefined) {
                         return yield* new FsError({ code: "NotFound", operation: "realPath", path: input });
+                    }
                     components.push(entry[0]);
                     directory = parent;
                 }
@@ -928,7 +1469,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             if (!isMode(mode))
                 return yield* new FsError({ code: "InvalidArgument", operation: "chmod" });
             const chosen = options === undefined ? undefined : { ...options };
-            return yield* coordinated(Effect.gen(function* () {
+            return yield* coordinated("chmod", Effect.gen(function* () {
                 const node = yield* metadataNode(target, chosen, "chmod");
                 const permitted = yield* permittedMode(node.metadata, mode, "chmod");
                 node.metadata = {
@@ -946,7 +1487,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 return yield* new FsError({ code: "InvalidArgument", operation: "chown" });
             const update = { ...decoded.success };
             const chosen = options === undefined ? undefined : { ...options };
-            return yield* coordinated(Effect.gen(function* () {
+            return yield* coordinated("chown", Effect.gen(function* () {
                 const node = yield* metadataNode(target, chosen, "chown");
                 if (!identity.privileged && (identity.uid !== node.metadata.uid ||
                     (update.uid !== undefined && update.uid !== node.metadata.uid) ||
@@ -973,7 +1514,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             const access = { ...decoded.success.access };
             const modification = { ...decoded.success.modification };
             const chosen = options === undefined ? undefined : { ...options };
-            return yield* coordinated(Effect.gen(function* () {
+            return yield* coordinated("utimes", Effect.gen(function* () {
                 const node = yield* metadataNode(target, chosen, "utimes");
                 if (access.kind === "omit" && modification.kind === "omit")
                     return;
@@ -1009,15 +1550,17 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
         });
         const authorizeRemoval = (parent, child, operation, input) => (parent.metadata.mode & STICKY_BIT) !== 0 && !identity.privileged &&
             identity.uid !== parent.metadata.uid && identity.uid !== child.metadata.uid
-            ? Effect.fail(new FsError({ code: "AccessDenied", operation: operation, path: input }))
+            ? Effect.fail(input === undefined
+                ? new FsError({ code: "AccessDenied", operation })
+                : new FsError({ code: "AccessDenied", operation, path: input }))
             : Effect.void;
         return Object.freeze({
             [CallerId]: true,
-            rootReference: coordinated(Effect.gen(function* () {
+            rootReference: coordinatedRead("rootReference", Effect.gen(function* () {
                 if (reference.directory === undefined) {
                     return yield* new FsError({ code: "ClosedCaller", operation: "rootReference" });
                 }
-                return referenceFor(root);
+                return referenceFor(state.root);
             })).pipe(Effect.withSpan("Caller.rootReference")),
             lookupReference: Effect.fn("Caller.lookupReference")(function* (directoryReference, name) {
                 if (!isAttachedBytes(name) || name.length === 0 || name.length > MAX_NAME_BYTES || name.includes(0) ||
@@ -1026,7 +1569,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 const key = Encoding.encodeHex(new Uint8Array(name));
                 if (isDotComponent(key))
                     return yield* new FsError({ code: "InvalidArgument", operation: "lookupReference" });
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinatedRead("lookupReference", Effect.gen(function* () {
                     const directory = yield* referencedNode(directoryReference, "lookupReference");
                     if (directory.kind !== "directory") {
                         return yield* new FsError({ code: "NotDirectory", operation: "lookupReference" });
@@ -1039,7 +1582,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 }));
             }),
             parentReference: Effect.fn("Caller.parentReference")(function* (directoryReference) {
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinatedRead("parentReference", Effect.gen(function* () {
                     const directory = yield* referencedNode(directoryReference, "parentReference");
                     if (directory.kind !== "directory") {
                         return yield* new FsError({ code: "NotDirectory", operation: "parentReference" });
@@ -1049,13 +1592,25 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 }));
             }),
             observeMetadata: Effect.fn("Caller.observeMetadata")(function* (objectReference) {
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinatedRead("observeMetadata", Effect.gen(function* () {
                     const node = yield* referencedNode(objectReference, "observeMetadata");
                     return Object.freeze({ value: Object.freeze({ ...node.metadata }), revision: node.revision });
                 }));
             }),
+            accessReference: Effect.fn("Caller.accessReference")(function* (objectReference, bits = 0) {
+                if (!Number.isInteger(bits) || bits < 0 || bits > (READ | WRITE | EXECUTE)) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "accessReference" });
+                }
+                return yield* coordinatedRead("accessReference", Effect.gen(function* () {
+                    const node = yield* referencedNode(objectReference, "accessReference");
+                    if (node.kind === "file" && (bits & EXECUTE) !== 0 && (node.metadata.mode & ANY_EXECUTE) === 0) {
+                        return yield* new FsError({ code: "AccessDenied", operation: "accessReference" });
+                    }
+                    yield* authorize(node, identity, bits, "accessReference");
+                }));
+            }),
             observeDirectory: Effect.fn("Caller.observeDirectory")(function* (directoryReference) {
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinatedRead("observeDirectory", Effect.gen(function* () {
                     const directory = yield* referencedNode(directoryReference, "observeDirectory");
                     if (directory.kind !== "directory") {
                         return yield* new FsError({ code: "NotDirectory", operation: "observeDirectory" });
@@ -1066,7 +1621,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 }));
             }),
             readLinkReference: Effect.fn("Caller.readLinkReference")(function* (objectReference) {
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinatedRead("readLinkReference", Effect.gen(function* () {
                     const node = yield* referencedNode(objectReference, "readLinkReference");
                     if (node.kind !== "symlink") {
                         return yield* new FsError({ code: "InvalidArgument", operation: "readLinkReference" });
@@ -1074,17 +1629,394 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     return new Uint8Array(node.target);
                 }));
             }),
-            openReference: Effect.fn("Caller.openReference")(function* (objectReference) {
-                const acquired = {
-                    volume: volumeIdentity,
-                    file: undefined,
-                    closed: false,
-                    offset: 0n,
-                    access: "read",
-                    append: false
-                };
-                yield* Effect.addFinalizer(() => coordinated(Effect.sync(() => releaseFile(acquired))));
-                return yield* coordinated(Effect.gen(function* () {
+            mkdirReference: Effect.fn("Caller.mkdirReference")(function* (directoryReference, input, raw = {}) {
+                const name = yield* referencedName(input, "mkdirReference");
+                const decoded = decodeMkdirReferenceSettings(raw);
+                if (Result.isFailure(decoded)) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "mkdirReference" });
+                }
+                const chosen = { ...decoded.success };
+                if (chosen.exactMode && chosen.mode === undefined) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "mkdirReference" });
+                }
+                const mode = chosen.mode ?? 0o777;
+                return yield* coordinated("mkdirReference", Effect.gen(function* () {
+                    const parent = yield* referencedDirectory(directoryReference, "mkdirReference");
+                    yield* authorize(parent, identity, WRITE | EXECUTE, "mkdirReference");
+                    if (parent.entries.has(name)) {
+                        return yield* new FsError({ code: "AlreadyExists", operation: "mkdirReference" });
+                    }
+                    if (atEntryLimit())
+                        return yield* new FsError({ code: "NoSpace", operation: "mkdirReference" });
+                    const before = parent.revision;
+                    const now = yield* timestamp("mkdirReference");
+                    const initial = creationTimes(chosen.times, now);
+                    const creationMode = chosen.exactMode
+                        ? yield* permittedMode({ kind: "directory", uid: identity.uid, gid: parent.metadata.gid }, mode, "mkdirReference")
+                        : (mode & 0o777 & ~umask) | (mode & STICKY_BIT);
+                    const child = {
+                        kind: "directory",
+                        lineage: undefined,
+                        parent,
+                        entries: new Map(),
+                        metadata: {
+                            ...directoryMetadata(state.nextInode, identity.uid, parent.metadata.gid, creationMode, now),
+                            ...initial
+                        },
+                        revision: nextRevision(),
+                        objectReference: undefined
+                    };
+                    attach(parent, name, child, now);
+                    state.nextInode += 1n;
+                    state.entries += 1;
+                    publishEntry("Create", parent, name);
+                    return { reference: referenceFor(child), directory: { before, after: parent.revision } };
+                }));
+            }),
+            symlinkReference: Effect.fn("Caller.symlinkReference")(function* (target, directoryReference, input, raw = {}) {
+                const name = yield* referencedName(input, "symlinkReference");
+                const decoded = decodeSymlinkReferenceSettings(raw);
+                if (Result.isFailure(decoded)) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "symlinkReference" });
+                }
+                const rawTarget = inputBytes(target);
+                if (Result.isFailure(rawTarget)) {
+                    return yield* new FsError({ code: rawTarget.failure, operation: "symlinkReference" });
+                }
+                if (rawTarget.success.includes(0)) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "symlinkReference" });
+                }
+                const targetBytes = new Uint8Array(rawTarget.success);
+                const chosen = { ...decoded.success };
+                return yield* coordinated("symlinkReference", Effect.gen(function* () {
+                    const parent = yield* referencedDirectory(directoryReference, "symlinkReference");
+                    yield* authorize(parent, identity, WRITE | EXECUTE, "symlinkReference");
+                    if (parent.entries.has(name)) {
+                        return yield* new FsError({ code: "AlreadyExists", operation: "symlinkReference" });
+                    }
+                    if (atEntryLimit() ||
+                        (settings.maxBytes !== undefined &&
+                            BigInt(targetBytes.length) > ByteSize.toBigInt(settings.maxBytes) - state.usedBytes))
+                        return yield* new FsError({ code: "NoSpace", operation: "symlinkReference" });
+                    const before = parent.revision;
+                    const now = yield* timestamp("symlinkReference");
+                    const initial = creationTimes(chosen.times, now);
+                    const node = {
+                        kind: "symlink",
+                        lineage: undefined,
+                        target: targetBytes,
+                        metadata: {
+                            ...directoryMetadata(state.nextInode, identity.uid, parent.metadata.gid, 0o777, now),
+                            ...initial,
+                            kind: "symlink",
+                            nlink: 1,
+                            size: BigInt(targetBytes.length)
+                        },
+                        revision: nextRevision(),
+                        objectReference: undefined
+                    };
+                    attach(parent, name, node, now);
+                    state.nextInode += 1n;
+                    state.entries += 1;
+                    state.usedBytes += BigInt(targetBytes.length);
+                    publishEntry("Create", parent, name);
+                    return { reference: referenceFor(node), directory: { before, after: parent.revision } };
+                }));
+            }),
+            linkReference: Effect.fn("Caller.linkReference")(function* (sourceReference, directoryReference, input) {
+                const name = yield* referencedName(input, "linkReference");
+                return yield* coordinated("linkReference", Effect.gen(function* () {
+                    const node = yield* referencedNode(sourceReference, "linkReference");
+                    if (node.kind === "directory") {
+                        return yield* new FsError({ code: "IsDirectory", operation: "linkReference" });
+                    }
+                    if (node.metadata.nlink === 0) {
+                        return yield* new FsError({ code: "StaleReference", operation: "linkReference" });
+                    }
+                    const parent = yield* referencedDirectory(directoryReference, "linkReference");
+                    yield* authorize(parent, identity, WRITE | EXECUTE, "linkReference");
+                    if (parent.entries.has(name)) {
+                        return yield* new FsError({ code: "AlreadyExists", operation: "linkReference" });
+                    }
+                    if (atEntryLimit())
+                        return yield* new FsError({ code: "NoSpace", operation: "linkReference" });
+                    const before = parent.revision;
+                    const now = yield* timestamp("linkReference");
+                    attach(parent, name, node, now);
+                    node.metadata = { ...node.metadata, nlink: node.metadata.nlink + 1, ctimeNs: now };
+                    advanceRevision(node);
+                    state.entries += 1;
+                    publishEntry("Create", parent, name);
+                    return { reference: referenceFor(node), directory: { before, after: parent.revision } };
+                }));
+            }),
+            unlinkReference: Effect.fn("Caller.unlinkReference")(function* (directoryReference, input) {
+                const name = yield* referencedName(input, "unlinkReference");
+                return yield* coordinated("unlinkReference", Effect.gen(function* () {
+                    const parent = yield* referencedDirectory(directoryReference, "unlinkReference");
+                    yield* authorize(parent, identity, WRITE | EXECUTE, "unlinkReference");
+                    const child = parent.entries.get(name);
+                    if (child === undefined)
+                        return yield* new FsError({ code: "NotFound", operation: "unlinkReference" });
+                    if (child.kind === "directory") {
+                        return yield* new FsError({ code: "IsDirectory", operation: "unlinkReference" });
+                    }
+                    yield* authorizeRemoval(parent, child, "unlinkReference");
+                    const before = parent.revision;
+                    const now = yield* timestamp("unlinkReference");
+                    parent.entries.delete(name);
+                    parent.metadata = { ...parent.metadata, mtimeNs: now, ctimeNs: now };
+                    advanceRevision(parent);
+                    detach(child, now);
+                    state.entries -= 1;
+                    publishEntry("Remove", parent, name);
+                    return { before, after: parent.revision };
+                }));
+            }),
+            rmdirReference: Effect.fn("Caller.rmdirReference")(function* (directoryReference, input) {
+                const name = yield* referencedName(input, "rmdirReference");
+                return yield* coordinated("rmdirReference", Effect.gen(function* () {
+                    const parent = yield* referencedDirectory(directoryReference, "rmdirReference");
+                    yield* authorize(parent, identity, WRITE | EXECUTE, "rmdirReference");
+                    const child = parent.entries.get(name);
+                    if (child === undefined)
+                        return yield* new FsError({ code: "NotFound", operation: "rmdirReference" });
+                    yield* authorizeRemoval(parent, child, "rmdirReference");
+                    if (child.kind !== "directory") {
+                        return yield* new FsError({ code: "NotDirectory", operation: "rmdirReference" });
+                    }
+                    if (child.entries.size > 0) {
+                        return yield* new FsError({ code: "NotEmpty", operation: "rmdirReference" });
+                    }
+                    const before = parent.revision;
+                    const now = yield* timestamp("rmdirReference");
+                    parent.entries.delete(name);
+                    parent.metadata = { ...parent.metadata, nlink: parent.metadata.nlink - 1, mtimeNs: now, ctimeNs: now };
+                    child.parent = undefined;
+                    child.metadata = { ...child.metadata, nlink: 0, ctimeNs: now };
+                    advanceRevision(parent);
+                    advanceRevision(child);
+                    invalidateReference(child);
+                    state.entries -= 1;
+                    publishEntry("Remove", parent, name);
+                    return { before, after: parent.revision };
+                }));
+            }),
+            removeReference: Effect.fn("Caller.removeReference")(function* (directoryReference, input) {
+                const name = yield* referencedName(input, "removeReference");
+                return yield* coordinated("removeReference", Effect.gen(function* () {
+                    const parent = yield* referencedDirectory(directoryReference, "removeReference");
+                    yield* authorize(parent, identity, WRITE | EXECUTE, "removeReference");
+                    const child = parent.entries.get(name);
+                    if (child === undefined)
+                        return yield* new FsError({ code: "NotFound", operation: "removeReference" });
+                    yield* authorizeRemoval(parent, child, "removeReference");
+                    if (child.kind === "directory" && child.entries.size > 0) {
+                        return yield* new FsError({ code: "NotEmpty", operation: "removeReference" });
+                    }
+                    const before = parent.revision;
+                    const now = yield* timestamp("removeReference");
+                    parent.entries.delete(name);
+                    parent.metadata = {
+                        ...parent.metadata,
+                        nlink: parent.metadata.nlink - (child.kind === "directory" ? 1 : 0),
+                        mtimeNs: now,
+                        ctimeNs: now
+                    };
+                    if (child.kind === "directory") {
+                        child.parent = undefined;
+                        child.metadata = { ...child.metadata, nlink: 0, ctimeNs: now };
+                        advanceRevision(parent);
+                        advanceRevision(child);
+                        invalidateReference(child);
+                    }
+                    else {
+                        advanceRevision(parent);
+                        detach(child, now);
+                    }
+                    state.entries -= 1;
+                    publishEntry("Remove", parent, name);
+                    return { before, after: parent.revision };
+                }));
+            }),
+            renameReference: Effect.fn("Caller.renameReference")(function* (sourceDirectoryReference, sourceInput, destinationDirectoryReference, destinationInput) {
+                const sourceName = yield* referencedName(sourceInput, "renameReference");
+                const destinationName = yield* referencedName(destinationInput, "renameReference");
+                return yield* coordinated("renameReference", Effect.gen(function* () {
+                    const sourceDirectory = yield* referencedDirectory(sourceDirectoryReference, "renameReference");
+                    const destinationDirectory = yield* referencedDirectory(destinationDirectoryReference, "renameReference");
+                    yield* authorize(sourceDirectory, identity, WRITE | EXECUTE, "renameReference");
+                    yield* authorize(destinationDirectory, identity, WRITE | EXECUTE, "renameReference");
+                    const sourceBefore = sourceDirectory.revision;
+                    const destinationBefore = destinationDirectory.revision;
+                    const child = sourceDirectory.entries.get(sourceName);
+                    if (child === undefined) {
+                        return yield* new FsError({ code: "NotFound", operation: "renameReference" });
+                    }
+                    const replaced = destinationDirectory.entries.get(destinationName);
+                    if (child === replaced) {
+                        return sourceDirectory === destinationDirectory
+                            ? { _tag: "SameDirectory", directory: { before: sourceBefore, after: sourceBefore } }
+                            : {
+                                _tag: "DifferentDirectories",
+                                sourceDirectory: { before: sourceBefore, after: sourceBefore },
+                                destinationDirectory: { before: destinationBefore, after: destinationBefore }
+                            };
+                    }
+                    yield* authorizeRemoval(sourceDirectory, child, "renameReference");
+                    if (replaced !== undefined) {
+                        yield* authorizeRemoval(destinationDirectory, replaced, "renameReference");
+                        if (child.kind === "directory" && replaced.kind !== "directory") {
+                            return yield* new FsError({ code: "NotDirectory", operation: "renameReference" });
+                        }
+                        if (child.kind !== "directory" && replaced.kind === "directory") {
+                            return yield* new FsError({ code: "IsDirectory", operation: "renameReference" });
+                        }
+                        if (replaced.kind === "directory" && replaced.entries.size > 0) {
+                            return yield* new FsError({ code: "NotEmpty", operation: "renameReference" });
+                        }
+                    }
+                    for (let ancestor = destinationDirectory; ancestor !== undefined; ancestor = ancestor.parent) {
+                        if (ancestor === child) {
+                            return yield* new FsError({ code: "InvalidArgument", operation: "renameReference" });
+                        }
+                    }
+                    const now = yield* timestamp("renameReference");
+                    const oldEvent = () => ownedPath(nameBytes(directoryHex(sourceDirectory) + (sourceDirectory === state.root ? "" : SLASH_HEX) + sourceName));
+                    sourceDirectory.entries.delete(sourceName);
+                    destinationDirectory.entries.set(destinationName, child);
+                    if (child.kind === "directory")
+                        child.parent = destinationDirectory;
+                    sourceDirectory.metadata = {
+                        ...sourceDirectory.metadata,
+                        nlink: sourceDirectory.metadata.nlink - (child.kind === "directory" ? 1 : 0),
+                        mtimeNs: now,
+                        ctimeNs: now
+                    };
+                    destinationDirectory.metadata = {
+                        ...destinationDirectory.metadata,
+                        nlink: destinationDirectory.metadata.nlink +
+                            (child.kind === "directory" && replaced === undefined ? 1 : 0),
+                        mtimeNs: now,
+                        ctimeNs: now
+                    };
+                    child.metadata = { ...child.metadata, ctimeNs: now };
+                    advanceRevision(sourceDirectory);
+                    if (destinationDirectory !== sourceDirectory)
+                        advanceRevision(destinationDirectory);
+                    advanceRevision(child);
+                    if (replaced !== undefined) {
+                        detach(replaced, now);
+                        state.entries -= 1;
+                    }
+                    queuePublish(() => watchHub.publishUnsafe(() => ({ _tag: "Remove", path: oldEvent() })));
+                    publishEntry("Create", destinationDirectory, destinationName);
+                    return sourceDirectory === destinationDirectory
+                        ? {
+                            _tag: "SameDirectory",
+                            directory: { before: sourceBefore, after: sourceDirectory.revision }
+                        }
+                        : {
+                            _tag: "DifferentDirectories",
+                            sourceDirectory: { before: sourceBefore, after: sourceDirectory.revision },
+                            destinationDirectory: { before: destinationBefore, after: destinationDirectory.revision }
+                        };
+                }));
+            }),
+            chmodReference: Effect.fn("Caller.chmodReference")(function* (objectReference, mode) {
+                if (!isMode(mode))
+                    return yield* new FsError({ code: "InvalidArgument", operation: "chmodReference" });
+                return yield* coordinated("chmodReference", Effect.gen(function* () {
+                    const node = yield* referencedNode(objectReference, "chmodReference");
+                    const permitted = yield* permittedMode(node.metadata, mode, "chmodReference");
+                    node.metadata = { ...node.metadata, mode: permitted, ctimeNs: (yield* timestamp("chmodReference")) };
+                    advanceRevision(node);
+                    publishNode(node);
+                }));
+            }),
+            chownReference: Effect.fn("Caller.chownReference")(function* (objectReference, owner) {
+                const decoded = decodeOwnerUpdate(owner);
+                if (Result.isFailure(decoded)) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "chownReference" });
+                }
+                const update = { ...decoded.success };
+                return yield* coordinated("chownReference", Effect.gen(function* () {
+                    const node = yield* referencedNode(objectReference, "chownReference");
+                    if (!identity.privileged && (identity.uid !== node.metadata.uid ||
+                        (update.uid !== undefined && update.uid !== node.metadata.uid) ||
+                        (update.gid !== undefined && update.gid !== identity.gid && !identity.groups.includes(update.gid))))
+                        return yield* new FsError({ code: "AccessDenied", operation: "chownReference" });
+                    if (update.uid === undefined && update.gid === undefined)
+                        return;
+                    node.metadata = {
+                        ...node.metadata,
+                        uid: update.uid ?? node.metadata.uid,
+                        gid: update.gid ?? node.metadata.gid,
+                        mode: node.kind === "file" ? node.metadata.mode & ~SET_ID_BITS : node.metadata.mode,
+                        ctimeNs: (yield* timestamp("chownReference"))
+                    };
+                    advanceRevision(node);
+                    publishNode(node);
+                }));
+            }),
+            utimesReference: Effect.fn("Caller.utimesReference")(function* (objectReference, times) {
+                const decoded = decodeTimes(times);
+                if (Result.isFailure(decoded)) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "utimesReference" });
+                }
+                const access = { ...decoded.success.access };
+                const modification = { ...decoded.success.modification };
+                return yield* coordinated("utimesReference", Effect.gen(function* () {
+                    const node = yield* referencedNode(objectReference, "utimesReference");
+                    if (access.kind === "omit" && modification.kind === "omit")
+                        return;
+                    if (!identity.privileged && identity.uid !== node.metadata.uid) {
+                        if (access.kind !== "now" || modification.kind !== "now") {
+                            return yield* new FsError({ code: "AccessDenied", operation: "utimesReference" });
+                        }
+                        yield* authorize(node, identity, WRITE, "utimesReference");
+                    }
+                    const now = yield* timestamp("utimesReference");
+                    node.metadata = {
+                        ...node.metadata,
+                        atimeNs: access.kind === "omit"
+                            ? node.metadata.atimeNs
+                            : access.kind === "now"
+                                ? now
+                                : access.nanoseconds,
+                        mtimeNs: modification.kind === "omit"
+                            ? node.metadata.mtimeNs
+                            : modification.kind === "now"
+                                ? now
+                                : modification.nanoseconds,
+                        ctimeNs: now
+                    };
+                    advanceRevision(node);
+                    publishNode(node);
+                }));
+            }),
+            truncateReference: Effect.fn("Caller.truncateReference")(function* (objectReference, length) {
+                return yield* coordinated("truncateReference", Effect.gen(function* () {
+                    const node = yield* referencedNode(objectReference, "truncateReference");
+                    if (node.kind !== "file") {
+                        return yield* new FsError({ code: "IsDirectory", operation: "truncateReference" });
+                    }
+                    yield* authorize(node, identity, WRITE, "truncateReference");
+                    yield* resize(node, length, "truncateReference");
+                }));
+            }),
+            openReference: Effect.fn("Caller.openReference")(function* (objectReference, raw = { access: "read" }) {
+                const decoded = decodeOpenReferenceSettings(raw);
+                if (Result.isFailure(decoded)) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "openReference" });
+                }
+                const chosen = { ...decoded.success };
+                if (chosen.access === "read" && (chosen.append || chosen.truncate)) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "openReference" });
+                }
+                const acquired = makeFileReference(chosen.access, chosen.append ?? false);
+                yield* Effect.addFinalizer(() => finalizeFile(acquired));
+                return yield* coordinated("openReference", Effect.gen(function* () {
                     if (acquired.closed)
                         return yield* Effect.interrupt;
                     const node = yield* referencedNode(objectReference, "openReference");
@@ -1093,16 +2025,170 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     if (node.metadata.nlink === 0) {
                         return yield* new FsError({ code: "StaleReference", operation: "openReference" });
                     }
-                    yield* authorize(node, identity, READ, "openReference", "/");
+                    yield* authorize(node, identity, chosen.access === "read" ? READ : chosen.access === "write" ? WRITE : READ | WRITE, "openReference");
+                    if (chosen.truncate)
+                        yield* resize(node, 0n, "openReference");
                     node.openCount += 1;
                     acquired.file = node;
                     return fileHandle(acquired);
                 }));
             }),
+            openChildReference: Effect.fn("Caller.openChildReference")(function* (directoryReference, input, raw, expected) {
+                const name = yield* referencedName(input, "openChildReference");
+                const decoded = decodeOpenChildReferenceSettings(raw);
+                if (Result.isFailure(decoded)) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "openChildReference" });
+                }
+                const chosen = { ...decoded.success };
+                if (chosen.access === "read" && (chosen.append || chosen.truncate)) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "openChildReference" });
+                }
+                if ((chosen.mode !== undefined || chosen.times !== undefined || chosen.initialSize !== undefined ||
+                    chosen.exactMode !== undefined || chosen.owner !== undefined) &&
+                    (chosen.create === undefined || chosen.create === "never")) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "openChildReference" });
+                }
+                if (chosen.exactMode && chosen.mode === undefined) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "openChildReference" });
+                }
+                const relativePath = preparePath(ownedPath(nameBytes(name)), "openChildReference", undefined);
+                const acquired = makeFileReference(chosen.access, chosen.append ?? false);
+                yield* Effect.addFinalizer(() => finalizeFile(acquired));
+                return yield* coordinated("openChildReference", Effect.gen(function* () {
+                    if (acquired.closed)
+                        return yield* Effect.interrupt;
+                    const parent = yield* referencedDirectory(directoryReference, "openChildReference");
+                    yield* authorize(parent, identity, EXECUTE, "openChildReference");
+                    const direct = parent.entries.get(name);
+                    if (expected !== undefined) {
+                        let expectedNode;
+                        if (expected !== null) {
+                            const observed = yield* Effect.result(referencedNode(expected, "openChildReference"));
+                            if (Result.isFailure(observed)) {
+                                return yield* new FsError({ code: "VolumeBusy", operation: "openChildReference" });
+                            }
+                            expectedNode = observed.success;
+                        }
+                        if (direct !== expectedNode) {
+                            return yield* new FsError({ code: "VolumeBusy", operation: "openChildReference" });
+                        }
+                    }
+                    if (chosen.expectedChild === null) {
+                        if (direct !== undefined) {
+                            return yield* new FsError({ code: "StaleReference", operation: "openChildReference" });
+                        }
+                    }
+                    else if (chosen.expectedChild !== undefined) {
+                        const expected = chosen.expectedChild;
+                        const observed = yield* referencedNode(expected.reference, "openChildReference");
+                        if (direct !== observed || observed.revision !== expected.revision ||
+                            observed.metadata.atimeNs !== expected.atimeNs || observed.metadata.mtimeNs !== expected.mtimeNs) {
+                            return yield* new FsError({ code: "StaleReference", operation: "openChildReference" });
+                        }
+                    }
+                    if (direct !== undefined && chosen.create === "exclusive") {
+                        return yield* new FsError({ code: "AlreadyExists", operation: "openChildReference" });
+                    }
+                    let file = direct;
+                    let mutationParent = parent;
+                    let mutationName = name;
+                    if (file?.kind === "symlink" && chosen.followFinalSymlink !== false) {
+                        const resolved = yield* lookup(yield* Effect.fromResult(relativePath), undefined, "openChildReference", {
+                            followFinalSymlink: true,
+                            allowMissing: chosen.create === "ifMissing" || chosen.create === "exclusive"
+                        }, parent);
+                        file = resolved.node;
+                        if (file === undefined) {
+                            if (resolved.parent === undefined || resolved.name === undefined) {
+                                return yield* new FsError({ code: "IsDirectory", operation: "openChildReference" });
+                            }
+                            mutationParent = resolved.parent;
+                            mutationName = resolved.name;
+                        }
+                    }
+                    const before = mutationParent.revision;
+                    let created = false;
+                    if (file === undefined) {
+                        if (chosen.create === undefined || chosen.create === "never") {
+                            return yield* new FsError({ code: "NotFound", operation: "openChildReference" });
+                        }
+                        yield* authorize(mutationParent, identity, WRITE | EXECUTE, "openChildReference");
+                        if (atEntryLimit()) {
+                            return yield* new FsError({ code: "NoSpace", operation: "openChildReference" });
+                        }
+                        const size = chosen.initialSize ?? 0n;
+                        if (size < 0n) {
+                            return yield* new FsError({ code: "InvalidArgument", operation: "openChildReference" });
+                        }
+                        if (size > BigInt(maxFileBytes)) {
+                            return yield* new FsError({ code: "FileTooLarge", operation: "openChildReference" });
+                        }
+                        if (settings.maxBytes !== undefined && size > ByteSize.toBigInt(settings.maxBytes) - state.usedBytes) {
+                            return yield* new FsError({ code: "NoSpace", operation: "openChildReference" });
+                        }
+                        if (!identity.privileged &&
+                            ((chosen.owner?.uid !== undefined && chosen.owner.uid !== identity.uid) ||
+                                (chosen.owner?.gid !== undefined && chosen.owner.gid !== identity.gid &&
+                                    !identity.groups.includes(chosen.owner.gid)))) {
+                            return yield* new FsError({ code: "AccessDenied", operation: "openChildReference" });
+                        }
+                        const now = yield* timestamp("openChildReference");
+                        const initial = creationTimes(chosen.times, now);
+                        const creationMode = chosen.exactMode
+                            ? yield* permittedMode({
+                                kind: "file",
+                                uid: chosen.owner?.uid ?? identity.uid,
+                                gid: chosen.owner?.gid ?? mutationParent.metadata.gid
+                            }, chosen.mode, "openChildReference")
+                            : (chosen.mode ?? 0o666) & 0o777 & ~umask;
+                        const createdFile = {
+                            kind: "file",
+                            lineage: undefined,
+                            data: Content.make(new Uint8Array(Number(size))),
+                            openCount: 0,
+                            metadata: {
+                                ...directoryMetadata(state.nextInode, chosen.owner?.uid ?? identity.uid, chosen.owner?.gid ?? mutationParent.metadata.gid, creationMode, now),
+                                ...initial,
+                                kind: "file",
+                                size,
+                                nlink: 1
+                            },
+                            revision: nextRevision(),
+                            objectReference: undefined
+                        };
+                        file = createdFile;
+                        attach(mutationParent, mutationName, createdFile, now);
+                        state.entries += 1;
+                        state.usedBytes += size;
+                        state.nextInode += 1n;
+                        created = true;
+                        publishEntry("Create", mutationParent, mutationName);
+                    }
+                    else {
+                        if (file.kind === "symlink") {
+                            return yield* new FsError({ code: "SymlinkLoop", operation: "openChildReference" });
+                        }
+                        if (file.kind !== "file") {
+                            return yield* new FsError({ code: "IsDirectory", operation: "openChildReference" });
+                        }
+                        yield* authorize(file, identity, chosen.access === "read" ? READ : chosen.access === "write" ? WRITE : READ | WRITE, "openChildReference");
+                        if (chosen.truncate)
+                            yield* resize(file, 0n, "openChildReference");
+                    }
+                    file.openCount += 1;
+                    acquired.file = file;
+                    return {
+                        handle: fileHandle(acquired),
+                        reference: referenceFor(file),
+                        created,
+                        directory: { before, after: mutationParent.revision }
+                    };
+                }));
+            }),
             readFile: Effect.fn("Caller.readFile")(function* (input, options) {
                 const prepared = preparePath(input, "readFile", settings.maxPathBytes);
                 const base = options?.relativeTo;
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinated("readFile", Effect.gen(function* () {
                     const node = yield* resolveNode(yield* Effect.fromResult(prepared), base, "readFile");
                     if (node.kind !== "file") {
                         return yield* new FsError({ code: "IsDirectory", operation: "readFile", path: input });
@@ -1125,7 +2211,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     return yield* new FsError({ code: "InvalidArgument", operation: "writeFile", path: input });
                 }
                 const chosen = decoded.success;
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinated("writeFile", Effect.gen(function* () {
                     const path = yield* Effect.fromResult(prepared);
                     if (chosen.create === "exclusive") {
                         const exists = yield* Effect.result(lookup(path, base, "writeFile", { followFinalSymlink: false }));
@@ -1172,7 +2258,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     }
                     const reclaimed = replaced !== undefined && replaced.metadata.nlink === 1 ? replaced.target.length : 0;
                     if (settings.maxBytes !== undefined &&
-                        BigInt(size - previous) > ByteSize.toBigInt(settings.maxBytes) - usedBytes + BigInt(reclaimed)) {
+                        BigInt(size - previous) > ByteSize.toBigInt(settings.maxBytes) - state.usedBytes + BigInt(reclaimed)) {
                         return yield* new FsError({ code: "NoSpace", operation: "writeFile", path: input });
                     }
                     if (file !== undefined && !chosen.truncate && captured.length === 0 && chosen.finalMode === undefined) {
@@ -1194,7 +2280,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                             data: Content.empty(),
                             openCount: 0,
                             metadata: {
-                                ...directoryMetadata(nextInode++, identity.uid, parent.metadata.gid, (chosen.mode ?? 0o666) & 0o777 & ~umask, now),
+                                ...directoryMetadata(state.nextInode++, identity.uid, parent.metadata.gid, (chosen.mode ?? 0o666) & 0o777 & ~umask, now),
                                 kind: "file",
                                 nlink: 1
                             },
@@ -1210,13 +2296,13 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                         ctimeNs: now
                     };
                     advanceRevision(node);
-                    usedBytes += BigInt(size - previous);
+                    state.usedBytes += BigInt(size - previous);
                     if (file === undefined) {
                         if (replaced !== undefined)
                             detach(replaced, now);
                         attach(parent, name, node, now);
                         if (replaced === undefined)
-                            entries += 1;
+                            state.entries += 1;
                         publishEntry(replaced === undefined ? "Create" : "Update", parent, name);
                     }
                     else
@@ -1247,7 +2333,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 if (!Number.isInteger(bits) || bits < 0 || bits > (READ | WRITE | EXECUTE)) {
                     return yield* new FsError({ code: "InvalidArgument", operation: "access", path: input });
                 }
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinatedRead("access", Effect.gen(function* () {
                     const node = yield* resolveNode(yield* Effect.fromResult(prepared), base, "access");
                     if (node.kind === "file" && (bits & EXECUTE) !== 0 && (node.metadata.mode & ANY_EXECUTE) === 0) {
                         return yield* new FsError({ code: "AccessDenied", operation: "access", path: input });
@@ -1258,7 +2344,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             truncate: Effect.fn("Caller.truncate")(function* (input, length, options) {
                 const prepared = preparePath(input, "truncate", settings.maxPathBytes);
                 const base = options?.relativeTo;
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinated("truncate", Effect.gen(function* () {
                     const node = yield* resolveNode(yield* Effect.fromResult(prepared), base, "truncate");
                     if (node.kind !== "file") {
                         return yield* new FsError({ code: "IsDirectory", operation: "truncate", path: input });
@@ -1270,7 +2356,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             lstat: Effect.fn("Caller.lstat")(function* (input, options) {
                 const prepared = preparePath(input, "lstat", settings.maxPathBytes);
                 const base = options?.relativeTo;
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinatedRead("lstat", Effect.gen(function* () {
                     const node = yield* resolveNode(yield* Effect.fromResult(prepared), base, "lstat", {
                         followFinalSymlink: false
                     });
@@ -1283,7 +2369,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 const sourceBase = options?.sourceRelativeTo;
                 const destinationBase = options?.destinationRelativeTo;
                 const follow = options?.followSourceSymlink ?? false;
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinated("link", Effect.gen(function* () {
                     const node = yield* resolveNode(yield* Effect.fromResult(a), sourceBase, "link", {
                         followFinalSymlink: follow
                     });
@@ -1307,7 +2393,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     attach(parent, name, node, now);
                     node.metadata = { ...node.metadata, nlink: node.metadata.nlink + 1, ctimeNs: now };
                     advanceRevision(node);
-                    entries += 1;
+                    state.entries += 1;
                     publishEntry("Create", parent, name);
                 }));
             }),
@@ -1322,7 +2408,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 }
                 const targetBytes = new Uint8Array(rawTarget.success);
                 const base = options?.relativeTo;
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinated("symlink", Effect.gen(function* () {
                     const path = yield* Effect.fromResult(prepared);
                     const bytes = targetBytes;
                     const parent = yield* locate(path, base, "symlink", { parentOnly: true });
@@ -1336,7 +2422,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     }
                     if (atEntryLimit() ||
                         (settings.maxBytes !== undefined &&
-                            BigInt(bytes.length) > ByteSize.toBigInt(settings.maxBytes) - usedBytes))
+                            BigInt(bytes.length) > ByteSize.toBigInt(settings.maxBytes) - state.usedBytes))
                         return yield* new FsError({ code: "NoSpace", operation: "symlink", path: input });
                     const now = yield* timestamp("symlink");
                     const node = {
@@ -1344,7 +2430,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                         lineage: undefined,
                         target: new Uint8Array(bytes),
                         metadata: {
-                            ...directoryMetadata(nextInode, identity.uid, parent.metadata.gid, 0o777, now),
+                            ...directoryMetadata(state.nextInode, identity.uid, parent.metadata.gid, 0o777, now),
                             kind: "symlink",
                             nlink: 1,
                             size: BigInt(bytes.length)
@@ -1353,9 +2439,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                         objectReference: undefined
                     };
                     attach(parent, name, node, now);
-                    nextInode += 1n;
-                    entries += 1;
-                    usedBytes += BigInt(bytes.length);
+                    state.nextInode += 1n;
+                    state.entries += 1;
+                    state.usedBytes += BigInt(bytes.length);
                     publishEntry("Create", parent, name);
                 }));
             }),
@@ -1391,16 +2477,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 if (chosen.mode !== undefined && (chosen.create === undefined || chosen.create === "never")) {
                     return yield* new FsError({ code: "InvalidArgument", operation: "open", path: input });
                 }
-                const acquired = {
-                    volume: volumeIdentity,
-                    file: undefined,
-                    closed: false,
-                    offset: 0n,
-                    access: chosen.access,
-                    append: chosen.append ?? false
-                };
-                yield* Effect.addFinalizer(() => coordinated(Effect.sync(() => releaseFile(acquired))));
-                return yield* coordinated(Effect.gen(function* () {
+                const acquired = makeFileReference(chosen.access, chosen.append ?? false);
+                yield* Effect.addFinalizer(() => finalizeFile(acquired));
+                return yield* coordinated("open", Effect.gen(function* () {
                     if (acquired.closed)
                         return yield* Effect.interrupt;
                     const path = yield* Effect.fromResult(prepared);
@@ -1417,8 +2496,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                         allowMissing: chosen.create === "ifMissing" || chosen.create === "exclusive"
                     });
                     const parent = resolved.parent;
-                    if (parent === undefined)
+                    if (parent === undefined) {
                         return yield* new FsError({ code: "IsDirectory", operation: "open", path: input });
+                    }
                     const name = resolved.name;
                     if (isDotComponent(name)) {
                         return yield* new FsError({ code: "IsDirectory", operation: "open", path: input });
@@ -1443,7 +2523,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                             data: Content.empty(),
                             openCount: 0,
                             metadata: {
-                                ...directoryMetadata(nextInode, identity.uid, parent.metadata.gid, (chosen.mode ?? 0o666) & 0o777 & ~umask, now),
+                                ...directoryMetadata(state.nextInode, identity.uid, parent.metadata.gid, (chosen.mode ?? 0o666) & 0o777 & ~umask, now),
                                 kind: "file",
                                 nlink: 1
                             },
@@ -1451,8 +2531,8 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                             objectReference: undefined
                         };
                         attach(parent, name, file, now);
-                        entries += 1;
-                        nextInode += 1n;
+                        state.entries += 1;
+                        state.nextInode += 1n;
                         publishEntry("Create", parent, name);
                     }
                     else {
@@ -1477,7 +2557,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             unlink: Effect.fn("Caller.unlink")(function* (input, options) {
                 const prepared = preparePath(input, "unlink", settings.maxPathBytes);
                 const base = options?.relativeTo;
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinated("unlink", Effect.gen(function* () {
                     const path = yield* Effect.fromResult(prepared);
                     const parent = yield* locate(path, base, "unlink", { parentOnly: true });
                     yield* authorize(parent, identity, WRITE | EXECUTE, "unlink", input);
@@ -1500,7 +2580,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     parent.metadata = { ...parent.metadata, mtimeNs: now, ctimeNs: now };
                     advanceRevision(parent);
                     detach(child, now);
-                    entries -= 1;
+                    state.entries -= 1;
                     publishEntry("Remove", parent, name);
                 }));
             }),
@@ -1509,7 +2589,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 const newPrepared = preparePath(destination, "rename", settings.maxPathBytes);
                 const oldBase = options?.sourceRelativeTo;
                 const newBase = options?.destinationRelativeTo;
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinated("rename", Effect.gen(function* () {
                     const oldPath = yield* Effect.fromResult(oldPrepared);
                     const newPath = yield* Effect.fromResult(newPrepared);
                     const oldParent = yield* locate(oldPath, oldBase, "rename", { parentOnly: true });
@@ -1522,8 +2602,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                         return yield* new FsError({ code: "InvalidArgument", operation: "rename", path: source });
                     }
                     const child = oldParent.entries.get(oldName);
-                    if (child === undefined)
+                    if (child === undefined) {
                         return yield* new FsError({ code: "NotFound", operation: "rename", path: source });
+                    }
                     const replaced = newParent.entries.get(newName);
                     if (newPath.trailingSlash && replaced === undefined) {
                         return yield* new FsError({ code: "NotFound", operation: "rename", path: destination });
@@ -1556,7 +2637,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     }
                     const now = yield* timestamp("rename");
                     // All rejection checks precede namespace, ancestry, quota, and metadata publication.
-                    const oldEvent = () => ownedPath(nameBytes(directoryHex(oldParent) + (oldParent === root ? "" : SLASH_HEX) + oldName));
+                    const oldEvent = () => ownedPath(nameBytes(directoryHex(oldParent) + (oldParent === state.root ? "" : SLASH_HEX) + oldName));
                     oldParent.entries.delete(oldName);
                     newParent.entries.set(newName, child);
                     if (child.kind === "directory")
@@ -1580,16 +2661,16 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     advanceRevision(child);
                     if (replaced !== undefined) {
                         detach(replaced, now);
-                        entries -= 1;
+                        state.entries -= 1;
                     }
-                    watchHub.publishUnsafe(() => ({ _tag: "Remove", path: oldEvent() }));
+                    queuePublish(() => watchHub.publishUnsafe(() => ({ _tag: "Remove", path: oldEvent() })));
                     publishEntry("Create", newParent, newName);
                 }));
             }),
             rmdir: Effect.fn("Caller.rmdir")(function* (input, options) {
                 const prepared = preparePath(input, "rmdir", settings.maxPathBytes);
                 const base = options?.relativeTo;
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinated("rmdir", Effect.gen(function* () {
                     const path = yield* Effect.fromResult(prepared);
                     const parent = yield* locate(path, base, "rmdir", { parentOnly: true });
                     yield* authorize(parent, identity, WRITE | EXECUTE, "rmdir", input);
@@ -1604,8 +2685,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     if (child.kind !== "directory") {
                         return yield* new FsError({ code: "NotDirectory", operation: "rmdir", path: input });
                     }
-                    if (child.entries.size > 0)
+                    if (child.entries.size > 0) {
                         return yield* new FsError({ code: "NotEmpty", operation: "rmdir", path: input });
+                    }
                     const now = yield* timestamp("rmdir");
                     parent.entries.delete(name);
                     parent.metadata = { ...parent.metadata, nlink: parent.metadata.nlink - 1, mtimeNs: now, ctimeNs: now };
@@ -1614,14 +2696,14 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     advanceRevision(parent);
                     advanceRevision(child);
                     invalidateReference(child);
-                    entries -= 1;
+                    state.entries -= 1;
                     publishEntry("Remove", parent, name);
                 }));
             }),
             stat: Effect.fn("Caller.stat")(function* (input, options) {
                 const prepared = preparePath(input, "stat", settings.maxPathBytes);
                 const base = options?.relativeTo;
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinatedRead("stat", Effect.gen(function* () {
                     const path = yield* Effect.fromResult(prepared);
                     const directory = yield* resolveNode(path, base, "stat");
                     return { ...directory.metadata };
@@ -1633,7 +2715,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 const mode = options?.mode === undefined ? 0o777 : options.mode;
                 if (!isMode(mode))
                     return yield* new FsError({ code: "InvalidArgument", operation: "mkdir", path: input });
-                return yield* coordinated(Effect.gen(function* () {
+                return yield* coordinated("mkdir", Effect.gen(function* () {
                     const path = yield* Effect.fromResult(prepared);
                     const parent = yield* locate(path, base, "mkdir", { parentOnly: true });
                     yield* authorize(parent, identity, WRITE | EXECUTE, "mkdir", input);
@@ -1650,14 +2732,14 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                         lineage: undefined,
                         parent,
                         entries: new Map(),
-                        metadata: directoryMetadata(nextInode, identity.uid, parent.metadata.gid, (mode & 0o777 & ~umask) | (mode & STICKY_BIT), now),
+                        metadata: directoryMetadata(state.nextInode, identity.uid, parent.metadata.gid, (mode & 0o777 & ~umask) | (mode & STICKY_BIT), now),
                         revision: nextRevision(),
                         objectReference: undefined
                     };
                     // No Effect yield or expected failure between these publication writes.
                     attach(parent, name, child, now);
-                    nextInode += 1n;
-                    entries += 1;
+                    state.nextInode += 1n;
+                    state.entries += 1;
                     publishEntry("Create", parent, name);
                 }));
             }),
@@ -1669,10 +2751,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 const acquired = yield* acquireDirectory(input, options, "openDirectory");
                 const handle = Object.freeze({
                     [DirectoryHandleId]: true,
-                    stat: coordinated(Effect.suspend(() => acquired.directory === undefined
+                    stat: coordinatedRead("stat", Effect.suspend(() => acquired.directory === undefined
                         ? Effect.fail(new FsError({ code: "InvalidHandle", operation: "stat" }))
                         : Effect.succeed({ ...acquired.directory.metadata }))).pipe(Effect.withSpan("DirectoryHandle.stat")),
-                    close: coordinated(Effect.suspend(() => {
+                    close: coordinatedCleanup(Effect.suspend(() => {
                         if (acquired.directory === undefined) {
                             return Effect.fail(new FsError({ code: "InvalidHandle", operation: "close" }));
                         }
@@ -1700,18 +2782,24 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
     let surface;
     const volume = Object.freeze({
         [VolumeId]: true,
+        durability,
+        identity,
+        incarnation,
+        limits,
+        usage: coordinatedRead("usage", Effect.sync(() => ({ usedBytes: state.usedBytes, entries: state.entries })))
+            .pipe(Effect.withSpan("Volume.usage")),
         watch: Effect.gen(function* () {
             const hook = TestHooks.getRegistrationHook(surface);
-            return yield* watchHub.subscribe(hook?.afterSubscribe);
+            return yield* admit("watch", watchHub.subscribe(hook?.afterSubscribe));
         }).pipe(Effect.withSpan("Volume.watch")),
-        snapshot: coordinatedRead(captureSnapshot()).pipe(Effect.withSpan("Volume.snapshot")),
+        snapshot: coordinatedRead("snapshot", captureSnapshot()).pipe(Effect.withSpan("Volume.snapshot")),
         caller: Effect.fn("Volume.caller")(function* (options) {
             const decoded = decodeConfiguration(RootCallerOptions, options === undefined ? {} : options);
             if (Result.isFailure(decoded))
                 return yield* decoded.failure;
             const chosen = decoded.success.identity ?? { uid: 0, gid: 0, groups: [], privileged: true };
             const identity = Object.freeze({ ...chosen, groups: Object.freeze([...chosen.groups]) });
-            return createCaller({ volume: volumeIdentity, directory: root, closed: false }, identity, decoded.success.umask ?? 0o022);
+            return yield* coordinatedRead("caller", Effect.sync(() => createCaller(makeDirectoryReference(state.root), identity, decoded.success.umask ?? 0o022)));
         })
     });
     surface = volume;
@@ -1724,12 +2812,12 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
         ...volume,
         changes: Effect.fn("OverlayVolume.changes")(function* (options) {
             const selected = yield* changeOptions(options);
-            const current = yield* coordinatedRead(observeChanges());
+            const current = yield* coordinatedRead("changes", observeChanges());
             return publicChanges(compareOverlay(baseObservation, current, selected.includeTimestamps ?? false));
         }),
         capture: Effect.fn("OverlayVolume.capture")(function* (options) {
             const selected = yield* changeOptions(options);
-            const current = yield* coordinatedRead(captureState(hook));
+            const current = yield* coordinatedRead("capture", captureState(hook));
             return Object.freeze({
                 snapshot: current.snapshot,
                 changes: publicChanges(compareOverlay(baseObservation, current.observation, selected.includeTimestamps ?? false))
@@ -1744,6 +2832,53 @@ export const make = Effect.fn("VirtualFileSystem.make")(function* (options) {
     return yield* makeVolume(VolumeSource.Empty(), options).pipe(Effect.catchTag("ImageError", Effect.die));
 });
 /** @internal */
+export const prepareEmptyLiveImage = Effect.fnUntraced(function* (options) {
+    let bytes;
+    yield* makeVolume(VolumeSource.Empty(), options, undefined, (initial, identity, limits) => captureLiveImage(initial, identity, limits).pipe(Effect.tap((image) => Effect.sync(() => {
+        bytes = image;
+    })), Effect.asVoid));
+    if (bytes === undefined)
+        return yield* new ImageError({ code: "InvalidStructure", field: "liveImage" });
+    return bytes;
+});
+/** @internal */
+export const openImageVolume = Effect.fnUntraced(function* (image, maxImageBytes, commit, durability = "memory-only") {
+    const document = yield* LiveImage.decode(image, maxImageBytes);
+    const prepared = new WeakMap();
+    const identity = VolumeIdentity.make(document.identity);
+    let shutdown;
+    const limits = {
+        maxEntries: document.limits.maxEntries,
+        maxBytes: document.limits.maxBytes === undefined ? undefined : ByteSize.bytes(document.limits.maxBytes),
+        maxFileBytes: document.limits.maxFileBytes === undefined
+            ? ByteSize.bytes(0xffffffff)
+            : ByteSize.bytes(document.limits.maxFileBytes),
+        maxPathBytes: document.limits.maxPathBytes === undefined ? undefined : ByteSize.bytes(document.limits.maxPathBytes),
+        maxPendingOperations: 64,
+        maxWatchEvents: 256
+    };
+    const volume = yield* makeVolume(VolumeSource.Live({ document }), undefined, {
+        onReady: (effect) => {
+            shutdown = effect;
+        },
+        prepare: (candidate) => captureLiveImage(candidate, identity, limits).pipe(Effect.flatMap((bytes) => ByteSize.isGreaterThan(ByteSize.bytes(bytes.length), maxImageBytes)
+            ? new FsError({ code: "StorageRejected", operation: "commit" })
+            : Effect.sync(() => {
+                prepared.set(candidate, bytes);
+            })), Effect.mapError(() => new FsError({ code: "StorageRejected", operation: "commit" }))),
+        commit: (candidate) => Effect.suspend(() => {
+            const bytes = prepared.get(candidate);
+            if (bytes === undefined)
+                return Effect.succeed("unknown");
+            prepared.delete(candidate);
+            return commit(bytes);
+        })
+    }, undefined, durability);
+    if (shutdown === undefined)
+        return yield* new ImageError({ code: "InvalidStructure", field: "liveImage" });
+    return Object.freeze({ volume, shutdown });
+});
+/** @internal */
 export const fromSnapshot = Effect.fn("VirtualFileSystem.fromSnapshot")(function* (snapshot, options) {
     const image = yield* Image.inspect(snapshot);
     return yield* makeVolume(VolumeSource.Snapshot({ image }), options);