@effect-vfs/core 0.7.1 → 0.9.0

package/dist/VirtualFileSystem.js

@@ -23,10 +23,11 @@ import * as FixtureInternal from "./internal/fixture.js";
 import * as Image from "./internal/image.js";
 import * as Path from "./internal/path.js";
 import * as SnapshotDeltaInternal from "./internal/snapshotDelta.js";
+import * as SnapshotMergeInternal from "./internal/snapshotMerge.js";
 import * as VfsModel from "./internal/virtualFileSystem.js";
 import { open as openLiveVolume } from "./LiveVolume.js";
 import * as SnapshotDeltaModel from "./SnapshotDelta.js";
-export { SnapshotChange, SnapshotChangesOptions, SnapshotDeltaLimits, SnapshotDeltaTypeId, SnapshotDifference, SnapshotNodeKind } from "./SnapshotDelta.js";
+export { MergeConflict, MergeConflictReason, MergeOptions, MergeResolution, MergeResult, MergeSideChange, MergeTake, SnapshotChange, SnapshotChangesOptions, SnapshotDeltaLimits, SnapshotDeltaTypeId, SnapshotDifference, SnapshotNodeKind } from "./SnapshotDelta.js";
 /**
  * Schema for portable virtual filesystem error codes.
  *
@@ -572,6 +573,12 @@ export const Change = WatchModule.Change;
  * @since 0.6.0
  */
 export const WatchOptions = WatchModule.WatchOptions;
+/**
+ * Caller watch publication and alias options.
+ * @category schemas
+ * @since 0.9.0
+ */
+export const CallerWatchOptions = WatchModule.CallerWatchOptions;
 /**
  * Schema for the filesystem entry kinds reported by overlay summaries.
  *
@@ -895,7 +902,7 @@ const deltaLimits = (operation, limits) => Effect.fromResult(decodeConfiguration
  * @category snapshots
  * @since 0.1.0
  */
