@effect-vfs/core 0.8.0 → 0.9.0

package/dist/internal/virtualFileSystem.js

@@ -23,8 +23,11 @@ import { Mode, OwnerUpdate, Times } from "../Metadata.js";
 import { isEntry, Target } from "../Target.js";
 import { make as makeError } from "../VfsError.js";
 import { OverlayChange, OverlayChangesOptions, ReferenceKey, VolumeId, VolumeIdentity, VolumeIncarnation } from "../Volume.js";
-import { WatchOptions } from "../Watch.js";
+import { CallerWatchOptions, WatchOptions } from "../Watch.js";
 import { sameBytes } from "./bytes.js";
+import * as CallerWatch from "./callerWatch.js";
+import * as Confinement from "./confinement.js";
+import * as DirectoryEntries from "./directoryEntries.js";
 import { argumentFailure, decodeConfiguration, errorPath, fsFailure, imageFailure, OpContext, retargetFailure, VfsError } from "./errors.js";
 import { KeySecret, VolumeEpoch } from "./hex128.js";
 import { hmacSha256, sameTag } from "./hmac.js";
@@ -112,14 +115,16 @@ class Draft extends Context.Service()("@effect-vfs/core/internal/virtualFileSyst
             finished: undefined,
             entries: base.entries,
             usedBytes: base.usedBytes,
+            renames: [],
             events: [],
             after: [],
             removed: []
         });
-        const get = (ino) => Effect.sync(() => {
+        const lookup = (ino) => {
             const draft = MutableRef.get(cell);
             return draft.pending.has(ino) ? draft.pending.get(ino) : InodeTable.get(base.inodes, ino);
-        });
+        };
+        const get = (ino) => Effect.sync(() => lookup(ino));
         const openCount = (ino) => Effect.sync(() => MutableRef.get(cell).opens?.get(ino) ?? base.open.get(ino) ?? 0);
         const put = (node, changed) => Effect.sync(() => {
             MutableRef.update(cell, (draft) => {
@@ -130,6 +135,7 @@ class Draft extends Context.Service()("@effect-vfs/core/internal/virtualFileSyst
         });
         return {
             revision,
+            lookup,
             get,
             put: (node) => put(node, true),
             putQuiet: (node) => put(node, false),
@@ -167,6 +173,9 @@ class Draft extends Context.Service()("@effect-vfs/core/internal/virtualFileSyst
             addUsedBytes: (amount) => Effect.sync(() => {
                 MutableRef.update(cell, (draft) => ({ ...draft, usedBytes: draft.usedBytes + amount }));
             }),
+            rename: (rename) => Effect.sync(() => {
+                MutableRef.get(cell).renames.push(rename);
+            }),
             publish: (event) => Effect.sync(() => {
                 MutableRef.get(cell).events.push(event);
             }),
@@ -203,19 +212,15 @@ class Draft extends Context.Service()("@effect-vfs/core/internal/virtualFileSyst
                 return finished;
             }),
             actions: Effect.sync(() => {
-                const { events, after, removed } = MutableRef.get(cell);
-                return { events, after, removed };
+                const { events, after, removed, renames } = MutableRef.get(cell);
+                return { events, after, removed, renames };
             })
         };
     })
 }) {
 }
 const withMetadata = (node) => ({ ...node.metadata, revision: node.revision });
-const withEntries = (directory, edit) => {
-    const entries = new Map(directory.entries);
-    edit(entries);
-    return { ...directory, entries };
-};
+const withEntries = (directory, entries) => ({ ...directory, entries });
 const withoutLink = (links, parent, name) => {
     const index = links.findIndex((link) => link.parent === parent && link.name === name);
     return index < 0 ? links : [...links.slice(0, index), ...links.slice(index + 1)];
@@ -320,6 +325,8 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
     if (live !== undefined)
         state = live.value;
     const view = (ino) => Effect.flatMap(Effect.serviceOption(Draft), (draft) => Option.isSome(draft) ? draft.value.get(ino) : Effect.sync(() => getNode(state, ino)));
+    // Select the operation's namespace at execution time; never retain it across operations.
+    const authorityView = Effect.map(Effect.serviceOption(Draft), (draft) => Option.isSome(draft) ? draft.value.lookup : (ino) => getNode(state, ino));
     const registry = TokenRegistry.make(volumeIdentity, view);
     const referenceFor = registry.referenceFor;
     const makeFileReference = registry.file;
@@ -337,7 +344,11 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
         for (const apply of actions.after)
             apply();
         const after = state;
-        watchHub.publishUnsafe(() => actions.events.flatMap((events) => Array.from(events(after))), { before, after });
+        watchHub.publishUnsafe(() => actions.events.flatMap((events) => Array.from(events(after))), {
+            before,
+            after,
+            renames: actions.renames
+        });
     });
     const transition = Effect.fnUntraced(function* (change) {
         const current = yield* Draft.make(state);
@@ -420,10 +431,14 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
         return SLASH_HEX + names.reverse().join(SLASH_HEX);
     });
     const entryPath = (prefix, name) => ownedPath(nameBytes(prefix + (prefix === SLASH_HEX ? "" : SLASH_HEX) + name));
