@effect-vfs/core 0.5.0 → 0.7.0

package/dist/Volume.d.ts

@@ -0,0 +1,211 @@
+import * as Order from "effect/Order";
+import * as Schema from "effect/Schema";
+import { BytePath } from "./BytePath.js";
+/**
+ * Brand key that marks a volume.
+ *
+ * @category type IDs
+ * @since 0.6.0
+ */
+export declare const VolumeId: unique symbol;
+/**
+ * Brand key that marks a volume.
+ *
+ * @category type IDs
+ * @since 0.6.0
+ */
+export type VolumeId = typeof VolumeId;
+/**
+ * Schema for the failure boundary a volume's committed mutations survive.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const VolumeDurability: Schema.Literals<readonly ["memory-only", "survives-process-crash", "survives-operating-system-crash", "survives-power-loss"]>;
+/**
+ * The failure boundary a volume's committed mutations survive.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type VolumeDurability = typeof VolumeDurability.Type;
+/**
+ * Weakest-to-strongest ordering for volume durability guarantees.
+ *
+ * @category ordering
+ * @since 0.6.0
+ */
+export declare const VolumeDurabilityOrder: Order.Order<VolumeDurability>;
+/**
+ * Returns whether `actual` survives at least the failure boundary required by `required`.
+ *
+ * @category predicates
+ * @since 0.6.0
+ */
+export declare const isVolumeDurabilityAtLeast: (actual: VolumeDurability, required: VolumeDurability) => boolean;
+/**
+ * Schema for a volume identity: 128 bits as lowercase hexadecimal, stable
+ * across restarts of a durable volume.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const VolumeIdentity: Schema.brand<Schema.String, "@effect-vfs/core/VolumeIdentity">;
+/**
+ * A volume identity.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type VolumeIdentity = typeof VolumeIdentity.Type;
+/**
+ * Schema for a volume incarnation: 128 bits as lowercase hexadecimal, minted
+ * on every construction.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const VolumeIncarnation: Schema.brand<Schema.String, "@effect-vfs/core/VolumeIncarnation">;
+/**
+ * A volume incarnation.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type VolumeIncarnation = typeof VolumeIncarnation.Type;
+/**
+ * Schema for a reference key: the serialisable name of one object in one
+ * volume, for adapters that must name an object outside the process, such as
+ * an NFS filehandle.
+ *
+ * **Details**
+ *
+ * `identity` is the volume's identity and `epoch` the inode-number namespace
+ * the object was numbered in, both as 16 bytes encoded as base64; `ino` is
+ * the object's inode number, encoded as a decimal string; `tag` is 16 bytes of
+ * HMAC-SHA-256 over the identity, epoch and inode number under a secret only
+ * the volume holds, encoded as base64. Inode numbers are small and sequential,
+ * so the tag is what keeps a holder of one key from naming a neighbouring
+ * object: a key with another inode number or an altered tag fails
+ * `InvalidReference`. A volume mints a new epoch and secret whenever its inode
+ * numbers start over: a new volume, a snapshot or fixture restore, and an
+ * overlay. A live volume keeps both across a reopen, so its keys outlive the
+ * process. Turning a key into bytes of a fixed layout stays the adapter's job.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const ReferenceKey: Schema.Struct<{
+    readonly identity: Schema.Uint8ArrayFromBase64;
+    readonly epoch: Schema.Uint8ArrayFromBase64;
+    readonly ino: Schema.BigIntFromString;
+    readonly tag: Schema.Uint8ArrayFromBase64;
+}>;
+/**
+ * The serialisable name of one object in one volume.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type ReferenceKey = typeof ReferenceKey.Type;
+/**
+ * Schema for volume construction options.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const VolumeOptions: Schema.Struct<{
+    readonly identity: Schema.optionalKey<Schema.brand<Schema.String, "@effect-vfs/core/VolumeIdentity">>;
+    readonly maxEntries: Schema.optionalKey<Schema.Natural>;
+    readonly maxPendingOperations: Schema.optionalKey<Schema.Int>;
+    readonly maxWatchEvents: Schema.optionalKey<Schema.Int>;
+    readonly maxBytes: Schema.optionalKey<Schema.ByteSize>;
+    readonly maxFileBytes: Schema.optionalKey<Schema.ByteSize>;
+    readonly maxPathBytes: Schema.optionalKey<Schema.ByteSize>;
+}>;
+/**
+ * Volume construction options.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type VolumeOptions = typeof VolumeOptions.Type;
+/**
+ * Schema for the kinds of filesystem entry an overlay summary reports.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const OverlayNodeKind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+/**
+ * A kind of filesystem entry in an overlay summary.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type OverlayNodeKind = typeof OverlayNodeKind.Type;
+/**
+ * Schema for one way an overlay entry differs from its base.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const OverlayDifference: Schema.Literals<readonly ["content", "mode", "uid", "gid", "atimeNs", "mtimeNs", "ctimeNs", "birthtimeNs"]>;
+/**
+ * One way an overlay entry differs from its base.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type OverlayDifference = typeof OverlayDifference.Type;
+/**
+ * Schema for one summarised change between an overlay and its base.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const OverlayChange: Schema.Union<readonly [Schema.TaggedStruct<"Added", {
+    readonly path: Schema.declare<BytePath, BytePath>;
+    readonly kind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+}>, Schema.TaggedStruct<"Removed", {
+    readonly path: Schema.declare<BytePath, BytePath>;
+    readonly kind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+}>, Schema.TaggedStruct<"Replaced", {
+    readonly path: Schema.declare<BytePath, BytePath>;
+    readonly beforeKind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+    readonly afterKind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+    readonly differences: Schema.$Array<Schema.Literals<readonly ["content", "mode", "uid", "gid", "atimeNs", "mtimeNs", "ctimeNs", "birthtimeNs"]>>;
+}>, Schema.TaggedStruct<"Renamed", {
+    readonly from: Schema.declare<BytePath, BytePath>;
+    readonly to: Schema.declare<BytePath, BytePath>;
+    readonly kind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+    readonly differences: Schema.$Array<Schema.Literals<readonly ["content", "mode", "uid", "gid", "atimeNs", "mtimeNs", "ctimeNs", "birthtimeNs"]>>;
+}>, Schema.TaggedStruct<"Updated", {
+    readonly path: Schema.declare<BytePath, BytePath>;
+    readonly kind: Schema.Literals<readonly ["directory", "file", "symlink"]>;
+    readonly differences: Schema.$Array<Schema.Literals<readonly ["content", "mode", "uid", "gid", "atimeNs", "mtimeNs", "ctimeNs", "birthtimeNs"]>>;
+}>]>;
+/**
+ * One summarised change between an overlay and its base.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type OverlayChange = typeof OverlayChange.Type;
+/**
+ * Schema for the options of an overlay change summary.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const OverlayChangesOptions: Schema.Struct<{
+    readonly includeTimestamps: Schema.optionalKey<Schema.Boolean>;
+}>;
+/**
+ * Options of an overlay change summary.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type OverlayChangesOptions = typeof OverlayChangesOptions.Type;
+//# sourceMappingURL=Volume.d.ts.map

package/dist/Volume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Volume.d.ts","sourceRoot":"","sources":["../src/Volume.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAIxC;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,EAAE,OAAO,MAA8C,CAAA;AAE5E;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAA;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,+HAK3B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAS3D;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,KAAK,CAAC,gBAAgB,CAG/D,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,WAAY,gBAAgB,YAAY,gBAAgB,KAAG,OACnD,CAAA;AAE9C;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,gEAA+D,CAAA;AAE1F;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAEvD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,mEAAkE,CAAA;AAEhG;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAA;AAO7D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,YAAY;;;;;EAKvB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;EAsBxB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,4DAAoD,CAAA;AAEhF;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC,IAAI,CAAA;AAEzD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,6GAS5B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAA;AAM7D;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;IAgBxB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;EAEhC,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAAG,OAAO,qBAAqB,CAAC,IAAI,CAAA"}

package/dist/Volume.js

@@ -0,0 +1,172 @@
+/**
+ * Volume identity brands and schemas: durability, identity tokens, reference
+ * keys, construction options, and the change summaries an overlay volume
+ * reports.
+ *
+ * @since 0.6.0
+ */
+import * as ByteSize from "effect/ByteSize";
+import * as Order from "effect/Order";
+import * as Schema from "effect/Schema";
+import { BytePath } from "./BytePath.js";
+import { Hex128 } from "./internal/hex128.js";
+import { MAX_FILE_BYTES, MAX_INO, ROOT_INO } from "./internal/volumeState.js";
+/**
+ * Brand key that marks a volume.
+ *
+ * @category type IDs
+ * @since 0.6.0
+ */
+export const VolumeId = Symbol.for("@effect-vfs/core/Volume");
+/**
+ * Schema for the failure boundary a volume's committed mutations survive.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export const VolumeDurability = Schema.Literals([
+    "memory-only",
+    "survives-process-crash",
+    "survives-operating-system-crash",
+    "survives-power-loss"
+]);
+const durabilityRank = {
+    "memory-only": 0,
+    "survives-process-crash": 1,
+    "survives-operating-system-crash": 2,
+    "survives-power-loss": 3
+};
+/**
+ * Weakest-to-strongest ordering for volume durability guarantees.
+ *
+ * @category ordering
+ * @since 0.6.0
+ */
+export const VolumeDurabilityOrder = Order.mapInput(Order.Number, (durability) => durabilityRank[durability]);
+/**
+ * Returns whether `actual` survives at least the failure boundary required by `required`.
+ *
+ * @category predicates
+ * @since 0.6.0
+ */
+export const isVolumeDurabilityAtLeast = (actual, required) => VolumeDurabilityOrder(actual, required) >= 0;
+/**
+ * Schema for a volume identity: 128 bits as lowercase hexadecimal, stable
+ * across restarts of a durable volume.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export const VolumeIdentity = Hex128.pipe(Schema.brand("@effect-vfs/core/VolumeIdentity"));
+/**
+ * Schema for a volume incarnation: 128 bits as lowercase hexadecimal, minted
+ * on every construction.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export const VolumeIncarnation = Hex128.pipe(Schema.brand("@effect-vfs/core/VolumeIncarnation"));
+// 128 bits as bytes, carried as base64 like every other byte field on a wire.
+const KeyBytes = Schema.Uint8ArrayFromBase64.check(Schema.makeFilter((bytes) => bytes.length === 16 ? undefined : "must hold exactly 16 bytes"));
+/**
+ * Schema for a reference key: the serialisable name of one object in one
+ * volume, for adapters that must name an object outside the process, such as
+ * an NFS filehandle.
+ *
+ * **Details**
+ *
+ * `identity` is the volume's identity and `epoch` the inode-number namespace
+ * the object was numbered in, both as 16 bytes encoded as base64; `ino` is
+ * the object's inode number, encoded as a decimal string; `tag` is 16 bytes of
+ * HMAC-SHA-256 over the identity, epoch and inode number under a secret only
+ * the volume holds, encoded as base64. Inode numbers are small and sequential,
+ * so the tag is what keeps a holder of one key from naming a neighbouring
+ * object: a key with another inode number or an altered tag fails
+ * `InvalidReference`. A volume mints a new epoch and secret whenever its inode
+ * numbers start over: a new volume, a snapshot or fixture restore, and an
+ * overlay. A live volume keeps both across a reopen, so its keys outlive the
+ * process. Turning a key into bytes of a fixed layout stays the adapter's job.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export const ReferenceKey = Schema.Struct({
+    identity: KeyBytes,
+    epoch: KeyBytes,
+    ino: Schema.BigIntFromString.check(Schema.isBetweenBigInt({ minimum: BigInt(ROOT_INO), maximum: BigInt(MAX_INO) })),
+    tag: KeyBytes
+});
+/**
+ * Schema for volume construction options.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export const VolumeOptions = Schema.Struct({
+    identity: Schema.optionalKey(VolumeIdentity),
+    maxEntries: Schema.optionalKey(Schema.Natural),
+    maxPendingOperations: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))),
+    maxWatchEvents: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(2))),
+    maxBytes: Schema.optionalKey(Schema.ByteSize),
+    maxFileBytes: Schema.optionalKey(Schema.ByteSize.check(Schema.makeFilter((size) => ByteSize.isLessThanOrEqualTo(size, ByteSize.bytes(MAX_FILE_BYTES))
+        ? undefined
+        : `must be at most ${MAX_FILE_BYTES} bytes`))),
+    maxPathBytes: Schema.optionalKey(Schema.ByteSize.check(Schema.makeFilter((size) => ByteSize.isGreaterThanOrEqualTo(size, ByteSize.bytes(1)) ? undefined : "must be at least 1 byte")))
+});
+/**
+ * Schema for the kinds of filesystem entry an overlay summary reports.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export const OverlayNodeKind = Schema.Literals(["directory", "file", "symlink"]);
+/**
+ * Schema for one way an overlay entry differs from its base.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export const OverlayDifference = Schema.Literals([
+    "content",
+    "mode",
+    "uid",
+    "gid",
+    "atimeNs",
+    "mtimeNs",
+    "ctimeNs",
+    "birthtimeNs"
+]);
+const OverlayDifferences = Schema.Array(OverlayDifference);
+const NonEmptyOverlayDifferences = OverlayDifferences.check(Schema.isMinLength(1));
+/**
+ * Schema for one summarised change between an overlay and its base.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export const OverlayChange = Schema.Union([
+    Schema.TaggedStruct("Added", { path: BytePath, kind: OverlayNodeKind }),
+    Schema.TaggedStruct("Removed", { path: BytePath, kind: OverlayNodeKind }),
+    Schema.TaggedStruct("Replaced", {
+        path: BytePath,
+        beforeKind: OverlayNodeKind,
+        afterKind: OverlayNodeKind,
+        differences: OverlayDifferences
+    }),
+    Schema.TaggedStruct("Renamed", {
+        from: BytePath,
+        to: BytePath,
+        kind: OverlayNodeKind,
+        differences: OverlayDifferences
+    }),
+    Schema.TaggedStruct("Updated", { path: BytePath, kind: OverlayNodeKind, differences: NonEmptyOverlayDifferences })
+]);
+/**
+ * Schema for the options of an overlay change summary.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export const OverlayChangesOptions = Schema.Struct({
+    includeTimestamps: Schema.optionalKey(Schema.Boolean)
+});

package/dist/Watch.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Change events published by a volume's watch stream, and the options that
+ * narrow a watch to one object's subtree.
+ *
+ * @since 0.6.0
+ */
+import * as Schema from "effect/Schema";
+import { BytePath } from "./BytePath.js";
+import type { ObjectReference } from "./VirtualFileSystem.js";
+/**
+ * Schema for one committed change. `Rescan` means the subscriber lost events
+ * and must rescan what it watches, whose path it names; events are never
+ * replayed.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const Change: Schema.TaggedUnion<{
+    readonly Create: Schema.TaggedStruct<"Create", {
+        readonly path: Schema.declare<BytePath, BytePath>;
+    }>;
+    readonly Remove: Schema.TaggedStruct<"Remove", {
+        readonly path: Schema.declare<BytePath, BytePath>;
+    }>;
+    readonly Rescan: Schema.TaggedStruct<"Rescan", {
+        readonly path: Schema.declare<BytePath, BytePath>;
+    }>;
+    readonly Update: Schema.TaggedStruct<"Update", {
+        readonly path: Schema.declare<BytePath, BytePath>;
+    }>;
+}>;
+/**
+ * One committed change observed through a watch subscription.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type Change = typeof Change.Type;
+/**
+ * Schema for the options of a watch. `scope` narrows the watch to one object
+ * and, when `recursive` is not `false`, everything below it; without a scope
+ * the watch covers the volume.
+ *
+ * **Details**
+ *
+ * The scope is an object, not a path: a watch on a directory keeps receiving
+ * its changes, at their current paths, after the directory or one of its
+ * ancestors is renamed. Each change is tested against the scope on its own,
+ * so a move out of the scope arrives as `Remove` and a move into it as
+ * `Create`. With `recursive: false` only the object itself and its direct
+ * children are reported. When the object's last name is removed the watch
+ * reports `Remove` for it and ends.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export declare const WatchOptions: Schema.Struct<{
+    readonly scope: Schema.optionalKey<Schema.declare<ObjectReference, ObjectReference>>;
+    readonly recursive: Schema.optionalKey<Schema.Boolean>;
+}>;
+/**
+ * Options of a watch.
+ *
+ * @category models
+ * @since 0.6.0
+ */
+export type WatchOptions = typeof WatchOptions.Type;
+//# sourceMappingURL=Watch.d.ts.map

