@effect-vfs/core 0.8.0 → 0.10.0

package/dist/Target.js

@@ -1,26 +1,11 @@
-/**
- * How a caller names what it operates on. A `Target` is a path, an object
- * reference, or an open handle; an `Entry` is a child of a directory target
- * called `name`. Every verb takes one or the other, so the three addressing
- * modes share one body and one option vocabulary.
- *
- * @since 0.6.0
- */
-import * as Data from "effect/Data";
-import * as Predicate from "effect/Predicate";
-import * as Schema from "effect/Schema";
-import { DirectoryHandleId, FileHandleId } from "./FileHandle.js";
-import * as Internal from "./internal/bytePath.js";
-const isFileHandle = (value) => Predicate.hasProperty(FileHandleId)(value) && value[FileHandleId] === true;
-const isDirectoryHandle = (value) => Predicate.hasProperty(DirectoryHandleId)(value) && value[DirectoryHandleId] === true;
-const enumeration = Data.taggedEnum();
+import { Address } from "./internal/engine.js";
 /**
  * Whether a value is a `Target`.
  *
  * @category predicates
  * @since 0.6.0
  */
-export const isTarget = (value) => Predicate.isTagged("Path")(value) || Predicate.isTagged("Reference")(value) || Predicate.isTagged("Handle")(value);
+export const isTarget = Address.isTarget;
 /**
  * Constructors and matchers for `Target`, plus `of`, which wraps a bare path,
  * reference, or handle.
@@ -28,46 +13,21 @@ export const isTarget = (value) => Predicate.isTagged("Path")(value) || Predicat
  * @category constructors
  * @since 0.6.0
  */
-export const Target = {
-    Path: enumeration.Path,
-    Reference: enumeration.Reference,
-    Handle: enumeration.Handle,
-    $is: enumeration.$is,
-    $match: enumeration.$match,
-    // A string or byte path is a path and a handle is a handle; anything else is taken for a reference, so a forged
-    // token reaches the registry and is reported as one.
-    of: (input) => {
-        if (isTarget(input))
-            return input;
-        if (isFileHandle(input) || isDirectoryHandle(input))
-            return enumeration.Handle({ handle: input });
-        if (Predicate.isString(input) || Internal.isBytePath(input))
-            return enumeration.Path({ path: input });
-        return enumeration.Reference({ reference: input });
-    }
-};
+export const Target = Address.Target;
 /**
  * Schema for a well-formed entry name, as bytes.
  *
  * @category schemas
  * @since 0.6.0
  */
-export const Name = Schema.Uint8Array.check(Schema.makeFilter((bytes) => bytes.length === 0
-    ? "must not be empty"
-    : bytes.length > 255
-        ? "must be at most 255 bytes"
-        : bytes.includes(0)
-            ? "must not contain NUL"
-            : bytes.includes(0x2f)
-                ? "must not contain a slash"
-                : undefined));
+export const Name = Address.Name;
 /**
  * Whether a value is an `Entry`.
  *
  * @category predicates
  * @since 0.6.0
  */
-export const isEntry = (value) => Predicate.hasProperty(value, "directory") && Predicate.hasProperty(value, "name") && isTarget(value.directory);
+export const isEntry = Address.isEntry;
 /**
  * Names a child of a directory. The directory may be given bare.
  *
@@ -82,11 +42,11 @@ export const isEntry = (value) => Predicate.hasProperty(value, "directory") && P
  * @category constructors
  * @since 0.6.0
  */
-export const Entry = (directory, name) => ({ directory: Target.of(directory), name });
+export const Entry = Address.Entry;
 /**
  * Whether a path input is a byte path rather than a string.
  *
  * @category predicates
  * @since 0.6.0
  */
-export const isBytePathInput = (input) => Internal.isBytePath(input);
+export const isBytePathInput = Address.isBytePathInput;

package/dist/Testing.d.ts