-export const diffSnapshots = Effect.fn("VirtualFileSystem.diffSnapshots")(function* (base, target, limits) {
+export const diffSnapshots = Effect.fnUntraced(function* (base, target, limits) {
     // The delta codec fails under its own name; the public entry point names itself.
     return yield* SnapshotDeltaInternal.diffSnapshots(base, target, yield* deltaLimits("diffSnapshots", limits)).pipe(Effect.mapError((error) => retargetFailure("diffSnapshots", error)));
 });
@@ -934,7 +941,7 @@ export const diffSnapshots = Effect.fn("VirtualFileSystem.diffSnapshots")(functi
  * @category snapshots
  * @since 0.1.0
  */
-export const inspectSnapshotDelta = Effect.fn("VirtualFileSystem.inspectSnapshotDelta")(function* (base, delta, options, limits) {
+export const inspectSnapshotDelta = Effect.fnUntraced(function* (base, delta, options, limits) {
     const decoded = yield* Effect.fromResult(decodeConfiguration(SnapshotDeltaModel.SnapshotChangesOptions, options ?? {}, "inspectSnapshotDelta"));
     return yield* SnapshotDeltaInternal.inspectSnapshotDelta(base, delta, decoded, yield* deltaLimits("inspectSnapshotDelta", limits)).pipe(Effect.mapError((error) => retargetFailure("inspectSnapshotDelta", error)));
 });
@@ -978,9 +985,66 @@ export const inspectSnapshotDelta = Effect.fn("VirtualFileSystem.inspectSnapshot
  * @category snapshots
  * @since 0.1.0
  */
-export const applySnapshotDelta = Effect.fn("VirtualFileSystem.applySnapshotDelta")(function* (base, delta, limits) {
+export const applySnapshotDelta = Effect.fnUntraced(function* (base, delta, limits) {
     return yield* SnapshotDeltaInternal.applySnapshotDelta(base, delta, yield* deltaLimits("applySnapshotDelta", limits)).pipe(Effect.mapError((error) => retargetFailure("applySnapshotDelta", error)));
 });
+/**
+ * Merges two snapshot deltas that share one base into a single delta, reporting path-level conflicts as data.
+ *
+ * Changes only one side made are taken as they are. Where both sides changed one path the merge keeps the change
+ * when both agree, combines metadata fields that only one side changed, and otherwise reports a conflict and leaves
+ * the base node in place. Timestamps never conflict. The merged delta is bound to the same base as its inputs and
+ * applies with {@link applySnapshotDelta}. Pass `resolutions` to take one side at paths an earlier merge reported.
+ * Requires the platform-neutral `Crypto.Crypto` service for base identity. Provide
+ * `NodeCrypto.layer`, `BunCrypto.layer`, or your own via `Crypto.make`.
+ *
+ * @example
+ * ```ts
+ * import * as BunCrypto from "@effect/platform-bun/BunCrypto"
+ * import { VirtualFileSystem as Vfs } from "@effect-vfs/core"
+ * import { Effect } from "effect"
+ *
+ * const encoder = new TextEncoder()
+ *
+ * const program = Effect.gen(function*() {
+ *   const source = yield* Vfs.fromFixture({
+ *     entries: [{ kind: "file", path: "/shared.txt", bytes: encoder.encode("v0") }]
+ *   })
+ *   const base = yield* source.snapshot
+ *
+ *   // Two agents work on separate overlays of one base.
+ *   const ours = yield* Vfs.makeOverlay(base)
+ *   const theirs = yield* Vfs.makeOverlay(base)
+ *   yield* (yield* ours.caller()).writeFile("/ours.txt", encoder.encode("a"), { access: "write", create: "exclusive" })
+ *   yield* (yield* theirs.caller()).writeFile("/shared.txt", encoder.encode("v1"), { access: "write", truncate: true })
+ *
+ *   const result = yield* Vfs.mergeSnapshotDeltas(
+ *     base,
+ *     yield* Vfs.diffSnapshots(base, (yield* ours.capture()).snapshot),
+ *     yield* Vfs.diffSnapshots(base, (yield* theirs.capture()).snapshot)
+ *   )
+ *
+ *   // Disjoint changes merge without conflicts; the delta applies to the shared base.
+ *   const merged = yield* Vfs.fromSnapshot(yield* Vfs.applySnapshotDelta(base, result.delta))
+ *   const reader = yield* merged.caller()
+ *
+ *   return [result.conflicts.length, new TextDecoder().decode(yield* reader.readFile("/shared.txt"))]
+ * })
+ *
+ * Effect.runPromise(program.pipe(Effect.provide(BunCrypto.layer))).then(console.log)
+ * // [ 0, 'v1' ]
+ * ```
+ *
+ * @see {@link diffSnapshots} to build each side's delta, {@link applySnapshotDelta} to apply the merged one.
+ * @category snapshots
+ * @since 0.8.0
+ */
+export const mergeSnapshotDeltas = Effect.fnUntraced(function* (base, ours, theirs, options) {
+    // Limits decode first so a bad limit names its own field; the rest of the options decode as one.
+    const limits = yield* deltaLimits("mergeSnapshotDeltas", options?.limits);
+    const decoded = yield* Effect.fromResult(decodeConfiguration(SnapshotDeltaModel.MergeOptions, options ?? {}, "mergeSnapshotDeltas"));
+    return yield* SnapshotMergeInternal.mergeSnapshotDeltas(base, ours, theirs, decoded.resolutions ?? [], limits).pipe(Effect.mapError((error) => retargetFailure("mergeSnapshotDeltas", error)));
+});
 const deltaSchemaIssue = (cause, input, options) => new SchemaIssue.InvalidValue({ message: `Snapshot delta ${cause.code}${cause.field === undefined ? "" : ` at ${cause.field}`}` }, input, options);
 /**
  * Creates an Effect Schema codec between owned bytes and opaque snapshot deltas.

package/dist/Watch.d.ts

@@ -65,4 +65,22 @@ export declare const WatchOptions: Schema.Struct<{
  * @since 0.6.0
  */
 export type WatchOptions = typeof WatchOptions.Type;
+/**
+ * Options for a caller watch. `resolved` follows the selected path alias
+ * through rename and ends when that name is unlinked. `all` reports every
+ * currently authorized alias of the object.
+ *
+ * @category schemas
+ * @since 0.9.0
+ */
+export declare const CallerWatchOptions: Schema.Struct<{
+    readonly recursive: Schema.optionalKey<Schema.Boolean>;
+    readonly alias: Schema.optionalKey<Schema.Literals<readonly ["all", "resolved"]>>;
+}>;
+/**
+ * Options for a caller watch.
+ * @category models
+ * @since 0.9.0
+ */
+export type CallerWatchOptions = typeof CallerWatchOptions.Type;
 //# sourceMappingURL=Watch.d.ts.map

package/dist/Watch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Watch.d.ts","sourceRoot":"","sources":["../src/Watch.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAExC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAE7D;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;EAKjB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY;;;EAIvB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA"}
+{"version":3,"file":"Watch.d.ts","sourceRoot":"","sources":["../src/Watch.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAExC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAE7D;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;EAKjB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,YAAY;;;EAIvB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AAEnD;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB;;;EAG7B,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC,IAAI,CAAA"}

package/dist/Watch.js

@@ -44,3 +44,15 @@ export const WatchOptions = Schema.Struct({
     scope: Schema.optionalKey(ObjectReferenceSchema),
     recursive: Schema.optionalKey(Schema.Boolean)
 });
+/**
+ * Options for a caller watch. `resolved` follows the selected path alias
+ * through rename and ends when that name is unlinked. `all` reports every
+ * currently authorized alias of the object.
+ *
+ * @category schemas
+ * @since 0.9.0
+ */
+export const CallerWatchOptions = Schema.Struct({
+    recursive: Schema.optionalKey(Schema.Boolean),
+    alias: Schema.optionalKey(Schema.Literals(["all", "resolved"]))
+});

package/dist/index.d.ts

@@ -79,4 +79,11 @@ export * as Volume from "./Volume.js";
  * @category re-exports
  */
 export * as Watch from "./Watch.js";
+/**
+ * Bounded filename search over immutable snapshots.
+ *
+ * @category re-exports
+ * @since 0.8.0
+ */
+export * as Search from "./Search.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAE3D;;;;;GAKG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;;;GAKG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;GAGG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;GAGG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;GAGG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAE3D;;;;;GAKG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;;;GAKG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;GAGG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;GAGG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;GAGG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;;;GAKG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA"}

package/dist/index.js

@@ -79,3 +79,10 @@ export * as Volume from "./Volume.js";
  * @category re-exports
  */
 export * as Watch from "./Watch.js";
+/**
+ * Bounded filename search over immutable snapshots.
+ *
+ * @category re-exports
+ * @since 0.8.0
+ */
+export * as Search from "./Search.js";

package/dist/internal/callerWatch.d.ts

@@ -0,0 +1,32 @@
+import type { FsFailure } from "../VfsError.js";
+import { Change } from "../Watch.js";
+import { type Ino, type Link, type VolumeState } from "./volumeState.js";
+import type { Selection } from "./watchHub.js";
+/** @internal */
+export interface WatchEvent {
+    readonly change: Change;
+    readonly parent: Ino;
+    readonly ino: Ino;
+    readonly name?: string;
+}
+/** @internal */
+export interface Rename {
+    readonly ino: Ino;
+    readonly from: Link;
+    readonly to: Link;
+}
+/** @internal */
+export interface Installation {
+    readonly before: VolumeState;
+    readonly after: VolumeState;
+    readonly renames?: ReadonlyArray<Rename>;
+}
+/** Select and rebase names while publication holds both installed namespace states. @internal */
+export declare const make: (options: {
+    readonly roots: ReadonlyArray<Ino>;
+    readonly additionalRoots?: ReadonlyArray<ReadonlyArray<Ino>>;
+    readonly target: Ino;
+    readonly recursive: boolean;
+    readonly selected?: Link;
+}) => Selection<WatchEvent, Installation, FsFailure>;
+//# sourceMappingURL=callerWatch.d.ts.map

package/dist/internal/callerWatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callerWatch.d.ts","sourceRoot":"","sources":["../../src/internal/callerWatch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAIpC,OAAO,EAAW,KAAK,GAAG,EAAE,KAAK,IAAI,EAAY,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC3F,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,gBAAgB;AAChB,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAA;IACpB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IACjB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,gBAAgB;AAChB,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IACjB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAA;CAClB;AAED,gBAAgB;AAChB,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAA;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACzC;AA6ED,iGAAiG;AACjG,eAAO,MAAM,IAAI,YAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,GAAG,CAAC,CAAA;IAClC,QAAQ,CAAC,eAAe,CAAC,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAA;IAC5D,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAA;IACpB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAA;CACzB,KAAG,SAAS,CAAC,UAAU,EAAE,YAAY,EAAE,SAAS,CA6IhD,CAAA"}

package/dist/internal/callerWatch.js

@@ -0,0 +1,184 @@
+import * as Predicate from "effect/Predicate";
+import { Change } from "../Watch.js";
+import { getBytes } from "./bytePath.js";
+import { fsFailure } from "./errors.js";
+import { nameBytes, ownedPath, SLASH_HEX } from "./path.js";
+import { getNode, ROOT_INO } from "./volumeState.js";
+const directoryPath = (state, ino) => {
+    const names = [];
+    const visited = new Set();
+    let at = ino;
+    for (;;) {
+        if (visited.has(at))
+            return undefined;
+        visited.add(at);
+        const directory = getNode(state, at);
+        if (directory?.kind !== "directory" || directory.metadata.nlink === 0)
+            return undefined;
+        if (at === ROOT_INO)
+            return SLASH_HEX + names.reverse().join(SLASH_HEX);
+        names.push(directory.name);
+        at = directory.parent;
+    }
+};
+const below = (path, root) => root === SLASH_HEX || path === root || path.startsWith(root + SLASH_HEX);
+const rebase = (path, root) => root === SLASH_HEX ? path : path === root ? SLASH_HEX : path.slice(root.length);
+const entryPath = (state, link) => {
+    const parent = directoryPath(state, link.parent);
+    return parent === undefined ? undefined : parent + (parent === SLASH_HEX ? "" : SLASH_HEX) + link.name;
+};
+const paths = (state, target) => {
+    const node = getNode(state, target);
+    if (node === undefined || node.metadata.nlink === 0)
+        return [];
+    if (node.kind === "directory") {
+        const path = directoryPath(state, target);
+        return path === undefined ? [] : [path];
+    }
+    return node.links.flatMap((link) => {
+        const directory = getNode(state, link.parent);
+        const path = directory?.kind === "directory" && directory.entries.get(link.name) === target
+            ? entryPath(state, link)
+            : undefined;
+        return path === undefined ? [] : [path];
+    });
+};
+const rootPath = (state, roots) => {
+    let previous = SLASH_HEX;
+    for (const root of roots) {
+        const path = directoryPath(state, root);
+        if (path === undefined)
+            return fsFailure("ClosedCaller", "watch");
+        if (!below(path, previous))
+            return fsFailure("AccessDenied", "watch");
+        previous = path;
+    }
+    return previous;
+};
+const eventName = (event) => {
+    if (event.name !== undefined)
+        return event.name;
+    const bytes = getBytes(event.change.path);
+    const last = bytes.lastIndexOf(47);
+    return Array.from(bytes.subarray(last + 1), (byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+/** Select and rebase names while publication holds both installed namespace states. @internal */
+export const make = (options) => {
+    let selected = options.selected;
+    let oldSelected = selected;
+    let failure;
+    let previousRoot = SLASH_HEX;
+    let currentRoot = SLASH_HEX;
+    let terminal;
+    let rescanPath = SLASH_HEX;
+    const visible = (state, root, selection) => {
+        const aliases = paths(state, options.target);
+        for (const chain of options.additionalRoots ?? []) {
+            const boundary = rootPath(state, chain);
+            if (!Predicate.isString(boundary) || !aliases.some((path) => below(path, boundary)))
+                return [];
+        }
+        return aliases.filter((path) => below(path, root) && (selection === undefined || path === entryPath(state, selection)));
+    };
+    return {
+        boundedTerminal: true,
+        prepare: ({ before, after, renames }) => {
+            terminal = undefined;
+            oldSelected = selected;
+            const beforeRoot = rootPath(before, options.roots);
+            const afterRoot = rootPath(after, options.roots);
+            for (const chain of options.additionalRoots ?? []) {
+                const boundary = rootPath(after, chain);
+                if (!Predicate.isString(boundary)) {
+                    failure = boundary;
+                    return;
+                }
+            }
+            if (!Predicate.isString(afterRoot)) {
+                failure = afterRoot;
+                return;
+            }
+            if (!Predicate.isString(beforeRoot))
+                return;
+            previousRoot = beforeRoot;
+            currentRoot = afterRoot;
+            for (const rename of renames ?? []) {
+                if (rename.ino === options.target && selected !== undefined && selected.parent === rename.from.parent &&
+                    selected.name === rename.from.name)
+                    selected = rename.to;
+            }
+            const oldPaths = visible(before, previousRoot, oldSelected);
+            const nextPaths = visible(after, currentRoot, selected);
+            rescanPath = rebase(nextPaths[0] ?? oldPaths[0] ?? currentRoot, nextPaths.length > 0 ? currentRoot : previousRoot);
+            if (nextPaths.length === 0)
+                terminal = oldPaths.map((path) => rebase(path, previousRoot));
+        },
+        includes: () => failure === undefined,
+        project: (event, { before, after }) => {
+            if (failure !== undefined)
+                return undefined;
+            if (terminal === undefined && event.ino !== options.target && Predicate.isTagged(event.change, "Create")) {
+                const name = eventName(event);
+                const parent = getNode(before, event.parent);
+                const replacedPath = entryPath(before, { parent: event.parent, name });
+                // Rename publishes the incoming object; its replaced alias needs the old target's removal.
+                if (parent?.kind === "directory" && parent.entries.get(name) === options.target &&
+                    replacedPath !== undefined && visible(before, previousRoot, oldSelected).includes(replacedPath)) {
+                    return {
+                        ...event,
+                        ino: options.target,
+                        change: Change.cases.Remove.make({ path: ownedPath(nameBytes(rebase(replacedPath, previousRoot))) })
+                    };
+                }
+            }
+            const removed = Predicate.isTagged(event.change, "Remove");
+            const installed = removed ? before : after;
+            const root = removed ? previousRoot : currentRoot;
+            const selection = removed ? oldSelected : selected;
+            let path;
+            const node = getNode(installed, event.ino);
+            if (event.ino === options.target) {
+                // Settlement emits the terminal removals once, behind already queued changes.
+                if (removed && terminal !== undefined)
+                    return undefined;
+                path = node?.kind === "directory"
+                    ? directoryPath(installed, event.ino)
+                    : entryPath(installed, { parent: event.parent, name: eventName(event) });
+                if (selection !== undefined && path !== entryPath(installed, selection))
+                    return undefined;
+            }
+            else {
+                const scopes = visible(installed, root, selection);
+                path = entryPath(installed, { parent: event.parent, name: eventName(event) });
+                if (path === undefined || !scopes.some((scope) => {
+                    if (!below(path, scope))
+                        return false;
+                    if (options.recursive)
+                        return true;
+                    return directoryPath(installed, event.parent) === scope;
+                }))
+                    return undefined;
+            }
+            if (path === undefined || !below(path, root))
+                return undefined;
+            // A confinement root's outside parent is never reported as a rename.
+            if (event.ino === options.roots.at(-1) && !Predicate.isTagged(event.change, "Update"))
+                return undefined;
+            return {
+                ...event,
+                change: Change.cases[event.change._tag].make({ path: ownedPath(nameBytes(rebase(path, root))) })
+            };
+        },
+        rescan: () => ({
+            change: Change.cases.Rescan.make({ path: ownedPath(nameBytes(rescanPath)) }),
+            parent: options.target,
+            ino: options.target
+        }),
+        failure: () => failure,
+        settle: () => terminal?.map((path) => ({
+            change: Change.cases.Remove.make({ path: ownedPath(nameBytes(path)) }),
+            parent: options.target,
+            ino: options.target
+        }))
+    };
+};

package/dist/internal/confinement.d.ts

@@ -0,0 +1,16 @@
+import * as Effect from "effect/Effect";
+import type { FsFailure } from "../VfsError.js";
+import type { OpContext } from "./errors.js";
+import { type Ino, type Node } from "./volumeState.js";
+/** @internal */
+export declare const make: (view: Effect.Effect<(ino: Ino) => Node | undefined>, roots: ReadonlyArray<Ino>) => {
+    roots: readonly Ino[];
+    root: Ino;
+    alive: (op: OpContext, handle?: boolean) => Effect.Effect<undefined, FsFailure, never>;
+    contains: (node: Node) => Effect.Effect<boolean, never, never>;
+    check: (node: Node, op: OpContext, handle?: boolean | undefined) => Effect.Effect<void, FsFailure, never>;
+    path: (ino: Ino) => Effect.Effect<string | undefined, never, never>;
+};
+/** @internal */
+export type Confinement = ReturnType<typeof make>;
+//# sourceMappingURL=confinement.d.ts.map

package/dist/internal/confinement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confinement.d.ts","sourceRoot":"","sources":["../../src/internal/confinement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI,EAAiC,MAAM,kBAAkB,CAAA;AAErF,gBAAgB;AAChB,eAAO,MAAM,IAAI,SAAU,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,GAAG,SAAS,CAAC,SAAS,aAAa,CAAC,GAAG,CAAC;;;gBAoD9E,SAAS,WAAU,OAAO;qBAErB,IAAI;;;CAuC7B,CAAA;AAED,gBAAgB;AAChB,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,IAAI,CAAC,CAAA"}

package/dist/internal/confinement.js

@@ -0,0 +1,79 @@
+import * as Effect from "effect/Effect";
+import { ROOT_INO, WALK_YIELD_INTERVAL } from "./volumeState.js";
+/** @internal */
+export const make = (view, roots) => {
+    const descends = Effect.fnUntraced(function* (get, ino, root) {
+        let node = get(ino);
+        let steps = 0;
+        while (node?.kind === "directory" && node.metadata.nlink > 0) {
+            if (node.ino === root)
+                return true;
+            if (node.ino === ROOT_INO)
+                return false;
+            const parent = get(node.parent);
+            if (parent?.kind !== "directory" || parent.entries.get(node.name) !== node.ino)
+                return false;
+            node = parent;
+            if (++steps % WALK_YIELD_INTERVAL === 0)
+                yield* Effect.yieldNow;
+        }
+        return false;
+    });
+    const aliveIn = Effect.fnUntraced(function* (get, op, handle) {
+        for (let index = 0; index < roots.length; index++) {
+            const root = roots[index];
+            const node = get(root);
+            if (node?.kind !== "directory" || node.metadata.nlink === 0) {
+                return yield* op.fail(handle ? "InvalidHandle" : "ClosedCaller");
+            }
+            if (index > 0 && !(yield* descends(get, root, roots[index - 1])))
+                return yield* op.fail("AccessDenied");
+        }
+    });
+    const containsIn = Effect.fnUntraced(function* (get, node) {
+        const root = roots.at(-1);
+        if (root === undefined)
+            return true;
+        if (node.kind === "directory")
+            return yield* descends(get, node.ino, root);
+        for (const link of node.links) {
+            const parent = get(link.parent);
+            if (parent?.kind === "directory" && parent.entries.get(link.name) === node.ino &&
+                (yield* descends(get, parent.ino, root)))
+                return true;
+        }
+        return false;
+    });
+    const alive = (op, handle = false) => Effect.flatMap(view, (get) => aliveIn(get, op, handle));
+    const contains = (node) => Effect.flatMap(view, (get) => containsIn(get, node));
+    const check = Effect.fnUntraced(function* (node, op, handle = false) {
+        // Share the current lookup within authorization, never its result between operations.
+        const get = yield* view;
+        yield* aliveIn(get, op, handle);
+        if (!(yield* containsIn(get, node)))
+            return yield* op.fail("AccessDenied");
+    });
+    const path = Effect.fnUntraced(function* (ino) {
+        const names = [];
+        const get = yield* view;
+        let node = get(ino);
+        let steps = 0;
+        if (node?.kind !== "directory" || node.metadata.nlink === 0)
+            return undefined;
+        const root = roots.at(-1) ?? ROOT_INO;
+        while (node.ino !== root) {
+            if (node.ino === ROOT_INO)
+                return undefined;
+            names.push(node.name);
+            const parent = get(node.parent);
+            if (parent?.kind !== "directory" || parent.metadata.nlink === 0 || parent.entries.get(node.name) !== node.ino) {
+                return undefined;
+            }
+            node = parent;
+            if (++steps % WALK_YIELD_INTERVAL === 0)
+                yield* Effect.yieldNow;
+        }
+        return "2f" + names.reverse().join("2f");
+    });
+    return { roots, root: roots.at(-1) ?? ROOT_INO, alive, contains, check, path };
+};

package/dist/internal/directoryEntries.d.ts

@@ -0,0 +1,6 @@
+import type { Ino } from "./volumeState.js";
+/** @internal */
+export declare const set: (entries: ReadonlyMap<string, Ino>, name: string, ino: Ino) => ReadonlyMap<string, Ino>;
+/** @internal */
+export declare const remove: (entries: ReadonlyMap<string, Ino>, name: string) => ReadonlyMap<string, Ino>;
+//# sourceMappingURL=directoryEntries.d.ts.map

package/dist/internal/directoryEntries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directoryEntries.d.ts","sourceRoot":"","sources":["../../src/internal/directoryEntries.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AA2E3C,gBAAgB;AAChB,eAAO,MAAM,GAAG,YAAa,WAAW,CAAC,MAAM,EAAE,GAAG,CAAC,QAAQ,MAAM,OAAO,GAAG,KAAG,WAAW,CAAC,MAAM,EAAE,GAAG,CAYtG,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,MAAM,YAAa,WAAW,CAAC,MAAM,EAAE,GAAG,CAAC,QAAQ,MAAM,KAAG,WAAW,CAAC,MAAM,EAAE,GAAG,CAa/F,CAAA"}

package/dist/internal/directoryEntries.js

@@ -0,0 +1,79 @@
+import * as HashMap from "effect/HashMap";
+import * as Option from "effect/Option";
+import * as InodeTable from "./inodeTable.js";
+// Name lookup and insertion order share immutable trees. Deleted slots are compacted once they outnumber live entries.
+class DirectoryEntries {
+    names;
+    slots;
+    length;
+    [Symbol.toStringTag] = "Map";
+    constructor(names, slots, length) {
+        this.names = names;
+        this.slots = slots;
+        this.length = length;
+    }
+    get size() {
+        return HashMap.size(this.names);
+    }
+    get(name) {
+        const slot = HashMap.get(this.names, name);
+        return Option.isSome(slot) ? slot.value.ino : undefined;
+    }
+    has(name) {
+        return HashMap.has(this.names, name);
+    }
+    *entries() {
+        for (let index = 0; index < this.length; index++) {
+            const entry = InodeTable.get(this.slots, index);
+            if (entry !== undefined)
+                yield [entry.name, entry.ino];
+        }
+    }
+    *keys() {
+        for (const [name] of this)
+            yield name;
+    }
+    *values() {
+        for (const [, ino] of this)
+            yield ino;
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    // oxlint-disable-next-line anti-slop/no-unknown-parameters -- ReadonlyMap forwards the opaque callback receiver without inspecting it.
+    forEach(callback, thisArg) {
+        for (const [name, ino] of this)
+            callback.call(thisArg, ino, name, this);
+    }
+}
+const fromEntries = (entries) => {
+    let slots = InodeTable.empty();
+    let length = 0;
+    const owner = Symbol();
+    const names = HashMap.mutate(HashMap.empty(), (mutable) => {
+        for (const [name, ino] of entries) {
+            const entry = { name, ino, index: length };
+            HashMap.set(mutable, name, entry);
+            slots = InodeTable.set(slots, length, entry, owner);
+            length++;
+        }
+    });
+    return new DirectoryEntries(names, slots, length);
+};
+/** @internal */
+export const set = (entries, name, ino) => {
+    const current = entries instanceof DirectoryEntries ? entries : fromEntries(entries);
+    const existing = HashMap.get(current.names, name);
+    const index = Option.isSome(existing) ? existing.value.index : current.length;
+    const entry = { name, ino, index };
+    return new DirectoryEntries(HashMap.set(current.names, name, entry), InodeTable.set(current.slots, index, entry), Option.isSome(existing) ? current.length : current.length + 1);
+};
+/** @internal */
+export const remove = (entries, name) => {
+    const current = entries instanceof DirectoryEntries ? entries : fromEntries(entries);
+    const existing = HashMap.get(current.names, name);
+    if (Option.isNone(existing))
+        return current;
+    const removed = new DirectoryEntries(HashMap.remove(current.names, name), InodeTable.set(current.slots, existing.value.index, undefined), current.length);
+    return removed.length > removed.size * 2 ? fromEntries(removed) : removed;
+};

package/dist/internal/fixture.js

@@ -5,12 +5,12 @@ import { Fixture as FixtureSchema, FixtureEntry } from "../Fixture.js";
 import { VolumeIdentity, VolumeOptions as VolumeOptionsSchema } from "../Volume.js";
 import { decodeConfiguration, imageFailure, OpContext, VfsError } from "./errors.js";
 import { inputBytes, isAttachedBytes, isDotComponent, preparePath } from "./path.js";
-import { makeVolume, VolumeSource } from "./virtualFileSystem.js";
+import { makeVolume, memoryCommitProvider, VolumeSource } from "./virtualFileSystem.js";
 import { assemble, Ino, ROOT_INO } from "./volumeState.js";
 const DEFAULT_MODE = { directory: 0o755, file: 0o644, symlink: 0o777 };
 const EPOCH_NS = 0n;
 /** @internal */
-export const fromFixture = Effect.fn("VirtualFileSystem.fromFixture")(function* (fixture, options) {
+export const fromFixture = Effect.fnUntraced(function* (fixture, options) {
     const config = yield* Effect.fromResult(decodeConfiguration(VolumeOptionsSchema, options ?? {}, "fromFixture"));
     const source = yield* Schema.decodeEffect(FixtureSchema, { onExcessProperty: "error" })(fixture).pipe(Effect.mapError((cause) => imageFailure("fromFixture", "InvalidStructure", { field: "fixture", cause })));
     if (source.entries.some((entry) => FixtureEntry.match(entry, {
@@ -124,8 +124,8 @@ export const fromFixture = Effect.fn("VirtualFileSystem.fromFixture")(function*
     const restored = VolumeSource.Restored({ value: assemble(specs) });
     const { identity, ...volumeOptions } = config;
     if (identity === undefined)
-        return (yield* makeVolume(restored, volumeOptions)).volume;
-    const { volume } = yield* makeVolume(restored, {
+        return (yield* makeVolume(restored, memoryCommitProvider, volumeOptions)).volume;
+    const { volume } = yield* makeVolume(restored, memoryCommitProvider, {
         ...volumeOptions,
         identity: VolumeIdentity.make(identity)
     });