package/dist/Watch.d.ts.map

@@ -0,0 +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"}

package/dist/Watch.js

@@ -0,0 +1,46 @@
+/**
+ * Change events published by a volume's watch stream, and the options that
+ * narrow a watch to one object's subtree.
+ *
+ * @since 0.6.0
+ */
+import * as Schema from "effect/Schema";
+import { BytePath } from "./BytePath.js";
+import { ObjectReferenceSchema } from "./Caller.js";
+/**
+ * Schema for one committed change. `Rescan` means the subscriber lost events
+ * and must rescan what it watches, whose path it names; events are never
+ * replayed.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export const Change = Schema.TaggedUnion({
+    Create: { path: BytePath },
+    Update: { path: BytePath },
+    Remove: { path: BytePath },
+    Rescan: { path: BytePath }
+});
+/**
+ * Schema for the options of a watch. `scope` narrows the watch to one object
+ * and, when `recursive` is not `false`, everything below it; without a scope
+ * the watch covers the volume.
+ *
+ * **Details**
+ *
+ * The scope is an object, not a path: a watch on a directory keeps receiving
+ * its changes, at their current paths, after the directory or one of its
+ * ancestors is renamed. Each change is tested against the scope on its own,
+ * so a move out of the scope arrives as `Remove` and a move into it as
+ * `Create`. With `recursive: false` only the object itself and its direct
+ * children are reported. When the object's last name is removed the watch
+ * reports `Remove` for it and ends.
+ *
+ * @category schemas
+ * @since 0.6.0
+ */
+export const WatchOptions = Schema.Struct({
+    // Naming the type keeps `ObjectReference` in the rendered `WatchOptions` type.
+    scope: Schema.optionalKey(ObjectReferenceSchema),
+    recursive: Schema.optionalKey(Schema.Boolean)
+});