@@ -31,7 +31,7 @@ import type { VolumeOptions } from "./Volume.js";
 export interface LayerOptions {
     /** Entries the volume starts with; without one the volume starts empty. */
     readonly fixture?: Fixture;
-    /** Limits and identity of the volume. */
+    /** Execution mode, limits and identity of the volume. */
     readonly volume?: VolumeOptions;
     /** Credentials and umask of the root caller the layer provides. */
     readonly caller?: RootCallerOptions;
@@ -128,5 +128,8 @@ export declare const callerAs: (identity: Identity, options?: Omit<RootCallerOpt
  * @category combinators
  * @since 0.6.0
  */
-export declare const collectChanges: <A, E, R>(stream: Stream.Stream<A, E, R>, n: number) => Effect.Effect<Effect.Effect<Array<A>, E>, never, R | Scope.Scope>;
+export declare const collectChanges: {
+    (n: number): <A, E, R>(stream: Stream.Stream<A, E, R>) => Effect.Effect<Effect.Effect<Array<A>, E>, never, R | Scope.Scope>;
+    <A, E, R>(stream: Stream.Stream<A, E, R>, n: number): Effect.Effect<Effect.Effect<Array<A>, E>, never, R | Scope.Scope>;
+};
 //# sourceMappingURL=Testing.d.ts.map

package/dist/Testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Testing.d.ts","sourceRoot":"","sources":["../src/Testing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,yCAAyC;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAA;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,MAAM,CAAC,EAAE,iBAAiB,CAAA;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,KAAK,aAAc,YAAY,KAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,CAOhG,CAAA;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,QAAQ,aACT,QAAQ,YACR,IAAI,CAAC,iBAAiB,EAAE,UAAU,CAAC,KAC5C,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,CACoC,CAAA;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,UAC5B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAC3B,MAAM,KACR,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC,KAAK,CAIhE,CAAA"}
+{"version":3,"file":"Testing.d.ts","sourceRoot":"","sources":["../src/Testing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,yDAAyD;IACzD,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAA;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,MAAM,CAAC,EAAE,iBAAiB,CAAA;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,KAAK,aAAc,YAAY,KAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,CAOhG,CAAA;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,QAAQ,aACT,QAAQ,YACR,IAAI,CAAC,iBAAiB,EAAE,UAAU,CAAC,KAC5C,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,CACoC,CAAA;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,cAAc,EAAE;IAC3B,CACE,CAAC,EAAE,MAAM,GACR,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAA;IACjH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACN,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC9B,CAAC,EAAE,MAAM,GACR,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAA;CAQlE,CAAA"}

package/dist/Testing.js

@@ -1,5 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as Fiber from "effect/Fiber";
+import { dual } from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Stream from "effect/Stream";
 import { Caller, Volume } from "./VirtualFileSystem.js";
@@ -97,4 +98,4 @@ export const callerAs = (identity, options) => Effect.flatMap(Volume, (volume) =
  * @category combinators
  * @since 0.6.0
  */
-export const collectChanges = (stream, n) => Stream.runCollect(Stream.take(stream, n)).pipe(Effect.forkScoped({ startImmediately: true }), Effect.map(Fiber.join));
+export const collectChanges = dual(2, (stream, n) => Stream.runCollect(Stream.take(stream, n)).pipe(Effect.forkScoped({ startImmediately: true }), Effect.map(Fiber.join)));

package/dist/VfsError.d.ts

@@ -1,14 +1,16 @@
 /**
- * The one error family of `@effect-vfs/core`. Every failure a volume, caller,
+ * Filesystem and configuration errors for `@effect-vfs/core`. Every failure a volume, caller,
  * handle, snapshot codec, delta codec, or live store reports is a `VfsError`
  * whose `code` says what went wrong, whose `operation` names the verb or
  * constructor, and which may name the offending option `field`, the `path`
  * it was addressing, and the underlying `cause` it classifies.
+ * Live-volume registry capacity additionally reports Effect's native
+ * `Cause.ExceededCapacityError`.
  *
  * @since 0.6.0
  */
 import * as Schema from "effect/Schema";
-import type { BytePath } from "./BytePath.js";
+import type { BytePath } from "./internal/bytePath.js";
 /**
  * Schema for the codes an operation on a volume, caller, or handle reports.
  *

package/dist/VfsError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VfsError.d.ts","sourceRoot":"","sources":["../src/VfsError.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAM7C;;;;;GAKG;AACH,eAAO,MAAM,MAAM,4bA+BjB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,SAAS,0GAAkG,CAAA;AAExH;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,SAAS,4CAAoC,CAAA;AAE1D;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,SAAS,yFAAiF,CAAA;AAEvG;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,OAAO,ulBAKlB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,gGAUrB,CAAA;;IA2BC,uBAAuB;;IAEvB,2CAA2C;;IAE3C,wEAAwE;;IAExE,gEAAgE;;IAEhE,qEAAqE;;;AAjCvE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,QAAS,SAAQ,aAW5B;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;AAED;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAE5D;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAAA;AAElE;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAAA;AAElE;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,CAAA;AAE7E;;;;;;GAMG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC,SAAS,OAAO;IACtC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;IAChB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;IACpC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CACzB;AAUD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,OAAO,SAAS,KAAK,CAAC,CAAC,CAAC,KAAG,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CAYtF,CAAA"}
+{"version":3,"file":"VfsError.d.ts","sourceRoot":"","sources":["../src/VfsError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAMtD;;;;;GAKG;AACH,eAAO,MAAM,MAAM,4bA+BjB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,SAAS,0GAAkG,CAAA;AAExH;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,SAAS,4CAAoC,CAAA;AAE1D;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,SAAS,yFAAiF,CAAA;AAEvG;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,OAAO,ulBAKlB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,gGAUrB,CAAA;;IA2BC,uBAAuB;;IAEvB,2CAA2C;;IAE3C,wEAAwE;;IAExE,gEAAgE;;IAEhE,qEAAqE;;;AAjCvE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,QAAS,SAAQ,aAW5B;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;AAED;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAE5D;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAAA;AAElE;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAAA;AAElE;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,CAAA;AAE7E;;;;;;GAMG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC,SAAS,OAAO;IACtC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;IAChB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;IACpC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CACzB;AAUD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,OAAO,SAAS,KAAK,CAAC,CAAC,CAAC,KAAG,QAAQ,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;CAYtF,CAAA"}

package/dist/VfsError.js

@@ -1,9 +1,11 @@
 /**
- * The one error family of `@effect-vfs/core`. Every failure a volume, caller,
+ * Filesystem and configuration errors for `@effect-vfs/core`. Every failure a volume, caller,
  * handle, snapshot codec, delta codec, or live store reports is a `VfsError`
  * whose `code` says what went wrong, whose `operation` names the verb or
  * constructor, and which may name the offending option `field`, the `path`
  * it was addressing, and the underlying `cause` it classifies.
+ * Live-volume registry capacity additionally reports Effect's native
+ * `Cause.ExceededCapacityError`.
  *
  * @since 0.6.0
  */

package/dist/VirtualFileSystem.d.ts

@@ -34,8 +34,9 @@ import * as VolumeModule from "./Volume.js";
 import * as WatchModule from "./Watch.js";
 export { Entry, type EntryInput, isEntry, isTarget, Name, type NameInput, type PathTarget, Target, type TargetInput } from "./Target.js";
 export { BytePath } from "./BytePath.js";
-import type { DecodeLimits, Snapshot } from "./Snapshot.js";
+import { type DecodeLimits, type Snapshot } from "./Snapshot.js";
 export { DecodeLimits, type Snapshot, SnapshotTypeId } from "./Snapshot.js";
+import type * as Engine from "./internal/engine.js";
 import { type LiveImageStore, type Options as LiveVolumeOptions } from "./LiveVolume.js";
 import * as SnapshotDeltaModel from "./SnapshotDelta.js";
 export { MergeConflict, MergeConflictReason, MergeOptions, MergeResolution, MergeResult, MergeSideChange, MergeTake, SnapshotChange, SnapshotChangesOptions, type SnapshotDelta, SnapshotDeltaLimits, SnapshotDeltaTypeId, SnapshotDifference, SnapshotNodeKind } from "./SnapshotDelta.js";
@@ -235,7 +236,7 @@ export declare const VolumeDurabilityOrder: Order.Order<VolumeDurability>;
  * @category predicates
  * @since 0.1.0
  */
-export declare const isVolumeDurabilityAtLeast: (actual: VolumeDurability, required: VolumeDurability) => boolean;
+export declare const isVolumeDurabilityAtLeast: typeof VolumeModule.isVolumeDurabilityAtLeast;
 /**
  * Schema for the stable logical identity of a volume.
  *
@@ -337,7 +338,8 @@ export type ReferenceKey = typeof ReferenceKey.Type;
  */
 export declare const VolumeOptions: typeof VolumeModule.VolumeOptions;
 /**
- * Capacity, admission, watch retention, and path limits for a volume.
+ * Execution policy, capacity, admission, watch retention, and path limits for a volume.
+ * `execution` defaults to `"cooperative"`; `"sync"` opts memory operations into non-yielding coordination.
  * `maxPendingOperations` defaults to 64 and `maxWatchEvents` defaults to 256.
  *
  * @category models
@@ -351,7 +353,7 @@ export type VolumeOptions = typeof VolumeOptions.Type;
  * @category models
  * @since 0.1.0
  */
-export interface VolumeLimits {
+export interface VolumeLimits extends Engine.EngineLimits {
     readonly maxBytes: ByteSize.ByteSize | undefined;
     readonly maxFileBytes: ByteSize.ByteSize;
     readonly maxEntries: number | undefined;
@@ -368,7 +370,7 @@ export interface VolumeLimits {
  * @category models
  * @since 0.1.0
  */
-export interface VolumeUsage {
+export interface VolumeUsage extends Engine.VolumeUsage {
     readonly usedBytes: bigint;
     readonly entries: number;
 }
@@ -416,7 +418,7 @@ export type Metadata = typeof Metadata.Type;
  * @category models
  * @since 0.1.0
  */
-export interface ObjectReference {
+export interface ObjectReference extends Engine.ObjectReference {
     readonly [ObjectReferenceId]: true;
 }
 /**
@@ -454,7 +456,7 @@ export interface ObjectReference {
  * @category models
  * @since 0.1.0
  */
-export interface ObjectObservation<A> {
+export interface ObjectObservation<A> extends Engine.ObjectObservation<A> {
     readonly value: A;
     readonly revision: bigint;
 }
@@ -464,7 +466,7 @@ export interface ObjectObservation<A> {
  * @category models
  * @since 0.1.0
  */
-export interface DirectoryEntry {
+export interface DirectoryEntry extends Engine.DirectoryEntry {
     readonly name: Uint8Array;
     readonly reference: ObjectReference;
 }
@@ -482,7 +484,7 @@ export interface DirectoryEntry {
  * @category models
  * @since 0.6.0
  */
-export interface WalkEntry {
+export interface WalkEntry extends Engine.WalkEntry {
     readonly path: BytePath;
     readonly name: Uint8Array;
     readonly reference: ObjectReference;
@@ -535,7 +537,7 @@ export type DirectoryChange = typeof DirectoryChange.Type;
  * @category models
  * @since 0.4.0
  */
-export interface ReferenceEntryResult {
+export interface ReferenceEntryResult extends Engine.ReferenceEntryResult {
     readonly reference: ObjectReference;
     readonly directory: DirectoryChange;
 }
@@ -651,7 +653,7 @@ export type Times = typeof Times.Type;
  * @category models
  * @since 0.1.0
  */
-export interface DirectoryHandle {
+export interface DirectoryHandle extends Engine.DirectoryHandle {
     readonly [DirectoryHandleId]: true;
     readonly stat: Effect.Effect<Metadata, FsFailure>;
     readonly close: Effect.Effect<void, FsFailure>;
@@ -801,7 +803,7 @@ export type OpenEntryOptions = typeof OpenEntryOptions.Type;
  * @category models
  * @since 0.4.0
  */
-export interface OpenEntryResult {
+export interface OpenEntryResult extends Engine.OpenEntryResult {
     readonly handle: FileHandle;
     readonly reference: ObjectReference;
     readonly created: boolean;
@@ -862,7 +864,7 @@ export type WriteFileOptions = typeof WriteFileOptions.Type;
  * @category models
  * @since 0.6.0
  */
-export interface ReadResult {
+export interface ReadResult extends Engine.ReadResult {
     readonly bytes: Uint8Array;
     readonly eof: boolean;
 }
@@ -898,7 +900,7 @@ export interface ReadResult {
  * @category models
  * @since 0.1.0
  */
-export interface FileHandle {
+export interface FileHandle extends Engine.FileHandle {
     readonly [FileHandleId]: true;
     /** Reads up to `maximumBytes` from the cursor and advances it by the returned length. */
     readonly read: (maximumBytes: number) => Effect.Effect<Uint8Array, FsFailure>;
@@ -906,10 +908,22 @@ export interface FileHandle {
     readonly pread: (maximumBytes: number, offset: bigint) => Effect.Effect<ReadResult, FsFailure>;
     /** Writes at the cursor and advances it, or writes at end of file when opened for append. */
     readonly write: (bytes: Uint8Array) => Effect.Effect<number, FsFailure>;
-    /** Writes at `offset` without changing the cursor. Append mode does not affect positional writes. */
-    readonly pwrite: (bytes: Uint8Array, offset: bigint) => Effect.Effect<number, FsFailure>;
-    /** Moves the cursor and returns its new offset. `data` finds content and `hole` finds end of file. */
-    readonly seek: (offset: bigint, mode: SeekMode) => Effect.Effect<bigint, FsFailure>;
+    /**
+     * Writes at `offset` without changing the cursor. Append mode does not affect positional writes.
+     * The curried form is `pwrite(offset)(bytes)`.
+     */
+    readonly pwrite: {
+        (offset: bigint): (bytes: Uint8Array) => Effect.Effect<number, FsFailure>;
+        (bytes: Uint8Array, offset: bigint): Effect.Effect<number, FsFailure>;
+    };
+    /**
+     * Moves the cursor and returns its new offset. `data` finds content and `hole` finds end of file.
+     * The curried form is `seek(mode)(offset)`.
+     */
+    readonly seek: {
+        (mode: SeekMode): (offset: bigint) => Effect.Effect<bigint, FsFailure>;
+        (offset: bigint, mode: SeekMode): Effect.Effect<bigint, FsFailure>;
+    };
     /** Sets the file length without changing the cursor. */
     readonly truncate: (length: bigint) => Effect.Effect<void, FsFailure>;
     /** Reads metadata for the open file. */
@@ -1006,9 +1020,21 @@ export interface FileHandle {
  * @category models
  * @since 0.1.0
  */
-export interface Caller {
+export interface Caller extends Engine.EngineOperations {
     readonly [CallerId]: true;
-    /** The reference of the volume's root directory. */
+    /** Backing volume configuration; these are not subtree quotas. */
+    readonly limits: VolumeLimits;
+    /** Watches current authorized names, rebasing events when each change commits. */
+    readonly watch: (target: TargetInput, options?: WatchModule.CallerWatchOptions) => Effect.Effect<Stream.Stream<Change, FsFailure>, FsFailure, Scope.Scope>;
+    /**
+     * Narrows authority to a directory identity and resets the working directory. Absolute paths and symbolic
+     * links start at this root; `..` stops here. Nested roots retain their ancestor boundaries. References and
+     * direct handles check current membership on every use, including privileged callers. Root rename preserves
+     * authority; deletion permanently invalidates it. Existing hard links can share contents across roots.
+     * Independently scoped descendants and handles retain their own lifetime when their creator closes.
+     */
+    readonly withRoot: (directory: TargetInput) => Effect.Effect<Caller, FsFailure, Scope.Scope>;
+    /** The reference of the caller's visible root directory. */
     readonly root: Effect.Effect<ObjectReference, FsFailure>;
     /** The reference of a child of a directory, without following it. */
     readonly lookup: (entry: EntryInput) => Effect.Effect<ObjectReference, FsFailure>;
@@ -1036,8 +1062,14 @@ export interface Caller {
     readonly access: (target: TargetInput, bits?: number) => Effect.Effect<number, FsFailure>;
     /** The whole content of a regular file. */
     readonly readFile: (target: TargetInput) => Effect.Effect<Uint8Array, FsFailure>;
-    /** Writes a whole file in one operation, creating or replacing it as the options say. */
-    readonly writeFile: (entry: EntryInput, bytes: Uint8Array, options: WriteFileOptions) => Effect.Effect<void, FsFailure>;
+    /**
+     * Writes a whole file in one operation and returns its object reference, creating or replacing it as the options say.
+     * The curried form is `writeFile(bytes, options)(entry)`; the caller remains bound.
+     */
+    readonly writeFile: {
+        (bytes: Uint8Array, options: WriteFileOptions): (entry: EntryInput) => Effect.Effect<ObjectReference, FsFailure>;
+        (entry: EntryInput, bytes: Uint8Array, options: WriteFileOptions): Effect.Effect<ObjectReference, FsFailure>;
+    };
     /**
      * Opens a file. On a target, the file must exist and `create` is rejected. On an entry, the name is looked up
      * and created in one gate hold, and the result reports whether it was created.
@@ -1059,7 +1091,10 @@ export interface Caller {
     /** Creates a symbolic link to `target`, stored as given. */
     readonly symlink: (target: PathInput, entry: EntryInput, options?: SymlinkOptions) => Effect.Effect<ReferenceEntryResult, FsFailure>;
     /** Adds a name for an existing file or symbolic link. A path source follows a final symbolic link only when its target says so. */
-    readonly link: (source: TargetInput, entry: EntryInput) => Effect.Effect<ReferenceEntryResult, FsFailure>;
+    readonly link: {
+        (entry: EntryInput): (source: TargetInput) => Effect.Effect<ReferenceEntryResult, FsFailure>;
+        (source: TargetInput, entry: EntryInput): Effect.Effect<ReferenceEntryResult, FsFailure>;
+    };
     /** Removes a file or symbolic link. */
     readonly unlink: (entry: EntryInput) => Effect.Effect<DirectoryChange, FsFailure>;
     /** Removes an empty directory. */
@@ -1079,15 +1114,30 @@ export interface Caller {
         (entry: EntryInput, options: RemoveOptions): Effect.Effect<DirectoryChange | undefined, FsFailure>;
     };
     /** Moves an entry, replacing a compatible destination. */
-    readonly rename: (from: EntryInput, to: EntryInput) => Effect.Effect<RenameReferenceResult, FsFailure>;
+    readonly rename: {
+        (to: EntryInput): (from: EntryInput) => Effect.Effect<RenameReferenceResult, FsFailure>;
+        (from: EntryInput, to: EntryInput): Effect.Effect<RenameReferenceResult, FsFailure>;
+    };
     /** Sets the permission bits of a target. */
-    readonly chmod: (target: TargetInput, mode: number) => Effect.Effect<void, FsFailure>;
+    readonly chmod: {
+        (mode: number): (target: TargetInput) => Effect.Effect<void, FsFailure>;
+        (target: TargetInput, mode: number): Effect.Effect<void, FsFailure>;
+    };
     /** Changes the owner or group of a target. */
-    readonly chown: (target: TargetInput, owner: OwnerUpdate) => Effect.Effect<void, FsFailure>;
+    readonly chown: {
+        (owner: OwnerUpdate): (target: TargetInput) => Effect.Effect<void, FsFailure>;
+        (target: TargetInput, owner: OwnerUpdate): Effect.Effect<void, FsFailure>;
+    };
     /** Sets the access and modification times of a target. */
-    readonly utimes: (target: TargetInput, times: Times) => Effect.Effect<void, FsFailure>;
+    readonly utimes: {
+        (times: Times): (target: TargetInput) => Effect.Effect<void, FsFailure>;
+        (target: TargetInput, times: Times): Effect.Effect<void, FsFailure>;
+    };
     /** Sets the size of a regular file. */
-    readonly truncate: (target: TargetInput, length: bigint) => Effect.Effect<void, FsFailure>;
+    readonly truncate: {
+        (length: bigint): (target: TargetInput) => Effect.Effect<void, FsFailure>;
+        (target: TargetInput, length: bigint): Effect.Effect<void, FsFailure>;
+    };
     /**
      * Changes a target's size, owner, mode and times as one change. Every check passes before any attribute
      * applies, so a failure changes nothing. The attributes apply as size, owner, mode, then times, the POSIX
@@ -1096,7 +1146,10 @@ export interface Caller {
      * does so before it calls setattr, and passes the revision it read as `expected` so the change refuses a
      * target another change has moved.
      */
-    readonly setattr: (target: TargetInput, attributes: SetattrOptions) => Effect.Effect<void, FsFailure>;
+    readonly setattr: {
+        (attributes: SetattrOptions): (target: TargetInput) => Effect.Effect<void, FsFailure>;
+        (target: TargetInput, attributes: SetattrOptions): Effect.Effect<void, FsFailure>;
+    };
     /** A caller whose working directory is the target, released with the scope. */
     readonly withDirectory: (directory: TargetInput) => Effect.Effect<Caller, FsFailure, Scope.Scope>;
     /** A handle on a directory, released with the scope. */
@@ -1201,6 +1254,18 @@ export declare const WatchOptions: typeof WatchModule.WatchOptions;
  * @since 0.6.0
  */
 export type WatchOptions = typeof WatchOptions.Type;
+/**
+ * Caller watch publication and alias options.
+ * @category schemas
+ * @since 0.9.0
+ */
+export declare const CallerWatchOptions: typeof WatchModule.CallerWatchOptions;
+/**
+ * Options for a caller watch.
+ * @category models
+ * @since 0.9.0
+ */
+export type CallerWatchOptions = typeof CallerWatchOptions.Type;
 /**
  * Schema for the filesystem entry kinds reported by overlay summaries.
  *
@@ -1464,11 +1529,20 @@ export declare const Volume: Context.Service<Volume, Volume> & {
     /** A fresh empty volume. */
     readonly layer: (options?: VolumeOptions) => Layer.Layer<Volume, VfsError, Crypto.Crypto>;
     /** A fresh volume restored from a snapshot. */
-    readonly layerFromSnapshot: (snapshot: Snapshot, options?: VolumeOptions) => Layer.Layer<Volume, VfsError, Crypto.Crypto>;
+    readonly layerFromSnapshot: {
+        (options?: VolumeOptions): (snapshot: Snapshot) => Layer.Layer<Volume, VfsError, Crypto.Crypto>;
+        (snapshot: Snapshot, options?: VolumeOptions): Layer.Layer<Volume, VfsError, Crypto.Crypto>;
+    };
     /** A fresh volume built from a fixture. */
-    readonly layerFromFixture: (fixture: Fixture, options?: VolumeOptions) => Layer.Layer<Volume, VfsError, Crypto.Crypto>;
+    readonly layerFromFixture: {
+        (options?: VolumeOptions): (fixture: Fixture) => Layer.Layer<Volume, VfsError, Crypto.Crypto>;
+        (fixture: Fixture, options?: VolumeOptions): Layer.Layer<Volume, VfsError, Crypto.Crypto>;
+    };
     /** A writable overlay over a snapshot base. */
-    readonly layerOverlay: (base: Snapshot, options?: VolumeOptions) => Layer.Layer<Volume, VfsError, Crypto.Crypto>;
+    readonly layerOverlay: {
+        (options?: VolumeOptions): (base: Snapshot) => Layer.Layer<Volume, VfsError, Crypto.Crypto>;
+        (base: Snapshot, options?: VolumeOptions): Layer.Layer<Volume, VfsError, Crypto.Crypto>;
+    };
     /** A durable volume opened through the `LiveImageStore` in context; it shuts down with the layer's scope. */
     readonly layerLive: (options: LiveVolumeOptions) => Layer.Layer<Volume, VfsError, LiveImageStore | Crypto.Crypto>;
 };
@@ -1530,7 +1604,10 @@ export declare const Caller: Context.Service<Caller, Caller> & {
  * @category serialization
  * @since 0.6.0
  */
-export declare const encodeSnapshotStream: (snapshot: Snapshot, limits?: DecodeLimits) => Stream.Stream<Uint8Array, ImageFailure | ArgumentFailure>;
+export declare const encodeSnapshotStream: {
+    (limits?: DecodeLimits): (snapshot: Snapshot) => Stream.Stream<Uint8Array, ImageFailure | ArgumentFailure>;
+    (snapshot: Snapshot, limits?: DecodeLimits): Stream.Stream<Uint8Array, ImageFailure | ArgumentFailure>;
+};
 /**
  * Encodes a snapshot as owned UTF-8 bytes in the version 1 snapshot format.
  *
@@ -1571,7 +1648,10 @@ export declare const encodeSnapshotStream: (snapshot: Snapshot, limits?: DecodeL
  * @category serialization
  * @since 0.1.0
  */
-export declare const encodeSnapshot: (snapshot: Snapshot, limits?: DecodeLimits) => Effect.Effect<Uint8Array, ImageFailure | ArgumentFailure>;
+export declare const encodeSnapshot: {
+    (limits?: DecodeLimits): (snapshot: Snapshot) => Effect.Effect<Uint8Array, ImageFailure | ArgumentFailure>;
+    (snapshot: Snapshot, limits?: DecodeLimits): Effect.Effect<Uint8Array, ImageFailure | ArgumentFailure>;
+};
 /**
  * A sink that decodes a stream of version 1 snapshot chunks while enforcing
  * explicit input and payload limits.
@@ -1665,7 +1745,10 @@ export declare const decodeSnapshotSink: (limits: DecodeLimits) => Sink.Sink<Sna
  * @category serialization
  * @since 0.1.0
  */
-export declare const decodeSnapshot: (input: Uint8Array, limits: DecodeLimits) => Effect.Effect<Snapshot, ImageFailure | ArgumentFailure>;
+export declare const decodeSnapshot: {
+    (limits: DecodeLimits): (input: Uint8Array) => Effect.Effect<Snapshot, ImageFailure | ArgumentFailure>;
+    (input: Uint8Array, limits: DecodeLimits): Effect.Effect<Snapshot, ImageFailure | ArgumentFailure>;
+};
 /**
  * Computes an exact portable delta between two immutable snapshots.
  * Requires the platform-neutral `Crypto.Crypto` service for base identity. Provide
@@ -1704,7 +1787,10 @@ export declare const decodeSnapshot: (input: Uint8Array, limits: DecodeLimits) =
  * @category snapshots
  * @since 0.1.0
  */
-export declare const diffSnapshots: (base: Snapshot, target: Snapshot, limits?: SnapshotDeltaModel.SnapshotDeltaLimits) => Effect.Effect<SnapshotDeltaModel.SnapshotDelta, VfsError | PlatformError.PlatformError, Crypto.Crypto>;
+export declare const diffSnapshots: {
+    (target: Snapshot, limits?: SnapshotDeltaModel.SnapshotDeltaLimits): (base: Snapshot) => Effect.Effect<SnapshotDeltaModel.SnapshotDelta, VfsError | PlatformError.PlatformError, Crypto.Crypto>;
+    (base: Snapshot, target: Snapshot, limits?: SnapshotDeltaModel.SnapshotDeltaLimits): Effect.Effect<SnapshotDeltaModel.SnapshotDelta, VfsError | PlatformError.PlatformError, Crypto.Crypto>;
+};
 /**
  * Verifies an exact snapshot delta against its base and derives an owned path-oriented summary.
  * Requires the platform-neutral `Crypto.Crypto` service for base identity. Provide
@@ -1740,7 +1826,10 @@ export declare const diffSnapshots: (base: Snapshot, target: Snapshot, limits?:
  * @category snapshots
  * @since 0.1.0
  */
-export declare const inspectSnapshotDelta: (base: Snapshot, delta: SnapshotDeltaModel.SnapshotDelta, options?: SnapshotDeltaModel.SnapshotChangesOptions, limits?: SnapshotDeltaModel.SnapshotDeltaLimits) => Effect.Effect<ReadonlyArray<SnapshotDeltaModel.SnapshotChange>, VfsError | PlatformError.PlatformError, Crypto.Crypto>;
+export declare const inspectSnapshotDelta: {
+    (delta: SnapshotDeltaModel.SnapshotDelta, options?: SnapshotDeltaModel.SnapshotChangesOptions, limits?: SnapshotDeltaModel.SnapshotDeltaLimits): (base: Snapshot) => Effect.Effect<ReadonlyArray<SnapshotDeltaModel.SnapshotChange>, VfsError | PlatformError.PlatformError, Crypto.Crypto>;
+    (base: Snapshot, delta: SnapshotDeltaModel.SnapshotDelta, options?: SnapshotDeltaModel.SnapshotChangesOptions, limits?: SnapshotDeltaModel.SnapshotDeltaLimits): Effect.Effect<ReadonlyArray<SnapshotDeltaModel.SnapshotChange>, VfsError | PlatformError.PlatformError, Crypto.Crypto>;
+};
 /**
  * Applies an exact delta to its semantically matching base and returns a new snapshot.
  * Requires the platform-neutral `Crypto.Crypto` service for base identity. Provide
@@ -1781,7 +1870,10 @@ export declare const inspectSnapshotDelta: (base: Snapshot, delta: SnapshotDelta
  * @category snapshots
  * @since 0.1.0
  */
-export declare const applySnapshotDelta: (base: Snapshot, delta: SnapshotDeltaModel.SnapshotDelta, limits?: SnapshotDeltaModel.SnapshotDeltaLimits) => Effect.Effect<Snapshot, VfsError | PlatformError.PlatformError, Crypto.Crypto>;
+export declare const applySnapshotDelta: {
+    (delta: SnapshotDeltaModel.SnapshotDelta, limits?: SnapshotDeltaModel.SnapshotDeltaLimits): (base: Snapshot) => Effect.Effect<Snapshot, VfsError | PlatformError.PlatformError, Crypto.Crypto>;
+    (base: Snapshot, delta: SnapshotDeltaModel.SnapshotDelta, limits?: SnapshotDeltaModel.SnapshotDeltaLimits): Effect.Effect<Snapshot, VfsError | PlatformError.PlatformError, Crypto.Crypto>;
+};
 /**
  * Merges two snapshot deltas that share one base into a single delta, reporting path-level conflicts as data.
  *
@@ -1819,7 +1911,7 @@ export declare const applySnapshotDelta: (base: Snapshot, delta: SnapshotDeltaMo
  *   )
  *
  *   // Disjoint changes merge without conflicts; the delta applies to the shared base.
- *   const merged = yield* Vfs.fromSnapshot(yield* Vfs.applySnapshotDelta(base, result.delta))
+ *   const merged = yield* Vfs.applySnapshotDelta(base, result.delta).pipe(Effect.flatMap(Vfs.fromSnapshot()))
  *   const reader = yield* merged.caller()
  *
  *   return [result.conflicts.length, new TextDecoder().decode(yield* reader.readFile("/shared.txt"))]
@@ -1833,7 +1925,10 @@ export declare const applySnapshotDelta: (base: Snapshot, delta: SnapshotDeltaMo
  * @category snapshots
  * @since 0.8.0
  */
-export declare const mergeSnapshotDeltas: (base: Snapshot, ours: SnapshotDeltaModel.SnapshotDelta, theirs: SnapshotDeltaModel.SnapshotDelta, options?: SnapshotDeltaModel.MergeOptions) => Effect.Effect<SnapshotDeltaModel.MergeResult, VfsError | PlatformError.PlatformError, Crypto.Crypto>;
+export declare const mergeSnapshotDeltas: {
+    (ours: SnapshotDeltaModel.SnapshotDelta, theirs: SnapshotDeltaModel.SnapshotDelta, options?: SnapshotDeltaModel.MergeOptions): (base: Snapshot) => Effect.Effect<SnapshotDeltaModel.MergeResult, VfsError | PlatformError.PlatformError, Crypto.Crypto>;
+    (base: Snapshot, ours: SnapshotDeltaModel.SnapshotDelta, theirs: SnapshotDeltaModel.SnapshotDelta, options?: SnapshotDeltaModel.MergeOptions): Effect.Effect<SnapshotDeltaModel.MergeResult, VfsError | PlatformError.PlatformError, Crypto.Crypto>;
+};
 /**
  * Creates an Effect Schema codec between owned bytes and opaque snapshot deltas.
  * Omission uses `SnapshotDeltaLimits.default`.
@@ -2031,7 +2126,10 @@ export declare const make: (options?: VolumeOptions) => Effect.Effect<Volume, Vf
  * @category snapshots
  * @since 0.6.0
  */
-export declare const snapshotEntries: (snapshot: Snapshot, root: PathInput) => Stream.Stream<Fixture["entries"][number], FsFailure | ImageFailure>;
+export declare const snapshotEntries: {
+    (root: PathInput): (snapshot: Snapshot) => Stream.Stream<Fixture["entries"][number], FsFailure | ImageFailure>;
+    (snapshot: Snapshot, root: PathInput): Stream.Stream<Fixture["entries"][number], FsFailure | ImageFailure>;
+};
 /**
  * Restores a fresh volume from an opaque snapshot under the supplied destination limits.
  *
@@ -2074,7 +2172,10 @@ export declare const snapshotEntries: (snapshot: Snapshot, root: PathInput) => S
  * @category constructors
  * @since 0.1.0
  */
-export declare const fromSnapshot: (snapshot: Snapshot, options?: VolumeOptions) => Effect.Effect<Volume, VfsError, Crypto.Crypto>;
+export declare const fromSnapshot: {
+    (options?: VolumeOptions): (snapshot: Snapshot) => Effect.Effect<Volume, VfsError, Crypto.Crypto>;
+    (snapshot: Snapshot, options?: VolumeOptions): Effect.Effect<Volume, VfsError, Crypto.Crypto>;
+};
 /**
  * Creates an isolated writable volume relative to one immutable snapshot base.
  *
@@ -2126,7 +2227,10 @@ export declare const fromSnapshot: (snapshot: Snapshot, options?: VolumeOptions)
  * @category constructors
  * @since 0.1.0
  */
-export declare const makeOverlay: (base: Snapshot, options?: VolumeOptions) => Effect.Effect<OverlayVolume, VfsError, Crypto.Crypto>;
+export declare const makeOverlay: {
+    (options?: VolumeOptions): (base: Snapshot) => Effect.Effect<OverlayVolume, VfsError, Crypto.Crypto>;
+    (base: Snapshot, options?: VolumeOptions): Effect.Effect<OverlayVolume, VfsError, Crypto.Crypto>;
+};
 /**
  * Builds a fresh volume from a validated final-state fixture.
  *
@@ -2167,5 +2271,8 @@ export declare const makeOverlay: (base: Snapshot, options?: VolumeOptions) => E
  * @category constructors
  * @since 0.1.0
  */
-export declare const fromFixture: (fixture: Fixture, options?: VolumeOptions) => Effect.Effect<Volume, VfsError, Crypto.Crypto>;
+export declare const fromFixture: {
+    (options?: VolumeOptions): (fixture: Fixture) => Effect.Effect<Volume, VfsError, Crypto.Crypto>;
+    (fixture: Fixture, options?: VolumeOptions): Effect.Effect<Volume, VfsError, Crypto.Crypto>;
+};
 //# sourceMappingURL=VirtualFileSystem.d.ts.map