-    const publishEntry = (_tag, parent, name, ino) => Effect.flatMap(Draft, (draft) => draft.publish((installed) => {
-        const prefix = pathOf((at) => getNode(installed, at), parent);
-        return prefix === undefined ? [] : [{ change: { _tag, path: entryPath(prefix, name) }, parent, ino }];
-    }));
+    const publishEntry = Effect.fnUntraced(function* (_tag, parent, name, ino) {
+        const before = state;
+        const draft = yield* Draft;
+        yield* draft.publish((installed) => {
+            const prefix = pathOf((at) => getNode(installed, at), parent) ?? pathOf((at) => getNode(before, at), parent);
+            return prefix === undefined ? [] : [{ change: { _tag, path: entryPath(prefix, name) }, parent, ino, name }];
+        });
+    });
     const publishNode = Effect.fnUntraced(function* (ino) {
         const draft = yield* Draft;
         const target = yield* draft.get(ino);
@@ -599,7 +614,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                 mtimeNs: now,
                 ctimeNs: now
             }
-        }, (entries) => entries.set(name, child.ino)));
+        }, DirectoryEntries.set(parent.entries, name, child.ino)));
         if (child.kind === "directory")
             yield* d.put({ ...child, parent: parent.ino, name });
         else {
@@ -667,12 +682,14 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
         yield* publishNode(file.ino);
     });
     const fileHandle = (ref) => {
-        const get = Effect.fnUntraced(function* (op, access) {
+        const get = Effect.fnUntraced(function* (op, access, cleanup = false) {
             const ino = TokenRegistry.inode(ref);
             const node = ino === undefined ? undefined : yield* view(ino);
             if (node?.kind !== "file" || (access === "read" && ref.access === "write") ||
                 (access === "write" && ref.access === "read"))
                 return yield* op.fail("InvalidHandle");
+            if (!cleanup && ref.authority !== undefined)
+                yield* ref.authority(node, op);
             return node;
         });
         const read = (maximum, position) => {
@@ -754,19 +771,19 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
         const closeOp = OpContext.make("close");
         const handle = Object.freeze({
             [FileHandleId]: true,
-            read: Effect.fn("FileHandle.read")(function* (maximum) {
+            read: Effect.fnUntraced(function* (maximum) {
                 return (yield* read(maximum)).bytes;
             }),
-            pread: Effect.fn("FileHandle.pread")(function* (maximum, offset) {
+            pread: Effect.fnUntraced(function* (maximum, offset) {
                 return yield* read(maximum, offset);
             }),
-            write: Effect.fn("FileHandle.write")(function* (bytes) {
+            write: Effect.fnUntraced(function* (bytes) {
                 return yield* write(bytes);
             }),
-            pwrite: Effect.fn("FileHandle.pwrite")(function* (bytes, offset) {
+            pwrite: Effect.fnUntraced(function* (bytes, offset) {
                 return yield* write(bytes, offset);
             }),
-            seek: Effect.fn("FileHandle.seek")(function* (offset, mode) {
+            seek: Effect.fnUntraced(function* (offset, mode) {
                 const op = OpContext.make("seek");
                 return yield* coordinatedRead(op, Effect.uninterruptible(Effect.gen(function* () {
                     const file = yield* get(op);
@@ -791,23 +808,55 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                     return next;
                 })));
             }),
-            truncate: Effect.fn("FileHandle.truncate")(function* (length) {
+            truncate: Effect.fnUntraced(function* (length) {
                 const op = OpContext.make("truncate");
                 return yield* coordinated(op, Effect.gen(function* () {
                     yield* resize(yield* get(op, "write"), length, op);
                 }));
             }),
-            stat: coordinatedRead(statOp, Effect.map(Effect.suspend(() => get(statOp)), withMetadata)).pipe(Effect.withSpan("FileHandle.stat")),
-            sync: coordinatedRead(syncOp, Effect.suspend(() => Effect.asVoid(get(syncOp)))).pipe(Effect.withSpan("FileHandle.sync")),
-            close: closeFile(ref, closeOp, Effect.suspend(() => get(closeOp))).pipe(Effect.ensuring(closeReleasedScope(ref)), Effect.withSpan("FileHandle.close"))
+            stat: coordinatedRead(statOp, Effect.map(Effect.suspend(() => get(statOp)), withMetadata)),
+            sync: coordinatedRead(syncOp, Effect.suspend(() => Effect.asVoid(get(syncOp)))),
+            close: closeFile(ref, closeOp, Effect.suspend(() => get(closeOp, undefined, true))).pipe(Effect.ensuring(closeReleasedScope(ref)))
         });
         registry.registerFile(handle, ref);
         return handle;
     };
-    const createCaller = (reference, identity, umask) => {
+    const createCaller = (reference, identity, umask, roots = [], inherited = []) => {
+        const boundary = roots.length === 0 ? undefined : Confinement.make(authorityView, roots);
+        inherited = inherited.filter((chain, index) => !((chain.length <= roots.length && chain.every((ino, at) => roots[at] === ino)) ||
+            inherited.slice(0, index).some((other) => other.length === chain.length && chain.every((ino, at) => other[at] === ino))));
+        const additional = inherited.map((chain) => Confinement.make(authorityView, chain));
+        const checkAuthority = Effect.fnUntraced(function* (node, op) {
+            if (boundary !== undefined)
+                yield* boundary.check(node, op);
+            for (const authority of additional)
+                yield* authority.check(node, op);
+        });
+        const inheritedFor = (target) => Target.$is("Handle")(target)
+            ? registry.handleBoundaries(target.handle)
+            : Target.$is("Path")(target) && target.relativeTo !== undefined
+                ? registry.handleBoundaries(target.relativeTo)
+                : [];
+        const boundariesFor = (target) => [...(roots.length > 0 ? [roots] : []), ...inherited, ...(target === undefined ? [] : inheritedFor(target))];
+        const assignAuthority = (ref, target) => {
+            const chains = boundariesFor(target).filter((chain, index, all) => !all.some((other, at) => at !== index && other.length >= chain.length && chain.every((ino, offset) => other[offset] === ino) &&
+                (other.length > chain.length || at < index)));
+            if (chains.length === 0)
+                return;
+            ref.boundaries = chains;
+            const authorities = chains.map((chain) => Confinement.make(authorityView, chain));
+            ref.authority = Effect.fnUntraced(function* (node, op) {
+                for (const authority of authorities)
+                    yield* authority.check(node, op, true);
+            });
+        };
+        const callerPath = boundary?.path ?? pathOfCurrent;
         const resolver = Resolution.make({
             caller: reference,
+            confinement: boundary,
+            additional: additional.length === 0 ? undefined : additional,
             get: view,
+            authorityView,
             identity,
             maxPathBytes: limits.maxPathBytes,
             registry
@@ -965,6 +1014,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
             : Effect.void;
         const claimName = Effect.fnUntraced(function* (entry, trailingSlash = "allowed") {
             const parent = yield* directoryNow(entry.parent);
+            if (boundary !== undefined && parent.ino === boundary.root &&
+                (entry.name === undefined || isDotComponent(entry.name)))
+                return yield* entry.op.fail("NotPermitted");
             if (isDotComponent(entry.name)) {
                 return yield* entry.op.fail(entry.addressing === "entry" ? "InvalidArgument" : "AlreadyExists");
             }
@@ -1071,7 +1123,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                     mtimeNs: now,
                     ctimeNs: now
                 }
-            }, (entries) => entries.delete(name)));
+            }, DirectoryEntries.remove(parent.entries, name)));
             yield* publishEntry("Remove", parent.ino, name, child.ino);
             yield* detach(child, parent.ino, name, now);
             yield* d.addEntries(-1);
@@ -1080,8 +1132,13 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
         // Authorizes removing from the entry's directory and returns the named child. Only a path can name a dot
         // entry, and each verb reports it with its own code. Search permission comes before the lookup and write
         // permission after it, as on Linux; `beforeWrite` holds the verb's own checks that Linux makes in between.
+        const protectsRoot = (parent, name) => boundary !== undefined &&
+            ((parent.ino === boundary.root && (name === undefined || isDotComponent(name))) ||
+                (name === "2e2e" && parent.parent === boundary.root));
         const removalTarget = Effect.fnUntraced(function* (entry, dotNameCode, beforeWrite) {
             const parent = yield* directoryNow(entry.parent);
+            if (protectsRoot(parent, entry.name))
+                return yield* entry.op.fail("NotPermitted");
             if (isDotComponent(entry.name)) {
                 return yield* entry.op.fail(entry.addressing === "entry" ? "InvalidArgument" : dotNameCode);
             }
@@ -1090,6 +1147,8 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
             const child = childIno === undefined ? undefined : (yield* view(childIno));
             if (child === undefined)
                 return yield* entry.op.fail("NotFound");
+            if (child.ino === boundary?.root)
+                return yield* entry.op.fail("NotPermitted");
             const rejected = beforeWrite?.(child);
             if (rejected !== undefined)
                 return yield* rejected;
@@ -1127,6 +1186,8 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
             const sameDirectory = source.parent === destination.parent;
             const sourceName = source.name;
             const destinationName = destination.name;
+            if (protectsRoot(sourceDirectory, sourceName) || protectsRoot(destinationDirectory, destinationName))
+                return yield* source.op.fail("NotPermitted");
             if (isDotComponent(sourceName) || isDotComponent(destinationName)) {
                 return yield* source.op.fail("InvalidArgument");
             }
@@ -1142,6 +1203,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                 return yield* source.op.fail("NotFound");
             const replacedIno = destinationDirectory.entries.get(destinationName);
             const replaced = replacedIno === undefined ? undefined : (yield* view(replacedIno));
+            if (boundary !== undefined && (child.ino === boundary.root || replaced?.ino === boundary.root)) {
+                return yield* source.op.fail("NotPermitted");
+            }
             // A trailing slash on either side asks for a directory; a missing slashed destination is fine when the
             // source is one, as Linux allows.
             if ((source.trailingSlash || destination.trailingSlash) && child.kind !== "directory") {
@@ -1190,6 +1254,11 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
             }
             const now = yield* timestamp(op);
             const d = yield* Draft;
+            yield* d.rename({
+                ino: child.ino,
+                from: { parent: source.parent, name: sourceName },
+                to: { parent: destination.parent, name: destinationName }
+            });
             yield* publishEntry("Remove", sourceDirectory.ino, sourceName, child.ino);
             yield* d.put(withEntries({
                 ...sourceDirectory,
@@ -1199,7 +1268,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                     mtimeNs: now,
                     ctimeNs: now
                 }
-            }, (entries) => entries.delete(sourceName)));
+            }, DirectoryEntries.remove(sourceDirectory.entries, sourceName)));
             const destinationNow = yield* directoryNow(destination.parent);
             yield* d.put(withEntries({
                 ...destinationNow,
@@ -1209,7 +1278,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                     mtimeNs: now,
                     ctimeNs: now
                 }
-            }, (entries) => entries.set(destinationName, child.ino)));
+            }, DirectoryEntries.set(destinationNow.entries, destinationName, child.ino)));
             const moved = yield* nodeNow(child.ino);
             if (moved.kind === "directory") {
                 yield* d.put({
@@ -1309,6 +1378,21 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
             return yield* acquireHandle(acquired, (acquire) => coordinatedRead(op, Effect.uninterruptible(acquire)), Effect.gen(function* () {
                 const directory = yield* resolveDirectory(target, op);
                 yield* authorize(directory.node, identity, EXECUTE, directory.op);
+                assignAuthority(acquired, target);
+                const candidates = acquired.boundaries ?? [];
+                if (candidates.length === 1)
+                    acquired.namespaceRoots = candidates[0];
+                let current = directory.node;
+                while (candidates.length > 1) {
+                    const nearest = candidates.find((chain) => chain.at(-1) === current.ino);
+                    if (nearest !== undefined) {
+                        acquired.namespaceRoots = nearest;
+                        break;
+                    }
+                    if (current.ino === ROOT_INO)
+                        break;
+                    current = yield* directoryNow(current.parent);
+                }
                 holdDirectory(directory.node.ino);
                 TokenRegistry.publish(acquired, directory.node.ino);
                 return acquired;
@@ -1345,6 +1429,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                 const file = resolved.kind === "existing" ? resolved.node : undefined;
                 const result = yield* openFile({ parent: parent.ino, name, trailingSlash: path.trailingSlash, addressing: "path", op: pathOp }, file, chosen, acquired, op);
                 opened(result.ino);
+                assignAuthority(acquired, target);
                 return fileHandle(acquired);
             }));
         });
@@ -1368,6 +1453,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                 yield* draft.retain(node.ino);
                 yield* bindFile(acquired, node.ino);
                 opened(node.ino);
+                assignAuthority(acquired, target);
                 return fileHandle(acquired);
             }));
         });
@@ -1425,7 +1511,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                 const result = yield* openFile({ parent: mutationParent, name: mutationName, trailingSlash: false, addressing: "entry", op }, file, { ...chosen, initialSize: chosen.initialSize ?? 0n }, acquired, op);
                 opened(result.ino);
                 return {
-                    handle: fileHandle(acquired),
+                    handle: (() => {
+                        assignAuthority(acquired, entry.directory);
+                        return fileHandle(acquired);
+                    })(),
                     reference: referenceFor(result.ino),
                     created: result.created,
                     directory: result.directory
@@ -1492,10 +1581,14 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
         // through a reference or a handle is held by the object it resolved to, as a descriptor holds it.
         // It steps down the chain in a loop, so a tree of any depth reaches its frames without deepening the stack.
         const reachFrame = (frame, at) => Effect.gen(function* () {
+            if (boundary !== undefined)
+                yield* boundary.alive(at);
             const chain = [];
             for (let link = frame; link !== undefined; link = link.up)
                 chain.push(link);
             let node = yield* view((chain.at(-1) ?? frame).parent);
+            if (node !== undefined)
+                yield* checkAuthority(node, at);
             for (let index = chain.length - 1; index >= 0; index--) {
                 const link = chain[index];
                 if (link === undefined || node?.kind !== "directory" || node.metadata.nlink === 0)
@@ -1582,13 +1675,15 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
         // failure, which names the entry's path under the one the caller gave. Removing an empty directory reveals nothing, so only a directory with entries must be readable, and
         // no permission is changed to make one so. With `force`, the entry itself going missing leaves nothing to
         // empty.
-        const emptyDirectory = Effect.fnUntraced(function* (prepared, op, force) {
+        const emptyDirectory = Effect.fnUntraced(function* (prepared, op, force, guard) {
             const prefix = prepared.kind === "path" ? prepared.path.bytes : nameBytes(prepared.name);
             const locate = (path) => ownedPath(joinPath(prefix, path));
-            const listable = (directory, at) => directory.entries.size === 0 ? Effect.void : authorize(directory, identity, READ, at);
+            const targetGuard = guard.pipe(Effect.catchIf((error) => force && error.code === "NotFound", () => Effect.void));
+            const listable = (directory, at) => Effect.andThen(targetGuard, directory.entries.size === 0 ? Effect.void : authorize(directory, identity, READ, at));
             let anchor;
             let targetAt = preparedOp(prepared, op);
             const first = coordinatedRead(op, Effect.gen(function* () {
+                yield* guard;
                 const entry = yield* resolveEntry(prepared, op);
                 const parent = yield* directoryNow(entry.parent);
                 yield* authorize(parent, identity, EXECUTE, entry.op);
@@ -1607,6 +1702,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
             const removeFrame = (frame) => {
                 const at = op.at(locate(frame.path));
                 return Effect.andThen(seams.beforeTreeRemoval, coordinated(op, Effect.gen(function* () {
+                    yield* targetGuard;
                     if (anchor !== undefined && !holds(yield* view(anchor.parent), anchor)) {
                         return yield* (force ? Effect.void : Effect.fail(targetAt.fail("NotFound")));
                     }
@@ -1630,7 +1726,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
             const prepared = yield* Effect.fromResult(prepareEntry(input, op));
             return yield* coordinated(op, Effect.flatMap(resolveEntry(prepared, op), (entry) => body(entry, op)));
         });
-        const openDispatch = Effect.fn("Caller.open")(function* (input, options) {
+        const openDispatch = Effect.fnUntraced(function* (input, options) {
             const op = OpContext.make("open");
             if (isEntry(input))
                 return yield* openEntry(input, options, op);
@@ -1642,11 +1738,34 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
         function open(input, options) {
             return openDispatch(input, options);
         }
-        const removeDispatch = Effect.fn("Caller.remove")(function* (input, options) {
+        const removeDispatch = Effect.fnUntraced(function* (input, options) {
             const op = OpContext.make("remove");
             const prepared = yield* Effect.fromResult(prepareEntry(input, op));
             const chosen = yield* decodeRemoveOptions(options ?? {}).pipe(Effect.mapError((cause) => fail(preparedOp(prepared, op), cause)));
-            const once = coordinated(op, Effect.flatMap(resolveEntry(prepared, op), (entry) => removeEntry(entry, op)));
+            const imported = prepared.kind === "entry"
+                ? inheritedFor(prepared.directory)
+                : prepared.base === undefined
+                    ? []
+                    : registry.handleBoundaries(prepared.base);
+            const guard = chosen.expected === undefined && imported.length === 0 ? Effect.void : Effect.gen(function* () {
+                const entry = yield* resolveEntry(prepared, op);
+                const parent = yield* directoryNow(entry.parent);
+                if (protectsRoot(parent, entry.name))
+                    return yield* entry.op.fail("NotPermitted");
+                if (chosen.expected === undefined)
+                    return;
+                const expected = yield* registry.referenceIdentity(chosen.expected, op);
+                const expectedNode = yield* view(expected);
+                if (expectedNode !== undefined && expectedNode.metadata.nlink > 0)
+                    yield* checkAuthority(expectedNode, op);
+                yield* authorize(parent, identity, EXECUTE, entry.op);
+                const found = entry.name === undefined ? parent.ino : parent.entries.get(entry.name);
+                if (found === undefined)
+                    return yield* entry.op.fail("NotFound");
+                if (found !== expected)
+                    return yield* entry.op.fail("VolumeBusy", { field: "expected" });
+            });
+            const once = coordinated(op, Effect.andThen(guard, Effect.flatMap(resolveEntry(prepared, op), (entry) => removeEntry(entry, op))));
             const target = (effect) => chosen.force === true
                 ? Effect.catchIf(effect, (error) => error.code === "NotFound", () => Effect.undefined)
                 : effect;
@@ -1655,7 +1774,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                 return removed.success;
             if (chosen.recursive !== true || removed.failure.code !== "NotEmpty")
                 return yield* removed.failure;
-            yield* emptyDirectory(prepared, op, chosen.force === true);
+            yield* emptyDirectory(prepared, op, chosen.force === true, guard);
             return yield* target(once);
         });
         function remove(input, options) {
@@ -1663,10 +1782,43 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
         }
         const caller = Object.freeze({
             [CallerId]: true,
+            limits,
+            watch: Effect.fnUntraced(function* (input, options) {
+                const op = OpContext.make("watch");
+                const decoded = yield* Effect.fromResult(decodeConfiguration(CallerWatchOptions, options ?? {}, "watch"));
+                const target = asTarget(input);
+                const seams = yield* VolumeTestSeams;
+                const select = Effect.gen(function* () {
+                    yield* checkAvailable("watch");
+                    const resolved = yield* resolveTarget(target, op);
+                    yield* authorize(resolved.node, identity, READ, resolved.op);
+                    if (resolved.node.metadata.nlink === 0)
+                        return yield* resolved.op.fail("NotFound");
+                    if (decoded.alias === "resolved" && resolved.kind === "node" && resolved.node.kind !== "directory") {
+                        return yield* op.fail("InvalidArgument");
+                    }
+                    const selection = {
+                        roots,
+                        additionalRoots: [...inherited, ...inheritedFor(target)],
+                        target: resolved.node.ino,
+                        recursive: decoded.recursive ?? true
+                    };
+                    return CallerWatch.make(decoded.alias === "resolved" && resolved.kind === "entry"
+                        ? { ...selection, selected: { parent: resolved.parent.ino, name: resolved.name } }
+                        : selection);
+                });
+                return Stream.map(yield* admit(op, watchHub.subscribe(select, seams.afterSubscribe)), (event) => event.change);
+            }),
             root: coordinatedRead(rootOp, Effect.suspend(() => TokenRegistry.inode(reference) === undefined
                 ? Effect.fail(rootOp.fail("ClosedCaller"))
-                : Effect.succeed(referenceFor(ROOT_INO)))).pipe(Effect.withSpan("Caller.root")),
-            lookup: Effect.fn("Caller.lookup")(function* (input) {
+                : Effect.gen(function* () {
+                    const node = yield* view(boundary?.root ?? ROOT_INO);
+                    if (node === undefined)
+                        return yield* rootOp.fail("ClosedCaller");
+                    yield* checkAuthority(node, rootOp);
+                    return referenceFor(node.ino);
+                }))),
+            lookup: Effect.fnUntraced(function* (input) {
                 const op = OpContext.make("lookup");
                 const prepared = yield* Effect.fromResult(prepareEntry(input, op));
                 return yield* coordinatedRead(op, Effect.gen(function* () {
@@ -1682,21 +1834,24 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                     return referenceFor(child);
                 }));
             }),
-            parent: Effect.fn("Caller.parent")(function* (input) {
+            parent: Effect.fnUntraced(function* (input) {
                 const op = OpContext.make("parent");
                 const target = asTarget(input);
                 return yield* coordinatedRead(op, Effect.gen(function* () {
                     const directory = yield* resolveDirectory(target, op);
                     yield* authorize(directory.node, identity, EXECUTE, directory.op);
-                    return referenceFor(directory.node.parent);
+                    return referenceFor(directory.node.ino === boundary?.root ||
+                        inheritedFor(target).some((chain) => chain.at(-1) === directory.node.ino)
+                        ? directory.node.ino
+                        : directory.node.parent);
                 }));
             }),
-            stat: Effect.fn("Caller.stat")(function* (input) {
+            stat: Effect.fnUntraced(function* (input) {
                 const op = OpContext.make("stat");
                 const target = asTarget(input);
                 return yield* coordinatedRead(op, Effect.map(resolveTarget(target, op), (resolved) => withMetadata(resolved.node)));
             }),
-            readDirectory: Effect.fn("Caller.readDirectory")(function* (input) {
+            readDirectory: Effect.fnUntraced(function* (input) {
                 const op = OpContext.make("readDirectory");
                 const target = asTarget(input);
                 return yield* accessing(op, Effect.gen(function* () {
@@ -1712,7 +1867,12 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                 const target = asTarget(input);
                 const prefix = Target.$is("Path")(target) ? Result.getOrUndefined(inputBytes(target.path)) : undefined;
                 const locate = (path) => ownedPath(prefix === undefined ? path : joinPath(prefix, path));
-                const readable = (directory, at) => authorize(directory, identity, READ, at);
+                const authorities = inheritedFor(target).map((chain) => Confinement.make(authorityView, chain));
+                const readable = Effect.fnUntraced(function* (directory, at) {
+                    for (const authority of authorities)
+                        yield* authority.check(directory, at, true);
+                    yield* authorize(directory, identity, READ, at);
+                });
                 return Stream.unwrap(Effect.gen(function* () {
                     const chosen = yield* decodeWalkOptions(options ?? {}).pipe(Effect.mapError((cause) => fail(Target.$is("Path")(target) ? op.at(target.path) : op, cause)));
                     const first = coordinatedRead(op, Effect.gen(function* () {
@@ -1743,9 +1903,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                         kind: frame.kind,
                         depth: frame.depth
                     }));
-                })).pipe(Stream.withSpan("Caller.walk"));
+                }));
             },
-            readLink: Effect.fn("Caller.readLink")(function* (input) {
+            readLink: Effect.fnUntraced(function* (input) {
                 const op = OpContext.make("readLink");
                 const target = asTarget(input);
                 return yield* coordinatedRead(op, Effect.gen(function* () {
@@ -1755,7 +1915,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                     return new Uint8Array(resolved.node.target);
                 }));
             }),
-            realPath: Effect.fn("Caller.realPath")(function* (input) {
+            realPath: Effect.fnUntraced(function* (input) {
                 const op = OpContext.make("realPath");
                 const target = asTarget(input);
                 return yield* coordinatedRead(op, Effect.gen(function* () {
@@ -1767,7 +1927,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                             : result.kind === "entry"
                                 ? result.parent
                                 : undefined;
-                        const prefix = directory === undefined ? SLASH_HEX : yield* pathOfCurrent(directory.ino);
+                        const prefix = directory === undefined ? SLASH_HEX : yield* callerPath(directory.ino);
                         if (prefix === undefined)
                             return yield* pathOp.fail("NotFound");
                         if (result.node.kind === "directory" || result.kind === "node")
@@ -1775,13 +1935,13 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                         return ownedPath(nameBytes(prefix + (prefix === SLASH_HEX ? "" : SLASH_HEX) + result.name));
                     }
                     const resolved = yield* resolveTarget(target, op);
-                    const path = yield* pathOfCurrent(resolved.node.ino);
+                    const path = yield* callerPath(resolved.node.ino);
                     if (path === undefined)
                         return yield* resolved.op.fail("NotFound");
                     return ownedPath(nameBytes(path));
                 }));
             }),
-            access: Effect.fn("Caller.access")(function* (input, bits = 0) {
+            access: Effect.fnUntraced(function* (input, bits = 0) {
                 const op = OpContext.make("access");
                 const target = asTarget(input);
                 if (!Number.isInteger(bits) || bits < 0 || bits > (READ | WRITE | EXECUTE)) {
@@ -1801,7 +1961,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                     return granted;
                 }));
             }),
-            readFile: Effect.fn("Caller.readFile")(function* (input) {
+            readFile: Effect.fnUntraced(function* (input) {
                 const op = OpContext.make("readFile");
                 const target = asTarget(input);
                 return yield* accessing(op, Effect.gen(function* () {
@@ -1816,7 +1976,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                     return { value: data, access: { node, now: yield* timestamp(op) } };
                 }));
             }),
-            writeFile: Effect.fn("Caller.writeFile")(function* (input, bytes, options) {
+            writeFile: Effect.fnUntraced(function* (input, bytes, options) {
                 const op = OpContext.make("writeFile");
                 const prepared = yield* Effect.fromResult(prepareEntry(input, op));
                 const optionsOp = preparedOp(prepared, op);
@@ -1903,7 +2063,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                 }));
             }),
             open,
-            mkdir: Effect.fn("Caller.mkdir")(function* (input, options = {}) {
+            mkdir: Effect.fnUntraced(function* (input, options = {}) {
                 const op = OpContext.make("mkdir");
                 const prepared = yield* Effect.fromResult(prepareEntry(input, op));
                 const optionsOp = preparedOp(prepared, op);
@@ -1919,7 +2079,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                     return { reference: referenceFor(child), directory };
                 }));
             }),
-            symlink: Effect.fn("Caller.symlink")(function* (target, input, options = {}) {
+            symlink: Effect.fnUntraced(function* (target, input, options = {}) {
                 const op = OpContext.make("symlink");
                 const targetOp = op.at(target);
                 const prepared = yield* Effect.fromResult(prepareEntry(input, op));
@@ -1938,7 +2098,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                     return { reference: referenceFor(child), directory };
                 }));
             }),
-            link: Effect.fn("Caller.link")(function* (sourceInput, input) {
+            link: Effect.fnUntraced(function* (sourceInput, input) {
                 const op = OpContext.make("link");
                 const source = asTarget(sourceInput);
                 const prepared = yield* Effect.fromResult(prepareEntry(input, op));
@@ -1954,14 +2114,14 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                     return { reference: referenceFor(node.ino), directory };
                 }));
             }),
-            unlink: Effect.fn("Caller.unlink")(function* (input) {
+            unlink: Effect.fnUntraced(function* (input) {
                 return yield* entryVerb("unlink", input, unlinkEntry);
             }),
-            rmdir: Effect.fn("Caller.rmdir")(function* (input) {
+            rmdir: Effect.fnUntraced(function* (input) {
                 return yield* entryVerb("rmdir", input, rmdirEntry);
             }),
             remove,
-            rename: Effect.fn("Caller.rename")(function* (fromInput, toInput) {
+            rename: Effect.fnUntraced(function* (fromInput, toInput) {
                 const op = OpContext.make("rename");
                 const from = yield* Effect.fromResult(prepareEntry(fromInput, op));
                 const to = yield* Effect.fromResult(prepareEntry(toInput, op));
@@ -1971,34 +2131,34 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                     return yield* renameEntry(source, destination, op);
                 }));
             }),
-            chmod: Effect.fn("Caller.chmod")(function* (input, mode) {
+            chmod: Effect.fnUntraced(function* (input, mode) {
                 const op = OpContext.make("chmod");
                 const target = asTarget(input);
                 if (!isMode(mode))
                     return yield* op.fail("InvalidArgument");
                 yield* changeAttributes(() => asResolvedNode(target, op), { mode }, op);
             }),
-            chown: Effect.fn("Caller.chown")(function* (input, owner) {
+            chown: Effect.fnUntraced(function* (input, owner) {
                 const op = OpContext.make("chown");
                 const target = asTarget(input);
                 const decoded = yield* decodeOwnerUpdate(owner).pipe(Effect.mapError((cause) => fail(op, cause)));
                 yield* changeAttributes(() => asResolvedNode(target, op), { owner: decoded }, op);
             }),
-            utimes: Effect.fn("Caller.utimes")(function* (input, times) {
+            utimes: Effect.fnUntraced(function* (input, times) {
                 const op = OpContext.make("utimes");
                 const target = asTarget(input);
                 const decoded = yield* decodeTimes(times).pipe(Effect.mapError((cause) => fail(op, cause)));
                 yield* changeAttributes(() => asResolvedNode(target, op), { times: decoded }, op);
             }),
             // A negative length fails before the target resolves, as truncate(2) rejects it before the lookup.
-            truncate: Effect.fn("Caller.truncate")(function* (input, length) {
+            truncate: Effect.fnUntraced(function* (input, length) {
                 const op = OpContext.make("truncate");
                 const target = asTarget(input);
                 if (!isLength(length))
                     return yield* op.fail("InvalidArgument");
                 yield* changeAttributes(() => asResolvedNode(target, op), { size: length }, op);
             }),
-            setattr: Effect.fn("Caller.setattr")(function* (input, attributes) {
+            setattr: Effect.fnUntraced(function* (input, attributes) {
                 const op = OpContext.make("setattr");
                 const target = asTarget(input);
                 // A caller outside TypeScript can pass anything, so a non-object fails typed rather than as a defect;
@@ -2024,11 +2184,15 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                     : yield* decodeExpected(attributes.expected).pipe(Effect.mapError((cause) => fail(op, cause, "expected")));
                 yield* changeAttributes(() => asResolvedNode(target, op), { size: attributes.size, mode: attributes.mode, owner, times, expected }, op);
             }),
-            withDirectory: Effect.fn("Caller.withDirectory")(function* (input) {
+            withRoot: Effect.fnUntraced(function* (input) {
+                const acquired = yield* acquireDirectory(input, OpContext.make("withRoot"));
+                return createCaller(acquired, identity, umask, [...roots, TokenRegistry.inode(acquired)], acquired.boundaries ?? []);
+            }),
+            withDirectory: Effect.fnUntraced(function* (input) {
                 const acquired = yield* acquireDirectory(input, OpContext.make("withDirectory"));
-                return createCaller(acquired, identity, umask);
+                return createCaller(acquired, identity, umask, acquired.namespaceRoots ?? roots, acquired.boundaries ?? []);
             }),
-            openDirectory: Effect.fn("Caller.openDirectory")(function* (input) {
+            openDirectory: Effect.fnUntraced(function* (input) {
                 const acquired = yield* acquireDirectory(input, OpContext.make("openDirectory"));
                 const statOp = OpContext.make("stat");
                 const handle = Object.freeze({
@@ -2036,16 +2200,18 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                     stat: coordinatedRead(statOp, Effect.gen(function* () {
                         const ino = TokenRegistry.inode(acquired);
                         const node = ino === undefined ? undefined : yield* view(ino);
+                        if (node !== undefined && acquired.authority !== undefined)
+                            yield* acquired.authority(node, statOp);
                         return yield* (node === undefined
                             ? Effect.fail(statOp.fail("InvalidHandle"))
                             : Effect.succeed(withMetadata(node)));
-                    })).pipe(Effect.withSpan("DirectoryHandle.stat")),
+                    })),
                     close: coordinatedCleanup(Effect.suspend(() => {
                         if (TokenRegistry.inode(acquired) === undefined) {
                             return Effect.fail(OpContext.make("close").fail("InvalidHandle"));
                         }
                         return releaseDirectory(acquired);
-                    })).pipe(Effect.ensuring(closeReleasedScope(acquired)), Effect.withSpan("DirectoryHandle.close"))
+                    })).pipe(Effect.ensuring(closeReleasedScope(acquired)))
                 });
                 registry.registerDirectory(handle, acquired);
                 return handle;
@@ -2059,9 +2225,8 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
         identity,
         incarnation,
         limits,
-        usage: coordinatedRead(OpContext.make("usage"), Effect.sync(() => ({ usedBytes: state.usedBytes, entries: state.entries })))
-            .pipe(Effect.withSpan("Volume.usage")),
-        watch: Effect.fn("Volume.watch")(function* (options) {
+        usage: coordinatedRead(OpContext.make("usage"), Effect.sync(() => ({ usedBytes: state.usedBytes, entries: state.entries }))),
+        watch: Effect.fnUntraced(function* (options) {
             const op = OpContext.make("watch");
             const decoded = yield* Effect.fromResult(decodeConfiguration(WatchOptions, options === undefined ? {} : options, "watch"));
             const recursive = decoded.recursive ?? true;
@@ -2075,8 +2240,8 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
             const stream = yield* admit(op, watchHub.subscribe(select, seams.afterSubscribe));
             return Stream.map(stream, (event) => event.change);
         }),
-        snapshot: coordinatedRead(OpContext.make("snapshot"), Effect.sync(() => Image.make(state))).pipe(Effect.withSpan("Volume.snapshot")),
-        referenceKey: Effect.fn("Volume.referenceKey")(function* (reference) {
+        snapshot: coordinatedRead(OpContext.make("snapshot"), Effect.sync(() => Image.make(state))),
+        referenceKey: Effect.fnUntraced(function* (reference) {
             const op = OpContext.make("referenceKey");
             return yield* coordinatedRead(op, Effect.gen(function* () {
                 const node = yield* TokenRegistry.nodeOrFail(yield* registry.resolve(reference, "reference"), "reference", op);
@@ -2084,7 +2249,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                 return { identity: identityBytes.slice(), epoch: epochBytes.slice(), ino, tag: keyTag(ino) };
             }));
         }),
-        resolveReferenceKey: Effect.fn("Volume.resolveReferenceKey")(function* (key) {
+        resolveReferenceKey: Effect.fnUntraced(function* (key) {
             const op = OpContext.make("resolveReferenceKey");
             return yield* coordinatedRead(op, Effect.gen(function* () {
                 if (!Schema.is(ReferenceKey)(key))
@@ -2101,7 +2266,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
                 return referenceFor(ino);
             }));
         }),
-        caller: Effect.fn("Volume.caller")(function* (options) {
+        caller: Effect.fnUntraced(function* (options) {
             const decoded = yield* Effect.fromResult(decodeConfiguration(RootCallerOptions, options === undefined ? {} : options, "caller"));
             const chosen = decoded.identity ?? { uid: 0, gid: 0, groups: [], privileged: true };
             const identity = Object.freeze({ ...chosen, groups: Object.freeze([...chosen.groups]) });
@@ -2115,7 +2280,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, commitProvider, o
     return Object.freeze({ volume, shutdown, observe });
 });
 /** @internal */
-export const make = Effect.fn("VirtualFileSystem.make")(function* (options) {
+export const make = Effect.fnUntraced(function* (options) {
     return (yield* makeVolume(VolumeSource.Empty(), memoryCommitProvider, options).pipe(Effect.catchIf((error) => Schema.is(VfsError)(error) && error.code !== "InvalidArgument", Effect.die))).volume;
 });
 /** @internal */
@@ -2154,22 +2319,22 @@ const changeOptions = (options) => {
     return Effect.fromResult(decodeConfiguration(OverlayChangesOptions, options === undefined ? {} : options, "changes"));
 };
 /** @internal */
-export const fromSnapshot = Effect.fn("VirtualFileSystem.fromSnapshot")(function* (snapshot, options) {
+export const fromSnapshot = Effect.fnUntraced(function* (snapshot, options) {
     return (yield* makeVolume(VolumeSource.Restored({ value: yield* Image.valueOf(snapshot) }), memoryCommitProvider, options)).volume;
 }, Effect.mapError((error) => retargetFailure("fromSnapshot", error)));
 /** @internal */
-export const makeOverlay = Effect.fn("VirtualFileSystem.makeOverlay")(function* (base, options) {
+export const makeOverlay = Effect.fnUntraced(function* (base, options) {
     const value = yield* Image.valueOf(base);
     const made = yield* Effect.mapError(makeVolume(VolumeSource.Restored({ value }), memoryCommitProvider, options), (error) => retargetFailure("makeOverlay", error));
     const baseObservation = yield* observeChanges(value);
     const overlay = Object.freeze({
         ...made.volume,
-        changes: Effect.fn("OverlayVolume.changes")(function* (options) {
+        changes: Effect.fnUntraced(function* (options) {
             const selected = yield* changeOptions(options);
             const current = yield* made.observe.changes;
             return publicChanges(compareOverlay(baseObservation, current, selected.includeTimestamps ?? false));
         }),
-        capture: Effect.fn("OverlayVolume.capture")(function* (options) {
+        capture: Effect.fnUntraced(function* (options) {
             const selected = yield* changeOptions(options);
             const current = yield* made.observe.capture;
             return Object.freeze({