package/dist/index.d.ts

@@ -16,7 +16,7 @@ export * as VirtualFileSystem from "./VirtualFileSystem.js";
  * @category re-exports
  * @since 0.4.0
  */
-export * as VirtualFileSystemError from "./VirtualFileSystemError.js";
+export * as VfsError from "./VfsError.js";
 /**
  * Live volume image boundary for storage adapters.
  *
@@ -24,4 +24,59 @@ export * as VirtualFileSystemError from "./VirtualFileSystemError.js";
  * @since 0.4.0
  */
 export * as LiveVolume from "./LiveVolume.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as BytePath from "./BytePath.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Caller from "./Caller.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as FileHandle from "./FileHandle.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Fixture from "./Fixture.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Metadata from "./Metadata.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Snapshot from "./Snapshot.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as SnapshotDelta from "./SnapshotDelta.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Target from "./Target.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Testing from "./Testing.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Volume from "./Volume.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Watch from "./Watch.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,sBAAsB,MAAM,6BAA6B,CAAA;AAErE;;;;;GAKG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,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"}

package/dist/index.js

@@ -16,7 +16,7 @@ export * as VirtualFileSystem from "./VirtualFileSystem.js";
  * @category re-exports
  * @since 0.4.0
  */
-export * as VirtualFileSystemError from "./VirtualFileSystemError.js";
+export * as VfsError from "./VfsError.js";
 /**
  * Live volume image boundary for storage adapters.
  *
@@ -24,3 +24,58 @@ export * as VirtualFileSystemError from "./VirtualFileSystemError.js";
  * @since 0.4.0
  */
 export * as LiveVolume from "./LiveVolume.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as BytePath from "./BytePath.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Caller from "./Caller.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as FileHandle from "./FileHandle.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Fixture from "./Fixture.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Metadata from "./Metadata.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Snapshot from "./Snapshot.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as SnapshotDelta from "./SnapshotDelta.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Target from "./Target.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Testing from "./Testing.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Volume from "./Volume.js";
+/**
+ * @since 0.6.0
+ * @category re-exports
+ */
+export * as Watch from "./Watch.js";