@effect-vfs/core 0.3.0 → 0.3.1

package/dist/internal/virtualFileSystem.js

@@ -2,19 +2,22 @@
 import * as ByteSize from "effect/ByteSize";
 import * as Clock from "effect/Clock";
 import * as Context from "effect/Context";
+import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Encoding from "effect/Encoding";
+import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import * as Semaphore from "effect/Semaphore";
 import { BytePath } from "../BytePath.js";
 import { ImageError } from "../Snapshot.js";
-import { getBytes as getBytePathBytes } from "./bytePath.js";
+import { CanonicalBase64 } from "./canonicalBase64.js";
 import * as Image from "./image.js";
-import { ConfigurationError, FsCode as FsCodeSchema, FsError } from "./virtualFileSystem/errors.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 { attachedBuffer, decodeConfiguration, failure, nameBytes, ownedPath, preparePath, strictString, wellFormed } from "./virtualFileSystem/path.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";
 /** @internal */
@@ -29,8 +32,22 @@ export const DirectoryHandleId = Symbol("@effect-vfs/core/DirectoryHandle");
 export const ObjectReferenceId = Symbol("@effect-vfs/core/ObjectReference");
 /** @internal */
 export { ConfigurationError, FsCodeSchema as FsCode, FsError };
-/** @internal */
-export const Mode = Schema.Natural.check(Schema.isLessThanOrEqualTo(0o7777));
+// POSIX permission bits, masked against mode once it is shifted to the caller's class.
+const EXECUTE = 0o1;
+const WRITE = 0o2;
+const READ = 0o4;
+// Execute for every class; a file with none is not executable by anyone.
+const ANY_EXECUTE = 0o111;
+// setuid and setgid, cleared whenever a file's contents or ownership change.
+const SET_ID_BITS = 0o6000;
+// Sticky: only the owner of an entry or of its directory may remove it.
+const STICKY_BIT = 0o1000;
+const WALK_YIELD_INTERVAL = 128;
+// Largest signed 64-bit file offset, as POSIX off_t.
+const MAX_FILE_OFFSET = 0x7fffffffffffffffn;
+const Mode = Schema.Natural.check(Schema.isLessThanOrEqualTo(0o7777));
+const isMode = Schema.is(Mode);
+const isNatural = Schema.is(Schema.Natural);
 /** @internal */
 export const Identity = Schema.Struct({
     uid: Schema.Natural,
@@ -50,10 +67,7 @@ export const VolumeOptions = Schema.Struct({
     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")))
 });
-// Match snapshot v1's canonical signed decimal timestamp domain.
-const timestampLimit = 10n ** 128n - 1n;
-/** @internal */
-export const Timestamp = Schema.BigInt.check(Schema.isGreaterThanOrEqualToBigInt(-timestampLimit), Schema.isLessThanOrEqualToBigInt(timestampLimit));
+const isTimestamp = Schema.is(MetadataDomain.Timestamp);
 /** @internal */
 export const Metadata = Schema.Struct({
     kind: Schema.Literals(["directory", "file", "symlink"]),
@@ -63,10 +77,10 @@ export const Metadata = Schema.Struct({
     uid: Schema.Natural,
     gid: Schema.Natural,
     mode: Mode,
-    atimeNs: Timestamp,
-    mtimeNs: Timestamp,
-    ctimeNs: Timestamp,
-    birthtimeNs: Timestamp
+    atimeNs: MetadataDomain.Timestamp,
+    mtimeNs: MetadataDomain.Timestamp,
+    ctimeNs: MetadataDomain.Timestamp,
+    birthtimeNs: MetadataDomain.Timestamp
 });
 /** @internal */
 export const OwnerUpdate = Schema.Struct({
@@ -77,12 +91,13 @@ export const OwnerUpdate = Schema.Struct({
 export const TimeUpdate = Schema.Union([
     Schema.Struct({ kind: Schema.Literal("now") }),
     Schema.Struct({ kind: Schema.Literal("omit") }),
-    Schema.Struct({ kind: Schema.Literal("value"), nanoseconds: Timestamp })
+    Schema.Struct({ kind: Schema.Literal("value"), nanoseconds: MetadataDomain.Timestamp })
 ]);
 /** @internal */
 export const Times = Schema.Struct({ access: TimeUpdate, modification: TimeUpdate });
 /** @internal */
 export const SeekMode = Schema.Literals(["start", "current", "end", "data", "hole"]);
+const isSeekMode = Schema.is(SeekMode);
 /** @internal */
 export const OpenSettings = Schema.Struct({
     access: Schema.Literals(["read", "write", "readWrite"]),
@@ -92,12 +107,15 @@ export const OpenSettings = Schema.Struct({
     truncate: Schema.optionalKey(Schema.Boolean),
     followFinalSymlink: Schema.optionalKey(Schema.Boolean)
 });
-/** @internal */
-export const WriteFileSettings = Schema.Struct({
+const WriteFileSettings = Schema.Struct({
     ...OpenSettings.fields,
     replaceFinalSymlink: Schema.optionalKey(Schema.Boolean),
     finalMode: Schema.optionalKey(Mode)
 });
+const decodeOwnerUpdate = Schema.decodeResult(OwnerUpdate, { onExcessProperty: "error" });
+const decodeTimes = Schema.decodeResult(Times, { onExcessProperty: "error" });
+const decodeWriteFileSettings = Schema.decodeResult(WriteFileSettings, { onExcessProperty: "error" });
+const decodeOpenSettings = Schema.decodeResult(OpenSettings, { onExcessProperty: "error" });
 /** @internal */
 export const OverlayNodeKind = Schema.Literals(["directory", "file", "symlink"]);
 /** @internal */
@@ -143,40 +161,46 @@ export const FixtureMetadata = Schema.Struct({
     uid: Schema.optionalKey(Schema.Natural),
     gid: Schema.optionalKey(Schema.Natural),
     mode: Schema.optionalKey(Mode),
-    atimeNs: Schema.optionalKey(Timestamp),
-    mtimeNs: Schema.optionalKey(Timestamp),
-    ctimeNs: Schema.optionalKey(Timestamp),
-    birthtimeNs: Schema.optionalKey(Timestamp)
+    atimeNs: Schema.optionalKey(MetadataDomain.Timestamp),
+    mtimeNs: Schema.optionalKey(MetadataDomain.Timestamp),
+    ctimeNs: Schema.optionalKey(MetadataDomain.Timestamp),
+    birthtimeNs: Schema.optionalKey(MetadataDomain.Timestamp)
 });
 const FixturePath = Schema.Union([
     Schema.String,
     BytePath
 ]);
 /** @internal */
+export const FixtureEntry = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("directory"),
+        path: FixturePath,
+        metadata: Schema.optionalKey(FixtureMetadata)
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("file"),
+        path: FixturePath,
+        bytes: Schema.Uint8Array,
+        metadata: Schema.optionalKey(FixtureMetadata)
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("symlink"),
+        path: FixturePath,
+        target: FixturePath,
+        metadata: Schema.optionalKey(FixtureMetadata)
+    }),
+    Schema.Struct({ kind: Schema.Literal("hardLink"), path: FixturePath, target: FixturePath })
+]).pipe(Schema.toTaggedUnion("kind"));
+/** @internal */
 export const Fixture = Schema.Struct({
     rootMetadata: Schema.optionalKey(FixtureMetadata),
-    entries: Schema.Array(Schema.Union([
-        Schema.Struct({
-            kind: Schema.Literal("directory"),
-            path: FixturePath,
-            metadata: Schema.optionalKey(FixtureMetadata)
-        }),
-        Schema.Struct({
-            kind: Schema.Literal("file"),
-            path: FixturePath,
-            bytes: Schema.Uint8Array,
-            metadata: Schema.optionalKey(FixtureMetadata)
-        }),
-        Schema.Struct({
-            kind: Schema.Literal("symlink"),
-            path: FixturePath,
-            target: FixturePath,
-            metadata: Schema.optionalKey(FixtureMetadata)
-        }),
-        Schema.Struct({ kind: Schema.Literal("hardLink"), path: FixturePath, target: FixturePath })
-    ]))
+    entries: Schema.Array(FixtureEntry)
 });
 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.
+const pathOf = (target) => isFileHandle(target) || isDirectoryHandle(target) ? undefined : target;
+const isDirectoryHandle = (value) => Predicate.hasProperty(DirectoryHandleId)(value);
 const files = new WeakMap();
 const handles = new WeakMap();
 const directoryMetadata = (ino, uid, gid, mode, now) => ({
@@ -196,27 +220,32 @@ const storedMetadata = (metadata) => ({
     uid: metadata.uid,
     gid: metadata.gid,
     mode: metadata.mode,
-    atimeNs: String(metadata.atimeNs),
-    mtimeNs: String(metadata.mtimeNs),
-    ctimeNs: String(metadata.ctimeNs),
-    birthtimeNs: String(metadata.birthtimeNs)
+    atimeNs: metadata.atimeNs,
+    mtimeNs: metadata.mtimeNs,
+    ctimeNs: metadata.ctimeNs,
+    birthtimeNs: metadata.birthtimeNs
 });
+/** @internal */
+export const VolumeSource = Data.taggedEnum();
+const UpdateChange = Schema.TaggedStruct("Update", { path: BytePath });
 // Each execution constructs a fresh volume and captures its Clock.
 /** @internal */
 export const makeVolume = Effect.fnUntraced(function* (source, options) {
-    const image = source._tag === "Empty" ? undefined : source.image;
+    const image = "image" in source ? source.image : undefined;
     const decoded = decodeConfiguration(VolumeOptions, options === undefined ? {} : options);
     if (Result.isFailure(decoded))
         return yield* decoded.failure;
     const settings = { ...decoded.success };
     const clock = yield* Clock.clockWith(Effect.succeed);
     const initialTime = clock.currentTimeNanosUnsafe();
-    if (!Schema.is(Timestamp)(initialTime)) {
+    if (!isTimestamp(initialTime)) {
         return yield* new ConfigurationError({ field: "clock.currentTimeNanos" });
     }
     const timestamp = (operation) => Effect.suspend(() => {
         const now = clock.currentTimeNanosUnsafe();
-        return Schema.is(Timestamp)(now) ? Effect.succeed(now) : Effect.fail(failure("InvalidArgument", operation));
+        return isTimestamp(now)
+            ? Effect.succeed(now)
+            : Effect.fail(new FsError({ code: "InvalidArgument", operation: operation }));
     });
     const volumeIdentity = Symbol();
     const gate = Semaphore.makeUnsafe(1);
@@ -238,16 +267,19 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
     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);
     if (image !== undefined) {
         const incoming = new Map();
         let content = 0n;
         let count = 0;
         for (const record of image.records) {
-            if (record.kind === "directory")
+            if (Image.Record.guards.directory(record))
                 count += record.entries.length;
             else {
-                const length = Image.decodedLength(record.kind === "file" ? record.data : record.target);
-                if (record.kind === "file" && length > maxFileBytes) {
+                const length = CanonicalBase64.decodedLength(Image.Record.guards.file(record) ? record.data : record.target);
+                if (Image.Record.guards.file(record) && length > maxFileBytes) {
                     return yield* new ImageError({ code: "LimitExceeded", field: "maxFileBytes" });
                 }
                 content += BigInt(length);
@@ -257,20 +289,20 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             (settings.maxBytes !== undefined && content > ByteSize.toBigInt(settings.maxBytes))) {
             return yield* new ImageError({ code: "LimitExceeded", field: "volume" });
         }
-        const baseContents = source._tag === "Overlay" ? Content.forOverlay(source.base, image) : undefined;
+        const baseContents = Predicate.isTagged("Overlay")(source) ? Content.forOverlay(source.base, image) : undefined;
         for (const record of image.records) {
             const metadata = {
                 ...record.metadata,
-                kind: record.kind,
+                kind: record._tag,
                 ino: record.id === image.root ? 1n : nextInode++,
-                nlink: record.kind === "directory" ? 2 : 0,
+                nlink: Image.Record.guards.directory(record) ? 2 : 0,
                 size: 0n,
-                atimeNs: BigInt(record.metadata.atimeNs),
-                mtimeNs: BigInt(record.metadata.mtimeNs),
-                ctimeNs: BigInt(record.metadata.ctimeNs),
-                birthtimeNs: BigInt(record.metadata.birthtimeNs)
+                atimeNs: record.metadata.atimeNs,
+                mtimeNs: record.metadata.mtimeNs,
+                ctimeNs: record.metadata.ctimeNs,
+                birthtimeNs: record.metadata.birthtimeNs
             };
-            if (record.kind === "directory") {
+            if (Image.Record.guards.directory(record)) {
                 const node = record.id === image.root
                     ? root
                     : {
@@ -285,8 +317,8 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 node.metadata = metadata;
                 incoming.set(record.id, node);
             }
-            else if (record.kind === "file") {
-                const data = baseContents?.get(record.id) ?? Content.make(Image.bytes(record.data));
+            else if (Image.Record.guards.file(record)) {
+                const data = baseContents?.get(record.id) ?? Content.make(yield* CanonicalBase64.decode(record.data));
                 incoming.set(record.id, {
                     kind: "file",
                     lineage: record.id,
@@ -298,7 +330,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 });
             }
             else {
-                const target = Image.bytes(record.target);
+                const target = yield* CanonicalBase64.decode(record.target);
                 incoming.set(record.id, {
                     kind: "symlink",
                     lineage: record.id,
@@ -310,7 +342,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             }
         }
         for (const record of image.records) {
-            if (record.kind !== "directory")
+            if (!Image.Record.guards.directory(record))
                 continue;
             const parent = incoming.get(record.id);
             if (parent?.kind !== "directory")
@@ -319,7 +351,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 const node = incoming.get(entry.target);
                 if (node === undefined)
                     return yield* new ImageError({ code: "InvalidStructure" });
-                parent.entries.set(Encoding.encodeHex(Image.bytes(entry.name)), node);
+                parent.entries.set(Encoding.encodeHex(yield* CanonicalBase64.decode(entry.name)), node);
                 if (node.kind === "directory") {
                     node.parent = parent;
                     parent.metadata = { ...parent.metadata, nlink: parent.metadata.nlink + 1 };
@@ -343,22 +375,30 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             names.push(found[0]);
             current = parent;
         }
-        return "2f" + names.reverse().join("2f");
+        return SLASH_HEX + names.reverse().join(SLASH_HEX);
     };
     const publishEntry = (_tag, parent, name) => {
         watchHub.publishUnsafe(() => {
             const prefix = directoryHex(parent);
-            return { _tag, path: ownedPath(nameBytes(prefix + (prefix === "2f" ? "" : "2f") + name)) };
+            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.
+        if (target.kind === "directory") {
+            // Removal and rename displacement drop the link count while open handles keep reaching the node.
+            // No name resolves it any more, so its empty parent chain would otherwise read as the root path.
+            // 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))) }));
+            return;
+        }
         watchHub.publishManyUnsafe(() => {
             const changes = [];
-            if (target === root) {
-                changes.push({ _tag: "Update", path: ownedPath(new Uint8Array([47])) });
-            }
-            const pending = [[root, "2f"]];
-            while (pending.length > 0) {
+            const pending = [[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();
                 if (next === undefined)
                     break;
@@ -366,10 +406,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 for (const [name, node] of directory.entries) {
                     const path = prefix + name;
                     if (node === target) {
-                        changes.push({ _tag: "Update", path: ownedPath(nameBytes(path)) });
+                        changes.push(UpdateChange.make({ path: ownedPath(nameBytes(path)) }));
                     }
                     if (node.kind === "directory")
-                        pending.push([node, path + "2f"]);
+                        pending.push([node, path + SLASH_HEX]);
                 }
             }
             return changes;
@@ -380,6 +420,8 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
         const pending = [root];
         const records = [];
         for (let index = 0; index < pending.length; index++) {
+            if (index % WALK_YIELD_INTERVAL === 0)
+                yield* Effect.yieldNow;
             const node = pending[index];
             if (node === undefined)
                 continue;
@@ -396,22 +438,25 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                         ids.set(child, target);
                         pending.push(child);
                     }
-                    children.push({ name: Image.base64(nameBytes(name)), target });
+                    children.push({ name: CanonicalBase64.encode(nameBytes(name)), target });
                 }
-                records.push({ id, kind: "directory", metadata, entries: children });
+                records.push(Image.Record.cases.directory.make({ id, metadata, entries: children }));
             }
             else if (node.kind === "file") {
-                records.push({ id, kind: "file", metadata, data: Image.base64(node.data.bytes) });
+                records.push(Image.Record.cases.file.make({ id, metadata, data: CanonicalBase64.encode(node.data.bytes) }));
+            }
+            else {
+                records.push(Image.Record.cases.symlink.make({ id, metadata, target: CanonicalBase64.encode(node.target) }));
             }
-            else
-                records.push({ id, kind: "symlink", metadata, target: Image.base64(node.target) });
         }
-        return yield* Image.capture({ format: "effect-vfs", version: 1, root: "0", records });
+        return yield* Image.capture({ format: "effect-vfs", version: 1, root: "0", records }, undefined, true);
     });
-    const observeChanges = () => {
+    const observeChanges = Effect.fnUntraced(function* () {
         const observation = [];
-        const paths = [[root, new Uint8Array([47])]];
+        const paths = [[root, new Uint8Array([SLASH_BYTE])]];
         for (let index = 0; index < paths.length; index++) {
+            if (index % WALK_YIELD_INTERVAL === 0)
+                yield* Effect.yieldNow;
             const current = paths[index];
             if (current === undefined)
                 continue;
@@ -431,18 +476,18 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 childPath.set(path);
                 let offset = path.length;
                 if (path.length !== 1)
-                    childPath[offset++] = 47;
+                    childPath[offset++] = SLASH_BYTE;
                 childPath.set(bytes, offset);
                 paths.push([child, childPath]);
             }
         }
         return observation;
-    };
+    });
     const captureState = Effect.fnUntraced(function* (hook) {
         const snapshot = yield* captureSnapshot();
         if (hook !== undefined)
             yield* hook.betweenSnapshotAndSummary;
-        return { snapshot, observation: observeChanges() };
+        return { snapshot, observation: yield* observeChanges() };
     });
     const advanceRevision = (node) => {
         node.revision = nextRevision();
@@ -468,10 +513,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
         reference.directory = undefined;
         reference.closed = true;
     }));
-    const authorize = (directory, identity, bits, operation, path) => {
+    const authorize = (node, identity, bits, operation, path) => {
         if (identity.privileged)
             return Effect.void;
-        const metadata = directory.metadata;
+        const metadata = node.metadata;
         const shift = metadata.uid === identity.uid ?
             6
             : metadata.gid === identity.gid || identity.groups.includes(metadata.gid)
@@ -479,7 +524,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 : 0;
         return ((metadata.mode >> shift) & bits) === bits
             ? Effect.void
-            : Effect.fail(failure("AccessDenied", operation, path));
+            : Effect.fail(path === undefined
+                ? new FsError({ code: "AccessDenied", operation })
+                : new FsError({ code: "AccessDenied", operation, path }));
     };
     const reclaim = (file) => {
         if (file.metadata.nlink === 0 && file.openCount === 0) {
@@ -488,6 +535,19 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             invalidateReference(file);
         }
     };
+    // Whether the volume's entry quota leaves room for one more name.
+    const atEntryLimit = () => settings.maxEntries !== undefined && 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);
+        parent.metadata = {
+            ...parent.metadata,
+            nlink: parent.metadata.nlink + (node.kind === "directory" ? 1 : 0),
+            mtimeNs: now,
+            ctimeNs: now
+        };
+        advanceRevision(parent);
+    };
     const detach = (node, now) => {
         if (node.kind === "directory") {
             node.parent = undefined;
@@ -514,43 +574,47 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
         }
         ref.closed = true;
     };
-    const resize = Effect.fnUntraced(function* (file, length, operation) {
-        if (typeof length !== "bigint" || length < 0n)
-            return yield* failure("InvalidArgument", operation);
-        if (length > BigInt(maxFileBytes))
-            return yield* failure("FileTooLarge", operation);
-        const size = Number(length);
-        if (settings.maxBytes !== undefined &&
-            BigInt(size - file.data.bytes.length) > ByteSize.toBigInt(settings.maxBytes) - usedBytes) {
-            return yield* failure("NoSpace", operation);
-        }
-        const data = new Uint8Array(size);
-        data.set(file.data.bytes.subarray(0, size));
-        const now = yield* timestamp(operation);
-        usedBytes += BigInt(size - file.data.bytes.length);
+    // 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);
         file.data = Content.make(data);
         file.metadata = {
             ...file.metadata,
-            size: length,
-            mode: file.metadata.mode & ~0o6000,
+            size: BigInt(data.length),
+            mode: file.metadata.mode & ~SET_ID_BITS,
             mtimeNs: now,
             ctimeNs: now
         };
         advanceRevision(file);
         publishNode(file);
+    };
+    const resize = Effect.fnUntraced(function* (file, length, operation) {
+        if (!Predicate.isBigInt(length) || length < 0n) {
+            return yield* new FsError({ code: "InvalidArgument", operation: operation });
+        }
+        if (length > BigInt(maxFileBytes))
+            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) {
+            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));
     });
     const fileHandle = (ref) => {
         const get = (operation, access) => ref.file === undefined || (access === "read" && ref.access === "write") ||
             (access === "write" && ref.access === "read")
-            ? Effect.fail(failure("InvalidHandle", operation))
+            ? Effect.fail(new FsError({ code: "InvalidHandle", operation: operation }))
             : Effect.succeed(ref.file);
         const read = Effect.fnUntraced(function* (maximum, position) {
             const file = yield* get(position === undefined ? "read" : "pread", "read");
-            if (!Schema.is(Schema.Natural)(maximum))
-                return yield* failure("InvalidArgument", "read");
+            if (!isNatural(maximum))
+                return yield* new FsError({ code: "InvalidArgument", operation: "read" });
             const offset = position ?? ref.offset;
-            if (typeof offset !== "bigint" || offset < 0n || offset > 0x7fffffffffffffffn) {
-                return yield* failure("InvalidArgument", "read");
+            if (!Predicate.isBigInt(offset) || offset < 0n || offset > MAX_FILE_OFFSET) {
+                return yield* new FsError({ code: "InvalidArgument", operation: "read" });
             }
             const start = Number(offset > file.metadata.size ? file.metadata.size : offset);
             const data = file.data.bytes.slice(start, start + Math.min(maximum, file.data.bytes.length - start));
@@ -562,21 +626,20 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             return data;
         }, coordinated);
         const write = Effect.fnUntraced(function* (input, position) {
-            if (!(input instanceof Uint8Array) || !(input.buffer instanceof ArrayBuffer) || !attachedBuffer(input)) {
-                return yield* failure("InvalidArgument", "write");
-            }
+            if (!isAttachedBytes(input))
+                return yield* new FsError({ code: "InvalidArgument", operation: "write" });
             const bytes = new Uint8Array(input);
             return yield* coordinated(Effect.gen(function* () {
                 const file = yield* get(position === undefined ? "write" : "pwrite", "write");
                 const offset = position ?? (ref.append ? file.metadata.size : ref.offset);
-                if (typeof offset !== "bigint" || offset < 0n || offset > 0x7fffffffffffffffn) {
-                    return yield* failure("InvalidArgument", "write");
+                if (!Predicate.isBigInt(offset) || offset < 0n || offset > MAX_FILE_OFFSET) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "write" });
                 }
                 if (bytes.length === 0) {
                     return 0;
                 }
                 if (offset >= BigInt(maxFileBytes))
-                    return yield* failure("FileTooLarge", "write");
+                    return yield* new FsError({ code: "FileTooLarge", operation: "write" });
                 const start = Number(offset);
                 const free = settings.maxBytes === undefined
                     ? BigInt(maxFileBytes)
@@ -585,7 +648,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 const end = Number(BigInt(maxFileBytes) < maximumEnd ? BigInt(maxFileBytes) : maximumEnd);
                 const count = Math.min(bytes.length, Math.max(0, end - start));
                 if (count === 0)
-                    return yield* failure("NoSpace", "write");
+                    return yield* new FsError({ code: "NoSpace", operation: "write" });
                 const size = Math.max(file.data.bytes.length, start + count);
                 // Always detach before mutation. A same-sized write is the critical
                 // case: the current payload may belong to the base or a prior capture.
@@ -593,17 +656,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 data.set(file.data.bytes);
                 const now = yield* timestamp("write");
                 data.set(bytes.subarray(0, count), start);
-                usedBytes += BigInt(size - file.data.bytes.length);
-                file.data = Content.make(data);
-                file.metadata = {
-                    ...file.metadata,
-                    size: BigInt(size),
-                    mode: file.metadata.mode & ~0o6000,
-                    mtimeNs: now,
-                    ctimeNs: now
-                };
-                advanceRevision(file);
-                publishNode(file);
+                replaceContent(file, data, now);
                 if (position === undefined)
                     ref.offset = offset + BigInt(count);
                 return count;
@@ -626,15 +679,16 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             seek: Effect.fn("FileHandle.seek")(function* (offset, mode) {
                 return yield* coordinated(Effect.gen(function* () {
                     const file = yield* get("seek");
-                    if (typeof offset !== "bigint" || !Schema.is(SeekMode)(mode)) {
-                        return yield* failure("InvalidArgument", "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;
-                    if (next < 0n || next > 0x7fffffffffffffffn)
-                        return yield* failure("InvalidArgument", "seek");
+                    if (next < 0n || next > MAX_FILE_OFFSET) {
+                        return yield* new FsError({ code: "InvalidArgument", operation: "seek" });
+                    }
                     if (mode === "data" || mode === "hole") {
                         if (offset >= file.metadata.size)
-                            return yield* failure("NoData", "seek");
+                            return yield* new FsError({ code: "NoData", operation: "seek" });
                         if (mode === "hole")
                             next = file.metadata.size;
                     }
@@ -662,50 +716,57 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
     const createCaller = (reference, identity, umask) => {
         const referencedNode = Effect.fnUntraced(function* (target, operation) {
             if (reference.directory === undefined)
-                return yield* failure("ClosedCaller", operation);
-            if (typeof target !== "object" || target === null)
-                return yield* failure("InvalidReference", operation);
+                return yield* new FsError({ code: "ClosedCaller", operation: operation });
+            if (!Predicate.isObject(target))
+                return yield* new FsError({ code: "InvalidReference", operation: operation });
             const state = objectReferences.get(target);
             if (state === undefined)
-                return yield* failure("InvalidReference", operation);
-            if (state.volume !== volumeIdentity)
-                return yield* failure("ForeignReference", operation);
+                return yield* new FsError({ code: "InvalidReference", operation: operation });
+            if (state.volume !== volumeIdentity) {
+                return yield* new FsError({ code: "ForeignReference", operation: operation });
+            }
             if (state.node === undefined)
-                return yield* failure("StaleReference", operation);
+                return yield* new FsError({ code: "StaleReference", operation: operation });
             return state.node;
         });
         const lookup = Effect.fnUntraced(function* (path, base, operation, options = {}) {
             const { followFinalSymlink = true, allowMissing = false, parentOnly = false } = options;
-            if (reference.directory === undefined)
-                return yield* failure("ClosedCaller", operation, path.input);
+            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) {
                 const target = handles.get(base);
-                if (target === undefined)
-                    return yield* failure("InvalidHandle", operation, path.input);
-                if (target.volume !== volumeIdentity)
-                    return yield* failure("ForeignHandle", operation, path.input);
-                if (target.directory === undefined)
-                    return yield* failure("InvalidHandle", operation, path.input);
+                if (target === undefined) {
+                    return yield* new FsError({ code: "InvalidHandle", operation: operation, path: path.input });
+                }
+                if (target.volume !== volumeIdentity) {
+                    return yield* new FsError({ code: "ForeignHandle", operation: operation, path: path.input });
+                }
+                if (target.directory === undefined) {
+                    return yield* new FsError({ code: "InvalidHandle", operation: operation, path: path.input });
+                }
                 current = target.directory;
-                yield* authorize(current, identity, 1, operation, path.input);
+                yield* authorize(current, identity, EXECUTE, operation, path.input);
+            }
+            if (current.metadata.nlink === 0) {
+                return yield* new FsError({ code: "NotFound", operation: operation, path: path.input });
             }
-            if (current.metadata.nlink === 0)
-                return yield* failure("NotFound", operation, path.input);
             let work = path;
             let parent;
             let name;
             let traversals = 0;
             for (let index = 0; index < work.components.length - (parentOnly ? 1 : 0); index++) {
-                if (current.kind !== "directory")
-                    return yield* failure("NotDirectory", operation, path.input);
-                yield* authorize(current, identity, 1, operation, path.input);
+                if (current.kind !== "directory") {
+                    return yield* new FsError({ code: "NotDirectory", operation: operation, path: path.input });
+                }
+                yield* authorize(current, identity, EXECUTE, operation, path.input);
                 const component = work.components[index];
                 if (component === undefined)
                     break;
-                if (component === "2e")
+                if (component === DOT_HEX)
                     continue;
-                if (component === "2e2e") {
+                if (component === DOT_DOT_HEX) {
                     current = current.parent ?? current;
                     parent = undefined;
                     name = undefined;
@@ -718,22 +779,30 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     if (allowMissing && index === work.components.length - 1 && !work.trailingSlash) {
                         return { node: undefined, parent, name };
                     }
-                    return yield* failure("NotFound", operation, path.input);
+                    return yield* new FsError({ code: "NotFound", operation: operation, path: path.input });
                 }
                 if (child.kind === "symlink" && (followFinalSymlink || index < work.components.length - 1 || work.trailingSlash)) {
-                    if (child.target.length === 0)
-                        return yield* failure("NotFound", operation, path.input);
-                    if (++traversals > 40)
-                        return yield* failure("SymlinkLoop", operation, path.input);
+                    if (child.target.length === 0) {
+                        return yield* new FsError({ code: "NotFound", operation: operation, path: path.input });
+                    }
+                    if (++traversals > 40) {
+                        return yield* new FsError({ code: "SymlinkLoop", operation: operation, path: path.input });
+                    }
                     const suffix = work.suffixes[index] ?? new Uint8Array(0);
                     if (settings.maxPathBytes !== undefined &&
                         ByteSize.isGreaterThan(ByteSize.bytes(child.target.length + suffix.length), settings.maxPathBytes)) {
-                        return yield* failure("PathTooLong", operation, path.input);
+                        return yield* new FsError({ code: "PathTooLong", operation: operation, path: path.input });
                     }
                     const expansion = new Uint8Array(child.target.length + suffix.length);
                     expansion.set(child.target);
                     expansion.set(suffix, child.target.length);
-                    work = yield* Effect.fromResult(preparePath(ownedPath(expansion), operation, settings.maxPathBytes));
+                    const expanded = preparePath(ownedPath(expansion), operation, settings.maxPathBytes);
+                    // The expansion is synthetic: its per-component limits are the caller's to hear about,
+                    // but the path in the error has to be the one the caller passed in.
+                    if (Result.isFailure(expanded)) {
+                        return yield* new FsError({ code: expanded.failure.code, operation: operation, path: path.input });
+                    }
+                    work = expanded.success;
                     if (work.absolute)
                         current = root;
                     index = -1;
@@ -742,23 +811,26 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     current = child;
             }
             if (!parentOnly && work.trailingSlash && current.kind !== "directory") {
-                return yield* failure("NotDirectory", operation, path.input);
+                return yield* new FsError({ code: "NotDirectory", operation: operation, path: path.input });
             }
             return { node: current, parent, name };
         });
         const resolveNode = Effect.fnUntraced(function* (path, base, operation, options) {
             const result = yield* lookup(path, base, operation, options);
-            if (result.node === undefined)
-                return yield* failure("NotFound", operation, path.input);
+            if (result.node === undefined) {
+                return yield* new FsError({ code: "NotFound", operation: operation, path: path.input });
+            }
             return result.node;
         });
         const locate = Effect.fnUntraced(function* (path, base, operation, options) {
             const result = yield* lookup(path, base, operation, options);
             const node = result.node;
-            if (node === undefined)
-                return yield* failure("NotFound", operation, path.input);
-            if (node.kind !== "directory")
-                return yield* failure("NotDirectory", operation, path.input);
+            if (node === undefined) {
+                return yield* new FsError({ code: "NotFound", operation: operation, path: path.input });
+            }
+            if (node.kind !== "directory") {
+                return yield* new FsError({ code: "NotDirectory", operation: operation, path: path.input });
+            }
             return node;
         });
         const acquireDirectory = Effect.fnUntraced(function* (input, options, operation) {
@@ -773,7 +845,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     return yield* Effect.interrupt;
                 const path = yield* Effect.fromResult(prepared);
                 const directory = yield* locate(path, base, operation);
-                yield* authorize(directory, identity, 1, operation, input);
+                yield* authorize(directory, identity, EXECUTE, operation, input);
                 acquired.directory = directory;
                 return acquired;
             }));
@@ -783,7 +855,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             const base = options?.relativeTo;
             return yield* coordinated(Effect.gen(function* () {
                 const directory = yield* locate(yield* Effect.fromResult(prepared), base, "readDirectory");
-                yield* authorize(directory, identity, 4, "readDirectory", input);
+                yield* authorize(directory, identity, READ, "readDirectory", input);
                 const result = [...directory.entries.keys()].map(nameBytes);
                 directory.metadata = { ...directory.metadata, atimeNs: (yield* timestamp("readDirectory")) };
                 return result;
@@ -796,8 +868,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 const node = yield* resolveNode(yield* Effect.fromResult(prepared), base, "readLink", {
                     followFinalSymlink: false
                 });
-                if (node.kind !== "symlink")
-                    return yield* failure("InvalidArgument", "readLink", input);
+                if (node.kind !== "symlink") {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "readLink", path: input });
+                }
                 return new Uint8Array(node.target);
             }));
         });
@@ -814,25 +887,27 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     const parent = directory.parent;
                     const entry = [...parent.entries].find(([, child]) => child === directory);
                     if (entry === undefined)
-                        return yield* failure("NotFound", "realPath", input);
+                        return yield* new FsError({ code: "NotFound", operation: "realPath", path: input });
                     components.push(entry[0]);
                     directory = parent;
                 }
-                return nameBytes("2f" + components.reverse().join("2f"));
+                return nameBytes(SLASH_HEX + components.reverse().join(SLASH_HEX));
             }));
         });
         const metadataNode = Effect.fnUntraced(function* (target, options, operation) {
-            if (reference.directory === undefined)
-                return yield* failure("ClosedCaller", operation);
-            if (typeof target === "object" && target !== null && (FileHandleId in target || DirectoryHandleId in target)) {
-                const ref = FileHandleId in target ? files.get(target) : handles.get(target);
+            if (reference.directory === undefined) {
+                return yield* new FsError({ code: "ClosedCaller", operation: operation });
+            }
+            if (isFileHandle(target) || isDirectoryHandle(target)) {
+                const ref = isFileHandle(target) ? files.get(target) : handles.get(target);
                 if (ref === undefined)
-                    return yield* failure("InvalidHandle", operation);
-                if (ref.volume !== volumeIdentity)
-                    return yield* failure("ForeignHandle", operation);
+                    return yield* new FsError({ code: "InvalidHandle", operation: operation });
+                if (ref.volume !== volumeIdentity) {
+                    return yield* new FsError({ code: "ForeignHandle", operation: operation });
+                }
                 const node = "file" in ref ? ref.file : ref.directory;
                 if (node === undefined)
-                    return yield* failure("InvalidHandle", operation);
+                    return yield* new FsError({ code: "InvalidHandle", operation: operation });
                 return node;
             }
             const path = yield* Effect.fromResult(preparePath(target, operation, settings.maxPathBytes));
@@ -842,14 +917,16 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
         });
         const permittedMode = (metadata, mode, operation, path) => {
             if (!identity.privileged && identity.uid !== metadata.uid) {
-                return Effect.fail(failure("AccessDenied", operation, path));
+                return Effect.fail(path === undefined
+                    ? new FsError({ code: "AccessDenied", operation })
+                    : new FsError({ code: "AccessDenied", operation, path }));
             }
             const group = identity.gid === metadata.gid || identity.groups.includes(metadata.gid);
             return Effect.succeed(!identity.privileged && metadata.kind === "file" && !group ? mode & ~0o2000 : mode);
         };
         const changeMode = Effect.fnUntraced(function* (target, mode, options) {
-            if (!Schema.is(Mode)(mode))
-                return yield* failure("InvalidArgument", "chmod");
+            if (!isMode(mode))
+                return yield* new FsError({ code: "InvalidArgument", operation: "chmod" });
             const chosen = options === undefined ? undefined : { ...options };
             return yield* coordinated(Effect.gen(function* () {
                 const node = yield* metadataNode(target, chosen, "chmod");
@@ -864,9 +941,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             }));
         });
         const changeOwner = Effect.fnUntraced(function* (target, owner, options) {
-            const decoded = Schema.decodeResult(OwnerUpdate, { onExcessProperty: "error" })(owner);
+            const decoded = decodeOwnerUpdate(owner);
             if (Result.isFailure(decoded))
-                return yield* failure("InvalidArgument", "chown");
+                return yield* new FsError({ code: "InvalidArgument", operation: "chown" });
             const update = { ...decoded.success };
             const chosen = options === undefined ? undefined : { ...options };
             return yield* coordinated(Effect.gen(function* () {
@@ -874,7 +951,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 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* failure("AccessDenied", "chown");
+                    return yield* new FsError({ code: "AccessDenied", operation: "chown" });
                 }
                 if (update.uid === undefined && update.gid === undefined)
                     return;
@@ -882,7 +959,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     ...node.metadata,
                     uid: update.uid ?? node.metadata.uid,
                     gid: update.gid ?? node.metadata.gid,
-                    mode: node.kind === "file" ? node.metadata.mode & ~0o6000 : node.metadata.mode,
+                    mode: node.kind === "file" ? node.metadata.mode & ~SET_ID_BITS : node.metadata.mode,
                     ctimeNs: (yield* timestamp("chown"))
                 };
                 advanceRevision(node);
@@ -890,9 +967,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             }));
         });
         const changeTimes = Effect.fnUntraced(function* (target, times, options) {
-            const decoded = Schema.decodeResult(Times, { onExcessProperty: "error" })(times);
+            const decoded = decodeTimes(times);
             if (Result.isFailure(decoded))
-                return yield* failure("InvalidArgument", "utimes");
+                return yield* new FsError({ code: "InvalidArgument", operation: "utimes" });
             const access = { ...decoded.success.access };
             const modification = { ...decoded.success.modification };
             const chosen = options === undefined ? undefined : { ...options };
@@ -900,10 +977,16 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 const node = yield* metadataNode(target, chosen, "utimes");
                 if (access.kind === "omit" && modification.kind === "omit")
                     return;
+                // POSIX grants write access only when both times are UTIME_NOW; both UTIME_OMIT
+                // returned above. Every other combination, mixed ones included, needs ownership.
                 if (!identity.privileged && identity.uid !== node.metadata.uid) {
-                    if (access.kind !== "now" || modification.kind !== "now")
-                        return yield* failure("AccessDenied", "utimes");
-                    yield* authorize(node, identity, 2, "utimes", "/");
+                    if (access.kind !== "now" || modification.kind !== "now") {
+                        const path = pathOf(target);
+                        return yield* path === undefined
+                            ? new FsError({ code: "AccessDenied", operation: "utimes" })
+                            : new FsError({ code: "AccessDenied", operation: "utimes", path });
+                    }
+                    yield* authorize(node, identity, WRITE, "utimes", pathOf(target));
                 }
                 const now = yield* timestamp("utimes");
                 node.metadata = {
@@ -924,41 +1007,44 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 publishNode(node);
             }));
         });
-        const authorizeRemoval = (parent, child, operation, input) => (parent.metadata.mode & 0o1000) !== 0 && !identity.privileged &&
+        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(failure("AccessDenied", operation, input))
+            ? Effect.fail(new FsError({ code: "AccessDenied", operation: operation, path: input }))
             : Effect.void;
         return Object.freeze({
             [CallerId]: true,
             rootReference: coordinated(Effect.gen(function* () {
-                if (reference.directory === undefined)
-                    return yield* failure("ClosedCaller", "rootReference");
+                if (reference.directory === undefined) {
+                    return yield* new FsError({ code: "ClosedCaller", operation: "rootReference" });
+                }
                 return referenceFor(root);
             })).pipe(Effect.withSpan("Caller.rootReference")),
             lookupReference: Effect.fn("Caller.lookupReference")(function* (directoryReference, name) {
-                if (!(name instanceof Uint8Array) || !(name.buffer instanceof ArrayBuffer) || !attachedBuffer(name) ||
-                    name.length === 0 || name.length > 255 || name.includes(0) || name.includes(47))
-                    return yield* failure("InvalidArgument", "lookupReference");
+                if (!isAttachedBytes(name) || name.length === 0 || name.length > MAX_NAME_BYTES || name.includes(0) ||
+                    name.includes(SLASH_BYTE))
+                    return yield* new FsError({ code: "InvalidArgument", operation: "lookupReference" });
                 const key = Encoding.encodeHex(new Uint8Array(name));
-                if (key === "2e" || key === "2e2e")
-                    return yield* failure("InvalidArgument", "lookupReference");
+                if (isDotComponent(key))
+                    return yield* new FsError({ code: "InvalidArgument", operation: "lookupReference" });
                 return yield* coordinated(Effect.gen(function* () {
                     const directory = yield* referencedNode(directoryReference, "lookupReference");
-                    if (directory.kind !== "directory")
-                        return yield* failure("NotDirectory", "lookupReference");
-                    yield* authorize(directory, identity, 1, "lookupReference", "/");
+                    if (directory.kind !== "directory") {
+                        return yield* new FsError({ code: "NotDirectory", operation: "lookupReference" });
+                    }
+                    yield* authorize(directory, identity, EXECUTE, "lookupReference", "/");
                     const child = directory.entries.get(key);
                     if (child === undefined)
-                        return yield* failure("NotFound", "lookupReference");
+                        return yield* new FsError({ code: "NotFound", operation: "lookupReference" });
                     return referenceFor(child);
                 }));
             }),
             parentReference: Effect.fn("Caller.parentReference")(function* (directoryReference) {
                 return yield* coordinated(Effect.gen(function* () {
                     const directory = yield* referencedNode(directoryReference, "parentReference");
-                    if (directory.kind !== "directory")
-                        return yield* failure("NotDirectory", "parentReference");
-                    yield* authorize(directory, identity, 1, "parentReference", "/");
+                    if (directory.kind !== "directory") {
+                        return yield* new FsError({ code: "NotDirectory", operation: "parentReference" });
+                    }
+                    yield* authorize(directory, identity, EXECUTE, "parentReference", "/");
                     return referenceFor(directory.parent ?? directory);
                 }));
             }),
@@ -971,9 +1057,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             observeDirectory: Effect.fn("Caller.observeDirectory")(function* (directoryReference) {
                 return yield* coordinated(Effect.gen(function* () {
                     const directory = yield* referencedNode(directoryReference, "observeDirectory");
-                    if (directory.kind !== "directory")
-                        return yield* failure("NotDirectory", "observeDirectory");
-                    yield* authorize(directory, identity, 4, "observeDirectory", "/");
+                    if (directory.kind !== "directory") {
+                        return yield* new FsError({ code: "NotDirectory", operation: "observeDirectory" });
+                    }
+                    yield* authorize(directory, identity, READ, "observeDirectory", "/");
                     const value = Object.freeze([...directory.entries].map(([name, node]) => Object.freeze({ name: nameBytes(name), reference: referenceFor(node) })));
                     return Object.freeze({ value, revision: directory.revision });
                 }));
@@ -981,8 +1068,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             readLinkReference: Effect.fn("Caller.readLinkReference")(function* (objectReference) {
                 return yield* coordinated(Effect.gen(function* () {
                     const node = yield* referencedNode(objectReference, "readLinkReference");
-                    if (node.kind !== "symlink")
-                        return yield* failure("InvalidArgument", "readLinkReference");
+                    if (node.kind !== "symlink") {
+                        return yield* new FsError({ code: "InvalidArgument", operation: "readLinkReference" });
+                    }
                     return new Uint8Array(node.target);
                 }));
             }),
@@ -1001,10 +1089,11 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                         return yield* Effect.interrupt;
                     const node = yield* referencedNode(objectReference, "openReference");
                     if (node.kind !== "file")
-                        return yield* failure("IsDirectory", "openReference");
-                    if (node.metadata.nlink === 0)
-                        return yield* failure("StaleReference", "openReference");
-                    yield* authorize(node, identity, 4, "openReference", "/");
+                        return yield* new FsError({ code: "IsDirectory", operation: "openReference" });
+                    if (node.metadata.nlink === 0) {
+                        return yield* new FsError({ code: "StaleReference", operation: "openReference" });
+                    }
+                    yield* authorize(node, identity, READ, "openReference", "/");
                     node.openCount += 1;
                     acquired.file = node;
                     return fileHandle(acquired);
@@ -1015,9 +1104,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 const base = options?.relativeTo;
                 return yield* coordinated(Effect.gen(function* () {
                     const node = yield* resolveNode(yield* Effect.fromResult(prepared), base, "readFile");
-                    if (node.kind !== "file")
-                        return yield* failure("IsDirectory", "readFile", input);
-                    yield* authorize(node, identity, 4, "readFile", input);
+                    if (node.kind !== "file") {
+                        return yield* new FsError({ code: "IsDirectory", operation: "readFile", path: input });
+                    }
+                    yield* authorize(node, identity, READ, "readFile", input);
                     const data = new Uint8Array(node.data.bytes);
                     node.metadata = { ...node.metadata, atimeNs: (yield* timestamp("readFile")) };
                     return data;
@@ -1025,21 +1115,23 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             }),
             writeFile: Effect.fn("Caller.writeFile")(function* (input, bytes, options) {
                 const prepared = preparePath(input, "writeFile", settings.maxPathBytes);
-                if (!(bytes instanceof Uint8Array) || !(bytes.buffer instanceof ArrayBuffer) || !attachedBuffer(bytes)) {
-                    return yield* failure("InvalidArgument", "writeFile", input);
+                if (!isAttachedBytes(bytes)) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "writeFile", path: input });
                 }
                 const captured = new Uint8Array(bytes);
                 const { relativeTo: base, ...raw } = options;
-                const decoded = Schema.decodeResult(WriteFileSettings, { onExcessProperty: "error" })(raw);
-                if (Result.isFailure(decoded))
-                    return yield* failure("InvalidArgument", "writeFile", input);
+                const decoded = decodeWriteFileSettings(raw);
+                if (Result.isFailure(decoded)) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "writeFile", path: input });
+                }
                 const chosen = decoded.success;
                 return yield* coordinated(Effect.gen(function* () {
                     const path = yield* Effect.fromResult(prepared);
                     if (chosen.create === "exclusive") {
                         const exists = yield* Effect.result(lookup(path, base, "writeFile", { followFinalSymlink: false }));
-                        if (Result.isSuccess(exists))
-                            return yield* failure("AlreadyExists", "writeFile", input);
+                        if (Result.isSuccess(exists)) {
+                            return yield* new FsError({ code: "AlreadyExists", operation: "writeFile", path: input });
+                        }
                         if (exists.failure.code !== "NotFound")
                             return yield* exists.failure;
                     }
@@ -1049,36 +1141,39 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     });
                     const { name, parent } = resolved;
                     if (parent === undefined || name === undefined || resolved.node?.kind === "directory") {
-                        return yield* failure("IsDirectory", "writeFile", input);
+                        return yield* new FsError({ code: "IsDirectory", operation: "writeFile", path: input });
                     }
                     const replaced = resolved.node?.kind === "symlink" ? resolved.node : undefined;
                     if (replaced !== undefined && !chosen.replaceFinalSymlink) {
-                        return yield* failure("SymlinkLoop", "writeFile", input);
+                        return yield* new FsError({ code: "SymlinkLoop", operation: "writeFile", path: input });
+                    }
+                    if (chosen.access === "read") {
+                        return yield* new FsError({ code: "InvalidHandle", operation: "writeFile", path: input });
                     }
-                    if (chosen.access === "read")
-                        return yield* failure("InvalidHandle", "writeFile", input);
                     const file = resolved.node?.kind === "file" ? resolved.node : undefined;
                     if (file === undefined) {
-                        yield* authorize(parent, identity, 3, "writeFile", input);
+                        yield* authorize(parent, identity, WRITE | EXECUTE, "writeFile", input);
                         if (replaced !== undefined)
                             yield* authorizeRemoval(parent, replaced, "writeFile", input);
-                        if (replaced === undefined && settings.maxEntries !== undefined && entries >= settings.maxEntries) {
-                            return yield* failure("NoSpace", "writeFile", input);
+                        if (replaced === undefined && atEntryLimit()) {
+                            return yield* new FsError({ code: "NoSpace", operation: "writeFile", path: input });
                         }
                     }
-                    else
-                        yield* authorize(file, identity, chosen.access === "readWrite" ? 6 : 2, "writeFile", input);
+                    else {
+                        yield* authorize(file, identity, chosen.access === "readWrite" ? READ | WRITE : WRITE, "writeFile", input);
+                    }
                     const finalMode = chosen.finalMode === undefined ? undefined : yield* permittedMode(file?.metadata ?? { kind: "file", uid: identity.uid, gid: parent.metadata.gid }, chosen.finalMode, "writeFile", input);
                     const previous = file?.data.bytes.length ?? 0;
                     const initial = chosen.truncate ? 0 : previous;
                     const position = chosen.append ? initial : 0;
                     const size = Math.max(initial, position + captured.length);
-                    if (size > maxFileBytes)
-                        return yield* failure("FileTooLarge", "writeFile", input);
+                    if (size > maxFileBytes) {
+                        return yield* new FsError({ code: "FileTooLarge", operation: "writeFile", path: input });
+                    }
                     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)) {
-                        return yield* failure("NoSpace", "writeFile", input);
+                        return yield* new FsError({ code: "NoSpace", operation: "writeFile", path: input });
                     }
                     if (file !== undefined && !chosen.truncate && captured.length === 0 && chosen.finalMode === undefined) {
                         return;
@@ -1095,7 +1190,8 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                         {
                             kind: "file",
                             lineage: undefined,
-                            data: Content.make(data),
+                            // Assigned below on the shared path that also covers an existing file.
+                            data: Content.empty(),
                             openCount: 0,
                             metadata: {
                                 ...directoryMetadata(nextInode++, identity.uid, parent.metadata.gid, (chosen.mode ?? 0o666) & 0o777 & ~umask, now),
@@ -1108,7 +1204,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     node.data = Content.make(data);
                     node.metadata = {
                         ...node.metadata,
-                        mode: finalMode ?? node.metadata.mode & ~0o6000,
+                        mode: finalMode ?? node.metadata.mode & ~SET_ID_BITS,
                         size: BigInt(size),
                         mtimeNs: now,
                         ctimeNs: now
@@ -1118,9 +1214,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     if (file === undefined) {
                         if (replaced !== undefined)
                             detach(replaced, now);
-                        parent.entries.set(name, node);
-                        parent.metadata = { ...parent.metadata, mtimeNs: now, ctimeNs: now };
-                        advanceRevision(parent);
+                        attach(parent, name, node, now);
                         if (replaced === undefined)
                             entries += 1;
                         publishEntry(replaced === undefined ? "Create" : "Update", parent, name);
@@ -1150,12 +1244,13 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             access: Effect.fn("Caller.access")(function* (input, bits = 0, options) {
                 const prepared = preparePath(input, "access", settings.maxPathBytes);
                 const base = options?.relativeTo;
-                if (!Number.isInteger(bits) || bits < 0 || bits > 7)
-                    return yield* failure("InvalidArgument", "access", input);
+                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* () {
                     const node = yield* resolveNode(yield* Effect.fromResult(prepared), base, "access");
-                    if (node.kind === "file" && (bits & 1) !== 0 && (node.metadata.mode & 0o111) === 0) {
-                        return yield* failure("AccessDenied", "access", input);
+                    if (node.kind === "file" && (bits & EXECUTE) !== 0 && (node.metadata.mode & ANY_EXECUTE) === 0) {
+                        return yield* new FsError({ code: "AccessDenied", operation: "access", path: input });
                     }
                     yield* authorize(node, identity, bits, "access", input);
                 }));
@@ -1165,9 +1260,10 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 const base = options?.relativeTo;
                 return yield* coordinated(Effect.gen(function* () {
                     const node = yield* resolveNode(yield* Effect.fromResult(prepared), base, "truncate");
-                    if (node.kind !== "file")
-                        return yield* failure("IsDirectory", "truncate", input);
-                    yield* authorize(node, identity, 2, "truncate", input);
+                    if (node.kind !== "file") {
+                        return yield* new FsError({ code: "IsDirectory", operation: "truncate", path: input });
+                    }
+                    yield* authorize(node, identity, WRITE, "truncate", input);
                     yield* resize(node, length, "truncate");
                 }));
             }),
@@ -1191,25 +1287,25 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     const node = yield* resolveNode(yield* Effect.fromResult(a), sourceBase, "link", {
                         followFinalSymlink: follow
                     });
-                    if (node.kind === "directory")
-                        return yield* failure("IsDirectory", "link", source);
+                    if (node.kind === "directory") {
+                        return yield* new FsError({ code: "IsDirectory", operation: "link", path: source });
+                    }
                     const path = yield* Effect.fromResult(b);
                     const parent = yield* locate(path, destinationBase, "link", { parentOnly: true });
-                    yield* authorize(parent, identity, 3, "link", destination);
+                    yield* authorize(parent, identity, WRITE | EXECUTE, "link", destination);
                     const name = path.components.at(-1);
-                    if (name === undefined || name === "2e" || name === "2e2e" || parent.entries.has(name)) {
-                        return yield* failure("AlreadyExists", "link", destination);
+                    if (isDotComponent(name) || parent.entries.has(name)) {
+                        return yield* new FsError({ code: "AlreadyExists", operation: "link", path: destination });
+                    }
+                    if (path.trailingSlash) {
+                        return yield* new FsError({ code: "NotDirectory", operation: "link", path: destination });
                     }
-                    if (path.trailingSlash)
-                        return yield* failure("NotDirectory", "link", destination);
-                    if (settings.maxEntries !== undefined && entries >= settings.maxEntries) {
-                        return yield* failure("NoSpace", "link", destination);
+                    if (atEntryLimit()) {
+                        return yield* new FsError({ code: "NoSpace", operation: "link", path: destination });
                     }
                     const now = yield* timestamp("link");
-                    parent.entries.set(name, node);
-                    parent.metadata = { ...parent.metadata, mtimeNs: now, ctimeNs: now };
+                    attach(parent, name, node, now);
                     node.metadata = { ...node.metadata, nlink: node.metadata.nlink + 1, ctimeNs: now };
-                    advanceRevision(parent);
                     advanceRevision(node);
                     entries += 1;
                     publishEntry("Create", parent, name);
@@ -1217,30 +1313,31 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             }),
             symlink: Effect.fn("Caller.symlink")(function* (target, input, options) {
                 const prepared = preparePath(input, "symlink", settings.maxPathBytes);
-                if (typeof target === "string" && !wellFormed(target)) {
-                    return yield* failure("InvalidPathEncoding", "symlink", target);
+                const rawTarget = inputBytes(target);
+                if (Result.isFailure(rawTarget)) {
+                    return yield* new FsError({ code: rawTarget.failure, operation: "symlink", path: target });
                 }
-                const rawTarget = typeof target === "string" ? new TextEncoder().encode(target) : getBytePathBytes(target);
-                if (rawTarget === undefined || rawTarget.includes(0)) {
-                    return yield* failure("InvalidArgument", "symlink", target);
+                if (rawTarget.success.includes(0)) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "symlink", path: target });
                 }
-                const targetBytes = new Uint8Array(rawTarget);
+                const targetBytes = new Uint8Array(rawTarget.success);
                 const base = options?.relativeTo;
                 return yield* coordinated(Effect.gen(function* () {
                     const path = yield* Effect.fromResult(prepared);
                     const bytes = targetBytes;
                     const parent = yield* locate(path, base, "symlink", { parentOnly: true });
-                    yield* authorize(parent, identity, 3, "symlink", input);
+                    yield* authorize(parent, identity, WRITE | EXECUTE, "symlink", input);
                     const name = path.components.at(-1);
-                    if (name === undefined || name === "2e" || name === "2e2e" || parent.entries.has(name)) {
-                        return yield* failure("AlreadyExists", "symlink", input);
+                    if (isDotComponent(name) || parent.entries.has(name)) {
+                        return yield* new FsError({ code: "AlreadyExists", operation: "symlink", path: input });
+                    }
+                    if (path.trailingSlash) {
+                        return yield* new FsError({ code: "NotDirectory", operation: "symlink", path: input });
                     }
-                    if (path.trailingSlash)
-                        return yield* failure("NotDirectory", "symlink", input);
-                    if ((settings.maxEntries !== undefined && entries >= settings.maxEntries) ||
+                    if (atEntryLimit() ||
                         (settings.maxBytes !== undefined &&
                             BigInt(bytes.length) > ByteSize.toBigInt(settings.maxBytes) - usedBytes))
-                        return yield* failure("NoSpace", "symlink", input);
+                        return yield* new FsError({ code: "NoSpace", operation: "symlink", path: input });
                     const now = yield* timestamp("symlink");
                     const node = {
                         kind: "symlink",
@@ -1255,9 +1352,7 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                         revision: nextRevision(),
                         objectReference: undefined
                     };
-                    parent.entries.set(name, node);
-                    parent.metadata = { ...parent.metadata, mtimeNs: now, ctimeNs: now };
-                    advanceRevision(parent);
+                    attach(parent, name, node, now);
                     nextInode += 1n;
                     entries += 1;
                     usedBytes += BigInt(bytes.length);
@@ -1285,15 +1380,16 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             open: Effect.fn("Caller.open")(function* (input, options) {
                 const prepared = preparePath(input, "open", settings.maxPathBytes);
                 const { relativeTo: base, ...raw } = options;
-                const decoded = Schema.decodeResult(OpenSettings, { onExcessProperty: "error" })(raw);
-                if (Result.isFailure(decoded))
-                    return yield* failure("InvalidArgument", "open", input);
+                const decoded = decodeOpenSettings(raw);
+                if (Result.isFailure(decoded)) {
+                    return yield* new FsError({ code: "InvalidArgument", operation: "open", path: input });
+                }
                 const chosen = { ...decoded.success };
                 if (chosen.access === "read" && (chosen.append || chosen.truncate)) {
-                    return yield* failure("InvalidArgument", "open", input);
+                    return yield* new FsError({ code: "InvalidArgument", operation: "open", path: input });
                 }
                 if (chosen.mode !== undefined && (chosen.create === undefined || chosen.create === "never")) {
-                    return yield* failure("InvalidArgument", "open", input);
+                    return yield* new FsError({ code: "InvalidArgument", operation: "open", path: input });
                 }
                 const acquired = {
                     volume: volumeIdentity,
@@ -1310,8 +1406,9 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     const path = yield* Effect.fromResult(prepared);
                     if (chosen.create === "exclusive") {
                         const existing = yield* Effect.result(lookup(path, base, "open", { followFinalSymlink: false }));
-                        if (Result.isSuccess(existing))
-                            return yield* failure("AlreadyExists", "open", input);
+                        if (Result.isSuccess(existing)) {
+                            return yield* new FsError({ code: "AlreadyExists", operation: "open", path: input });
+                        }
                         if (existing.failure.code !== "NotFound")
                             return yield* existing.failure;
                     }
@@ -1321,23 +1418,23 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     });
                     const parent = resolved.parent;
                     if (parent === undefined)
-                        return yield* failure("IsDirectory", "open", input);
+                        return yield* new FsError({ code: "IsDirectory", operation: "open", path: input });
                     const name = resolved.name;
-                    if (name === undefined || name === "2e" || name === "2e2e") {
-                        return yield* failure("IsDirectory", "open", input);
+                    if (isDotComponent(name)) {
+                        return yield* new FsError({ code: "IsDirectory", operation: "open", path: input });
                     }
-                    yield* authorize(parent, identity, 1, "open", input);
+                    yield* authorize(parent, identity, EXECUTE, "open", input);
                     let file = resolved.node;
                     if (file !== undefined && chosen.create === "exclusive") {
-                        return yield* failure("AlreadyExists", "open", input);
+                        return yield* new FsError({ code: "AlreadyExists", operation: "open", path: input });
                     }
                     if (file === undefined) {
                         if (chosen.create === undefined || chosen.create === "never" || path.trailingSlash) {
-                            return yield* failure("NotFound", "open", input);
+                            return yield* new FsError({ code: "NotFound", operation: "open", path: input });
                         }
-                        yield* authorize(parent, identity, 3, "open", input);
-                        if (settings.maxEntries !== undefined && entries >= settings.maxEntries) {
-                            return yield* failure("NoSpace", "open", input);
+                        yield* authorize(parent, identity, WRITE | EXECUTE, "open", input);
+                        if (atEntryLimit()) {
+                            return yield* new FsError({ code: "NoSpace", operation: "open", path: input });
                         }
                         const now = yield* timestamp("open");
                         file = {
@@ -1353,21 +1450,22 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                             revision: nextRevision(),
                             objectReference: undefined
                         };
-                        parent.entries.set(name, file);
-                        parent.metadata = { ...parent.metadata, mtimeNs: now, ctimeNs: now };
-                        advanceRevision(parent);
+                        attach(parent, name, file, now);
                         entries += 1;
                         nextInode += 1n;
                         publishEntry("Create", parent, name);
                     }
                     else {
-                        if (file.kind === "symlink")
-                            return yield* failure("SymlinkLoop", "open", input);
-                        if (file.kind !== "file")
-                            return yield* failure("IsDirectory", "open", input);
-                        if (path.trailingSlash)
-                            return yield* failure("NotDirectory", "open", input);
-                        yield* authorize(file, identity, chosen.access === "read" ? 4 : chosen.access === "write" ? 2 : 6, "open", input);
+                        if (file.kind === "symlink") {
+                            return yield* new FsError({ code: "SymlinkLoop", operation: "open", path: input });
+                        }
+                        if (file.kind !== "file") {
+                            return yield* new FsError({ code: "IsDirectory", operation: "open", path: input });
+                        }
+                        if (path.trailingSlash) {
+                            return yield* new FsError({ code: "NotDirectory", operation: "open", path: input });
+                        }
+                        yield* authorize(file, identity, chosen.access === "read" ? READ : chosen.access === "write" ? WRITE : READ | WRITE, "open", input);
                         if (chosen.truncate)
                             yield* resize(file, 0n, "open");
                     }
@@ -1382,18 +1480,20 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 return yield* coordinated(Effect.gen(function* () {
                     const path = yield* Effect.fromResult(prepared);
                     const parent = yield* locate(path, base, "unlink", { parentOnly: true });
-                    yield* authorize(parent, identity, 3, "unlink", input);
+                    yield* authorize(parent, identity, WRITE | EXECUTE, "unlink", input);
                     const name = path.components.at(-1);
-                    if (name === undefined || name === "2e" || name === "2e2e") {
-                        return yield* failure("IsDirectory", "unlink", input);
+                    if (isDotComponent(name)) {
+                        return yield* new FsError({ code: "IsDirectory", operation: "unlink", path: input });
                     }
                     const child = parent.entries.get(name);
                     if (child === undefined)
-                        return yield* failure("NotFound", "unlink", input);
-                    if (child.kind === "directory")
-                        return yield* failure("IsDirectory", "unlink", input);
-                    if (path.trailingSlash)
-                        return yield* failure("NotDirectory", "unlink", input);
+                        return yield* new FsError({ code: "NotFound", operation: "unlink", path: input });
+                    if (child.kind === "directory") {
+                        return yield* new FsError({ code: "IsDirectory", operation: "unlink", path: input });
+                    }
+                    if (path.trailingSlash) {
+                        return yield* new FsError({ code: "NotDirectory", operation: "unlink", path: input });
+                    }
                     yield* authorizeRemoval(parent, child, "unlink", input);
                     const now = yield* timestamp("unlink");
                     parent.entries.delete(name);
@@ -1414,26 +1514,25 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     const newPath = yield* Effect.fromResult(newPrepared);
                     const oldParent = yield* locate(oldPath, oldBase, "rename", { parentOnly: true });
                     const newParent = yield* locate(newPath, newBase, "rename", { parentOnly: true });
-                    yield* authorize(oldParent, identity, 3, "rename", source);
-                    yield* authorize(newParent, identity, 3, "rename", destination);
+                    yield* authorize(oldParent, identity, WRITE | EXECUTE, "rename", source);
+                    yield* authorize(newParent, identity, WRITE | EXECUTE, "rename", destination);
                     const oldName = oldPath.components.at(-1);
                     const newName = newPath.components.at(-1);
-                    if (oldName === undefined || newName === undefined || oldName === "2e" || oldName === "2e2e" ||
-                        newName === "2e" || newName === "2e2e") {
-                        return yield* failure("InvalidArgument", "rename", source);
+                    if (isDotComponent(oldName) || isDotComponent(newName)) {
+                        return yield* new FsError({ code: "InvalidArgument", operation: "rename", path: source });
                     }
                     const child = oldParent.entries.get(oldName);
                     if (child === undefined)
-                        return yield* failure("NotFound", "rename", source);
+                        return yield* new FsError({ code: "NotFound", operation: "rename", path: source });
                     const replaced = newParent.entries.get(newName);
                     if (newPath.trailingSlash && replaced === undefined) {
-                        return yield* failure("NotFound", "rename", destination);
+                        return yield* new FsError({ code: "NotFound", operation: "rename", path: destination });
                     }
                     if (oldPath.trailingSlash && child.kind !== "directory") {
-                        return yield* failure("NotDirectory", "rename", source);
+                        return yield* new FsError({ code: "NotDirectory", operation: "rename", path: source });
                     }
                     if (newPath.trailingSlash && replaced?.kind !== "directory") {
-                        return yield* failure("NotDirectory", "rename", destination);
+                        return yield* new FsError({ code: "NotDirectory", operation: "rename", path: destination });
                     }
                     if (child === replaced)
                         return;
@@ -1441,22 +1540,23 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                     if (replaced !== undefined) {
                         yield* authorizeRemoval(newParent, replaced, "rename", destination);
                         if (child.kind === "directory" && replaced.kind !== "directory") {
-                            return yield* failure("NotDirectory", "rename", destination);
+                            return yield* new FsError({ code: "NotDirectory", operation: "rename", path: destination });
                         }
                         if (child.kind !== "directory" && replaced.kind === "directory") {
-                            return yield* failure("IsDirectory", "rename", destination);
+                            return yield* new FsError({ code: "IsDirectory", operation: "rename", path: destination });
                         }
                         if (replaced.kind === "directory" && replaced.entries.size > 0) {
-                            return yield* failure("NotEmpty", "rename", destination);
+                            return yield* new FsError({ code: "NotEmpty", operation: "rename", path: destination });
                         }
                     }
                     for (let ancestor = newParent; ancestor !== undefined; ancestor = ancestor.parent) {
-                        if (ancestor === child)
-                            return yield* failure("InvalidArgument", "rename", destination);
+                        if (ancestor === child) {
+                            return yield* new FsError({ code: "InvalidArgument", operation: "rename", path: destination });
+                        }
                     }
                     const now = yield* timestamp("rename");
                     // All rejection checks precede namespace, ancestry, quota, and metadata publication.
-                    const oldEvent = () => ownedPath(nameBytes(directoryHex(oldParent) + (oldParent === root ? "" : "2f") + oldName));
+                    const oldEvent = () => ownedPath(nameBytes(directoryHex(oldParent) + (oldParent === root ? "" : SLASH_HEX) + oldName));
                     oldParent.entries.delete(oldName);
                     newParent.entries.set(newName, child);
                     if (child.kind === "directory")
@@ -1492,19 +1592,20 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 return yield* coordinated(Effect.gen(function* () {
                     const path = yield* Effect.fromResult(prepared);
                     const parent = yield* locate(path, base, "rmdir", { parentOnly: true });
-                    yield* authorize(parent, identity, 3, "rmdir", input);
+                    yield* authorize(parent, identity, WRITE | EXECUTE, "rmdir", input);
                     const name = path.components.at(-1);
-                    if (name === undefined || name === "2e" || name === "2e2e") {
-                        return yield* failure("InvalidArgument", "rmdir", input);
+                    if (isDotComponent(name)) {
+                        return yield* new FsError({ code: "InvalidArgument", operation: "rmdir", path: input });
                     }
                     const child = parent.entries.get(name);
                     if (child === undefined)
-                        return yield* failure("NotFound", "rmdir", input);
+                        return yield* new FsError({ code: "NotFound", operation: "rmdir", path: input });
                     yield* authorizeRemoval(parent, child, "rmdir", input);
-                    if (child.kind !== "directory")
-                        return yield* failure("NotDirectory", "rmdir", input);
+                    if (child.kind !== "directory") {
+                        return yield* new FsError({ code: "NotDirectory", operation: "rmdir", path: input });
+                    }
                     if (child.entries.size > 0)
-                        return yield* failure("NotEmpty", "rmdir", input);
+                        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 };
@@ -1530,18 +1631,18 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 const prepared = preparePath(input, "mkdir", settings.maxPathBytes);
                 const base = options?.relativeTo;
                 const mode = options?.mode === undefined ? 0o777 : options.mode;
-                if (!Schema.is(Mode)(mode))
-                    return yield* failure("InvalidArgument", "mkdir", input);
+                if (!isMode(mode))
+                    return yield* new FsError({ code: "InvalidArgument", operation: "mkdir", path: input });
                 return yield* coordinated(Effect.gen(function* () {
                     const path = yield* Effect.fromResult(prepared);
                     const parent = yield* locate(path, base, "mkdir", { parentOnly: true });
-                    yield* authorize(parent, identity, 3, "mkdir", input);
+                    yield* authorize(parent, identity, WRITE | EXECUTE, "mkdir", input);
                     const name = path.components.at(-1);
-                    if (name === undefined || name === "2e" || name === "2e2e" || parent.entries.has(name)) {
-                        return yield* failure("AlreadyExists", "mkdir", input);
+                    if (isDotComponent(name) || parent.entries.has(name)) {
+                        return yield* new FsError({ code: "AlreadyExists", operation: "mkdir", path: input });
                     }
-                    if (settings.maxEntries !== undefined && entries >= settings.maxEntries) {
-                        return yield* failure("NoSpace", "mkdir", input);
+                    if (atEntryLimit()) {
+                        return yield* new FsError({ code: "NoSpace", operation: "mkdir", path: input });
                     }
                     const now = yield* timestamp("mkdir");
                     const child = {
@@ -1549,20 +1650,12 @@ 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 & 0o1000), now),
+                        metadata: directoryMetadata(nextInode, identity.uid, parent.metadata.gid, (mode & 0o777 & ~umask) | (mode & STICKY_BIT), now),
                         revision: nextRevision(),
                         objectReference: undefined
                     };
-                    const parentMetadata = {
-                        ...parent.metadata,
-                        nlink: parent.metadata.nlink + 1,
-                        mtimeNs: now,
-                        ctimeNs: now
-                    };
                     // No Effect yield or expected failure between these publication writes.
-                    parent.entries.set(name, child);
-                    parent.metadata = parentMetadata;
-                    advanceRevision(parent);
+                    attach(parent, name, child, now);
                     nextInode += 1n;
                     entries += 1;
                     publishEntry("Create", parent, name);
@@ -1577,11 +1670,12 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
                 const handle = Object.freeze({
                     [DirectoryHandleId]: true,
                     stat: coordinated(Effect.suspend(() => acquired.directory === undefined
-                        ? Effect.fail(failure("InvalidHandle", "stat"))
+                        ? Effect.fail(new FsError({ code: "InvalidHandle", operation: "stat" }))
                         : Effect.succeed({ ...acquired.directory.metadata }))).pipe(Effect.withSpan("DirectoryHandle.stat")),
                     close: coordinated(Effect.suspend(() => {
-                        if (acquired.directory === undefined)
-                            return Effect.fail(failure("InvalidHandle", "close"));
+                        if (acquired.directory === undefined) {
+                            return Effect.fail(new FsError({ code: "InvalidHandle", operation: "close" }));
+                        }
                         acquired.directory = undefined;
                         acquired.closed = true;
                         return Effect.void;
@@ -1592,35 +1686,25 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             })
         });
     };
-    const baseObservation = source._tag === "Overlay" ? observeChanges() : undefined;
-    const publicChange = (change) => {
-        switch (change._tag) {
-            case "Added":
-            case "Removed":
-            case "Updated":
-            case "Replaced":
-                return Object.freeze({ ...change, path: ownedPath(new Uint8Array(change.path)) });
-            case "Renamed":
-                return Object.freeze({
-                    ...change,
-                    from: ownedPath(new Uint8Array(change.from)),
-                    to: ownedPath(new Uint8Array(change.to))
-                });
-        }
-        throw new Error("Unknown internal overlay change");
-    };
+    const baseObservation = Predicate.isTagged("Overlay")(source) ? yield* observeChanges() : undefined;
+    const publicChange = (change) => Predicate.isTagged("Renamed")(change)
+        ? OverlayChange.make({ ...change, from: ownedPath(change.from), to: ownedPath(change.to) })
+        : OverlayChange.make({ ...change, path: ownedPath(change.path) });
     const publicChanges = (changes) => Object.freeze(changes.map(publicChange));
     const changeOptions = (options) => {
         const decoded = decodeConfiguration(OverlayChangesOptions, options === undefined ? {} : options);
         return Result.isFailure(decoded) ? Effect.fail(decoded.failure) : Effect.succeed(decoded.success);
     };
+    // An overlay is a spread copy of `volume`, so the object the caller holds is not always the one
+    // built here. `watch` runs lazily, so it reads whichever surface was actually handed out.
+    let surface;
     const volume = Object.freeze({
         [VolumeId]: true,
         watch: Effect.gen(function* () {
-            const hook = TestHooks.getRegistrationHook(volume);
+            const hook = TestHooks.getRegistrationHook(surface);
             return yield* watchHub.subscribe(hook?.afterSubscribe);
         }).pipe(Effect.withSpan("Volume.watch")),
-        snapshot: coordinated(captureSnapshot()).pipe(Effect.withSpan("Volume.snapshot")),
+        snapshot: coordinatedRead(captureSnapshot()).pipe(Effect.withSpan("Volume.snapshot")),
         caller: Effect.fn("Volume.caller")(function* (options) {
             const decoded = decodeConfiguration(RootCallerOptions, options === undefined ? {} : options);
             if (Result.isFailure(decoded))
@@ -1630,48 +1714,42 @@ export const makeVolume = Effect.fnUntraced(function* (source, options) {
             return createCaller({ volume: volumeIdentity, directory: root, closed: false }, identity, decoded.success.umask ?? 0o022);
         })
     });
-    if (source._tag !== "Overlay" || baseObservation === undefined) {
-        return { _tag: "Volume", volume };
+    surface = volume;
+    if (!Predicate.isTagged("Overlay")(source) || baseObservation === undefined) {
+        // SAFETY: Overlay sources return below, so S is non-Overlay here and VolumeFor<S> is Volume.
+        return volume;
     }
     const hook = TestHooks.getObservationHook(source.base);
     const overlay = Object.freeze({
         ...volume,
         changes: Effect.fn("OverlayVolume.changes")(function* (options) {
             const selected = yield* changeOptions(options);
-            const current = yield* coordinated(Effect.sync(observeChanges));
+            const current = yield* coordinatedRead(observeChanges());
             return publicChanges(compareOverlay(baseObservation, current, selected.includeTimestamps ?? false));
         }),
         capture: Effect.fn("OverlayVolume.capture")(function* (options) {
             const selected = yield* changeOptions(options);
-            const current = yield* coordinated(captureState(hook));
+            const current = yield* coordinatedRead(captureState(hook));
             return Object.freeze({
                 snapshot: current.snapshot,
                 changes: publicChanges(compareOverlay(baseObservation, current.observation, selected.includeTimestamps ?? false))
             });
         })
     });
-    return { _tag: "Overlay", volume: overlay };
+    surface = overlay;
+    return overlay;
 });
 /** @internal */
 export const make = Effect.fn("VirtualFileSystem.make")(function* (options) {
-    const result = yield* makeVolume({ _tag: "Empty" }, options).pipe(Effect.catchTag("ImageError", Effect.die));
-    if (result._tag === "Overlay")
-        return yield* Effect.die(new Error("empty volume constructed as overlay"));
-    return result.volume;
+    return yield* makeVolume(VolumeSource.Empty(), options).pipe(Effect.catchTag("ImageError", Effect.die));
 });
 /** @internal */
 export const fromSnapshot = Effect.fn("VirtualFileSystem.fromSnapshot")(function* (snapshot, options) {
     const image = yield* Image.inspect(snapshot);
-    const result = yield* makeVolume({ _tag: "Snapshot", image }, options);
-    if (result._tag === "Overlay")
-        return yield* new ImageError({ code: "InvalidStructure" });
-    return result.volume;
+    return yield* makeVolume(VolumeSource.Snapshot({ image }), options);
 });
 /** @internal */
 export const makeOverlay = Effect.fn("VirtualFileSystem.makeOverlay")(function* (base, options) {
     const image = yield* Image.inspect(base);
-    const result = yield* makeVolume({ _tag: "Overlay", base, image }, options);
-    if (result._tag === "Volume")
-        return yield* new ImageError({ code: "InvalidStructure" });
-    return result.volume;
+    return yield* makeVolume(VolumeSource.Overlay({ base, image }), options);
 });