@effect-vfs/core 0.5.0 → 0.7.0

package/dist/internal/volumeState.d.ts

@@ -0,0 +1,111 @@
+import * as Brand from "effect/Brand";
+import * as Effect from "effect/Effect";
+import * as Order from "effect/Order";
+import type { Metadata } from "../Metadata.js";
+import * as InodeTable from "./inodeTable.js";
+import type { StoredMetadata } from "./metadata.js";
+/** @internal */
+export type Ino = number & Brand.Brand<"@effect-vfs/core/Ino">;
+/** @internal */
+export declare const Ino: Brand.Constructor<Ino>;
+/** @internal */
+export declare const ROOT_INO: Ino;
+/** @internal */
+export declare const MAX_INO: number;
+/** @internal */
+export declare const MAX_FILE_BYTES = 4294967295;
+/** @internal */
+export declare const WALK_YIELD_INTERVAL = 128;
+/** @internal */
+export interface Link {
+    readonly parent: Ino;
+    readonly name: string;
+}
+/** @internal */
+export type NodeMetadata = Omit<Metadata, "revision">;
+/** @internal */
+export interface Directory {
+    readonly kind: "directory";
+    readonly ino: Ino;
+    readonly parent: Ino;
+    readonly name: string;
+    readonly entries: ReadonlyMap<string, Ino>;
+    readonly metadata: NodeMetadata;
+    readonly revision: bigint;
+}
+/** @internal */
+export interface RegularFile {
+    readonly kind: "file";
+    readonly ino: Ino;
+    readonly data: Uint8Array;
+    readonly links: ReadonlyArray<Link>;
+    readonly metadata: NodeMetadata;
+    readonly revision: bigint;
+}
+/** @internal */
+export interface SymbolicLink {
+    readonly kind: "symlink";
+    readonly ino: Ino;
+    readonly target: Uint8Array;
+    readonly links: ReadonlyArray<Link>;
+    readonly metadata: NodeMetadata;
+    readonly revision: bigint;
+}
+/** @internal */
+export type Node = Directory | RegularFile | SymbolicLink;
+/** @internal */
+export interface VolumeState {
+    readonly inodes: InodeTable.InodeTable<Node>;
+    readonly open: ReadonlyMap<Ino, number>;
+    readonly nextInode: Ino;
+    readonly revision: bigint;
+    readonly entries: number;
+    readonly usedBytes: bigint;
+}
+/** @internal */
+export declare const getNode: (state: VolumeState, ino: Ino) => Node | undefined;
+/** @internal */
+export declare const byIno: Order.Order<Node>;
+/** @internal */
+export declare const byEntryName: Order.Order<readonly [string, Ino]>;
+/** @internal */
+export declare const payloadOf: (node: Node) => Uint8Array | undefined;
+/** @internal */
+export declare const directoryMetadata: (ino: bigint, uid: number, gid: number, mode: number, now: bigint) => NodeMetadata;
+/** @internal */
+export declare const emptyRoot: (now: bigint) => Directory;
+/** @internal */
+export declare const storedMetadata: (metadata: NodeMetadata) => StoredMetadata;
+/** @internal */
+export declare const reachableNodes: (state: VolumeState) => Effect.Effect<Node[], never, never>;
+/** @internal */
+export declare const reachableValue: (source: VolumeState) => Effect.Effect<{
+    state: VolumeState;
+    largestFile: number;
+}, never, never>;
+/** @internal */
+export type NodeSpec = {
+    readonly kind: "directory";
+    readonly ino: Ino;
+    readonly parent: Ino;
+    readonly name: string;
+    readonly metadata: StoredMetadata;
+    readonly revision: bigint;
+} | {
+    readonly kind: "file";
+    readonly ino: Ino;
+    readonly links: ReadonlyArray<Link>;
+    readonly data: Uint8Array;
+    readonly metadata: StoredMetadata;
+    readonly revision: bigint;
+} | {
+    readonly kind: "symlink";
+    readonly ino: Ino;
+    readonly links: ReadonlyArray<Link>;
+    readonly target: Uint8Array;
+    readonly metadata: StoredMetadata;
+    readonly revision: bigint;
+};
+/** @internal */
+export declare const assemble: (specs: ReadonlyArray<NodeSpec>) => VolumeState;
+//# sourceMappingURL=volumeState.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"volumeState.d.ts","sourceRoot":"","sources":["../../src/internal/volumeState.ts"],"names":[],"mappings":"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"}

package/dist/internal/volumeState.js

@@ -0,0 +1,202 @@
+import * as Brand from "effect/Brand";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Order from "effect/Order";
+import * as InodeTable from "./inodeTable.js";
+/** @internal */
+export const Ino = Brand.nominal();
+/** @internal */
+export const ROOT_INO = Ino(1);
+// The largest inode number a value holds. The allocator resumes one above it and must stay exactly representable,
+// since the inode table is keyed by a number.
+/** @internal */
+export const MAX_INO = Number.MAX_SAFE_INTEGER - 1;
+// File sizes fit an unsigned 32-bit count in the volume and its public options.
+/** @internal */
+export const MAX_FILE_BYTES = 0xffffffff;
+// Nodes walked between yields. Whole-tree reads are one synchronous tick otherwise, which
+// starves the event loop and leaves nothing for interruption to act on.
+/** @internal */
+export const WALK_YIELD_INTERVAL = 128;
+/** @internal */
+export const getNode = (state, ino) => InodeTable.get(state.inodes, ino);
+/** @internal */
+export const byIno = Order.mapInput(Order.Number, (node) => node.ino);
+/** @internal */
+export const byEntryName = Order.mapInput(Order.String, ([name]) => name);
+const inNameOrder = (entries) => {
+    let previous;
+    for (const name of entries.keys()) {
+        if (previous !== undefined && previous > name)
+            return false;
+        previous = name;
+    }
+    return true;
+};
+const inEntryOrder = (directory) => inNameOrder(directory.entries)
+    ? directory
+    : { ...directory, entries: new Map([...directory.entries].sort(byEntryName)) };
+/** @internal */
+export const payloadOf = (node) => node.kind === "file" ? node.data : node.kind === "symlink" ? node.target : undefined;
+/** @internal */
+export const directoryMetadata = (ino, uid, gid, mode, now) => ({
+    kind: "directory",
+    ino,
+    uid,
+    gid,
+    mode,
+    nlink: 2,
+    size: 0n,
+    atimeNs: now,
+    mtimeNs: now,
+    ctimeNs: now,
+    birthtimeNs: now
+});
+/** @internal */
+export const emptyRoot = (now) => ({
+    kind: "directory",
+    ino: ROOT_INO,
+    parent: ROOT_INO,
+    name: "",
+    entries: new Map(),
+    metadata: directoryMetadata(BigInt(ROOT_INO), 0, 0, 0o755, now),
+    revision: 1n
+});
+/** @internal */
+export const storedMetadata = (metadata) => ({
+    uid: metadata.uid,
+    gid: metadata.gid,
+    mode: metadata.mode,
+    atimeNs: metadata.atimeNs,
+    mtimeNs: metadata.mtimeNs,
+    ctimeNs: metadata.ctimeNs,
+    birthtimeNs: metadata.birthtimeNs
+});
+/** @internal */
+export const reachableNodes = Effect.fnUntraced(function* (state) {
+    const nodes = [];
+    const seen = new Set([ROOT_INO]);
+    const pending = [ROOT_INO];
+    for (let index = 0; index < pending.length; index++) {
+        if (index % WALK_YIELD_INTERVAL === 0)
+            yield* Effect.yieldNow;
+        const ino = pending[index];
+        const node = ino === undefined ? undefined : getNode(state, ino);
+        if (node === undefined)
+            continue;
+        nodes.push(node);
+        if (node.kind !== "directory")
+            continue;
+        for (const child of node.entries.values()) {
+            if (seen.has(child))
+                continue;
+            seen.add(child);
+            pending.push(child);
+        }
+    }
+    return nodes;
+});
+const atFirstRevision = (node) => node.revision === 1n ? node : { ...node, revision: 1n };
+// A value holding only what a name reaches, and the size of its largest file. A captured value keeps unlinked
+// open files and detached directories a handle holds; a volume started from it has neither handle, so it starts
+// without them. Each directory lists its entries in the byte order of their names, as a decoded tree's do, so a
+// volume lists the same whether it was restored from a snapshot or from that snapshot's bytes. Its revisions start
+// afresh at the first one, as a decoded tree's do, since a snapshot holds none. Every payload stays shared with the
+// source; only a node whose revision is not the first, or a directory whose entries were in another order, is copied.
+/** @internal */
+export const reachableValue = Effect.fnUntraced(function* (source) {
+    const nodes = yield* reachableNodes(source);
+    const owner = Symbol();
+    let inodes = InodeTable.empty();
+    let entries = 0;
+    let usedBytes = 0n;
+    let largestFile = 0;
+    for (const node of nodes) {
+        inodes = InodeTable.set(inodes, node.ino, atFirstRevision(node.kind === "directory" ? inEntryOrder(node) : node), owner);
+        if (node.kind === "directory")
+            entries += node.entries.size;
+        else if (node.kind === "symlink")
+            usedBytes += BigInt(node.target.length);
+        else {
+            usedBytes += BigInt(node.data.length);
+            largestFile = Math.max(largestFile, node.data.length);
+        }
+    }
+    const state = {
+        inodes,
+        open: new Map(),
+        nextInode: source.nextInode,
+        revision: 1n,
+        entries,
+        usedBytes
+    };
+    return { state, largestFile };
+});
+// Builds the value a set of nodes describes. The caller has checked that the nodes form a tree under the root:
+// every parent is a directory among them, no directory holds a name twice, and every directory reaches the root.
+// Each directory lists its entries in the byte order of their names, so the value does not depend on the order
+// the nodes arrive in. Link counts and sizes come from the nodes, and the allocator resumes past the largest inode.
+/** @internal */
+export const assemble = (specs) => {
+    const edges = new Map();
+    const subdirectories = new Map();
+    let entries = 0;
+    let usedBytes = 0n;
+    let nextInode = Ino(ROOT_INO + 1);
+    let revision = 1n;
+    const attach = (parent, name, child) => {
+        const listed = edges.get(parent);
+        if (listed === undefined)
+            edges.set(parent, [[name, child]]);
+        else
+            listed.push([name, child]);
+        entries++;
+    };
+    for (const spec of specs) {
+        if (spec.ino >= nextInode)
+            nextInode = Ino(spec.ino + 1);
+        if (spec.revision > revision)
+            revision = spec.revision;
+        if (spec.kind === "directory") {
+            if (spec.ino === ROOT_INO)
+                continue;
+            attach(spec.parent, spec.name, spec.ino);
+            subdirectories.set(spec.parent, (subdirectories.get(spec.parent) ?? 0) + 1);
+        }
+        else {
+            usedBytes += BigInt(spec.kind === "file" ? spec.data.length : spec.target.length);
+            for (const link of spec.links)
+                attach(link.parent, link.name, spec.ino);
+        }
+    }
+    const owner = Symbol();
+    let inodes = InodeTable.empty();
+    for (const spec of specs) {
+        const base = { ...spec.metadata, ino: BigInt(spec.ino) };
+        const node = Match.value(spec).pipe(Match.discriminator("kind")("directory", (directory) => ({
+            kind: "directory",
+            ino: directory.ino,
+            parent: directory.parent,
+            name: directory.name,
+            entries: new Map((edges.get(directory.ino) ?? []).sort(byEntryName)),
+            metadata: { ...base, kind: "directory", nlink: 2 + (subdirectories.get(directory.ino) ?? 0), size: 0n },
+            revision: directory.revision
+        })), Match.discriminator("kind")("file", (file) => ({
+            kind: "file",
+            ino: file.ino,
+            data: file.data,
+            links: file.links,
+            metadata: { ...base, kind: "file", nlink: file.links.length, size: BigInt(file.data.length) },
+            revision: file.revision
+        })), Match.discriminator("kind")("symlink", (symlink) => ({
+            kind: "symlink",
+            ino: symlink.ino,
+            target: symlink.target,
+            links: symlink.links,
+            metadata: { ...base, kind: "symlink", nlink: symlink.links.length, size: BigInt(symlink.target.length) },
+            revision: symlink.revision
+        })), Match.exhaustive);
+        inodes = InodeTable.set(inodes, spec.ino, node, owner);
+    }
+    return { inodes, open: new Map(), nextInode, revision, entries, usedBytes };
+};

package/dist/internal/watchHub.d.ts

@@ -1,16 +1,25 @@
 import * as Effect from "effect/Effect";
-import type * as Scope from "effect/Scope";
+import * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
 /** @internal */
 export interface Coordinator {
     <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
 }
+/**
+ * Selection callbacks share the context of their publication.
+ *
+ * @internal
+ */
+export interface Selection<A, C> {
+    readonly includes: (event: A, context: C) => boolean;
+    readonly rescan: (context: C) => A;
+    readonly settle?: (context: C) => Iterable<A> | undefined;
+}
 /** @internal */
-export interface WatchHub<A, E = never> {
-    readonly publishUnsafe: (event: () => A) => void;
-    readonly publishManyUnsafe: (events: () => Iterable<A>) => void;
-    readonly subscribe: (afterSubscribe?: Effect.Effect<void>) => Effect.Effect<Stream.Stream<A>, E, Scope.Scope>;
+export interface WatchHub<A, C, E = never> {
+    readonly publishUnsafe: (events: () => Iterable<A>, context: C) => void;
+    readonly subscribe: (select: Effect.Effect<Selection<A, C>, E>, afterSubscribe: Effect.Effect<void>) => Effect.Effect<Stream.Stream<A>, E, Scope.Scope>;
 }
 /** @internal */
-export declare const make: <A, E = never>(coordinate: Coordinator, capacity: number, rescan: () => A, checkAvailable?: Effect.Effect<void, E, never> | undefined) => Effect.Effect<WatchHub<A, E>, never, never>;
+export declare const make: <A, C, E = never>(coordinate: Coordinator, capacity: number) => Effect.Effect<WatchHub<A, C, E>, never, never>;
 //# sourceMappingURL=watchHub.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"watchHub.d.ts","sourceRoot":"","sources":["../../src/internal/watchHub.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,gBAAgB;AAChB,MAAM,WAAW,WAAW;IAC1B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CAClE;AAED,gBAAgB;AAChB,MAAM,WAAW,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK;IACpC,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,CAAA;IAChD,QAAQ,CAAC,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,CAAA;IAC/D,QAAQ,CAAC,SAAS,EAAE,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;CAC9G;AAQD,gBAAgB;AAChB,eAAO,MAAM,IAAI,GAA+B,CAAC,EAAE,CAAC,mEAGpC,CAAC,4GAiEf,CAAA"}
+{"version":3,"file":"watchHub.d.ts","sourceRoot":"","sources":["../../src/internal/watchHub.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,gBAAgB;AAChB,MAAM,WAAW,WAAW;IAC1B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CAClE;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,EAAE,CAAC;IAE7B,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,OAAO,CAAA;IACpD,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAA;IAElC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAA;CAC1D;AAED,gBAAgB;AAChB,MAAM,WAAW,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK;IACvC,QAAQ,CAAC,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,IAAI,CAAA;IACvE,QAAQ,CAAC,SAAS,EAAE,CAClB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EACzC,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAChC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;CACrD;AAQD,gBAAgB;AAChB,eAAO,MAAM,IAAI,GAA+B,CAAC,EAAE,CAAC,EAAE,CAAC,sGAwFrD,CAAA"}

package/dist/internal/watchHub.js

@@ -1,54 +1,68 @@
 import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
 import * as Queue from "effect/Queue";
+import * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
 /** @internal */
-export const make = Effect.fnUntraced(function* (coordinate, capacity, rescan, checkAvailable) {
+export const make = Effect.fnUntraced(function* (coordinate, capacity) {
     const subscribers = new Set();
-    const publish = (event) => {
+    const offer = (subscriber, event, context) => {
+        const size = Queue.sizeUnsafe(subscriber.queue);
+        // An empty queue means the consumer has taken the rescan marker.
+        if (subscriber.overflowed && size > 0)
+            return;
+        subscriber.overflowed = size >= capacity - 1;
+        Queue.offerUnsafe(subscriber.queue, subscriber.overflowed ? subscriber.selection.rescan(context) : event);
+    };
+    const publishUnsafe = (events, context) => {
+        if (subscribers.size === 0)
+            return;
+        for (const event of events()) {
+            for (const subscriber of subscribers) {
+                if (subscriber.selection.includes(event, context))
+                    offer(subscriber, event, context);
+            }
+        }
         for (const subscriber of subscribers) {
-            if (subscriber.overflowed)
+            const last = subscriber.selection.settle?.(context);
+            if (last === undefined)
                 continue;
-            if (Queue.sizeUnsafe(subscriber.queue) < capacity - 1) {
+            for (const event of last)
                 Queue.offerUnsafe(subscriber.queue, event);
-            }
-            else {
-                subscriber.overflowed = true;
-                subscriber.marker = rescan();
-                Queue.offerUnsafe(subscriber.queue, subscriber.marker);
-            }
+            subscribers.delete(subscriber);
+            Queue.endUnsafe(subscriber.queue);
         }
     };
-    const publishUnsafe = (event) => {
-        if (subscribers.size > 0)
-            publish(event());
-    };
-    const publishManyUnsafe = (events) => {
-        if (subscribers.size > 0) {
-            for (const event of events())
-                publish(event);
-        }
-    };
-    const subscribe = (afterSubscribe) => Effect.acquireRelease(coordinate(Effect.gen(function* () {
-        if (checkAvailable !== undefined)
-            yield* checkAvailable;
-        const queue = yield* Queue.bounded(capacity);
-        const subscriber = {
-            queue,
-            overflowed: false,
-            marker: undefined
-        };
-        if (afterSubscribe !== undefined)
+    // Register cleanup before waiting for the volume, including when the scope closes during registration.
+    const subscribe = Effect.fnUntraced(function* (select, afterSubscribe) {
+        const scope = yield* Effect.scope;
+        let registered;
+        yield* Scope.addFinalizer(scope, Effect.suspend(() => {
+            const subscriber = registered;
+            if (subscriber === undefined)
+                return Effect.void;
+            return coordinate(Effect.sync(() => subscribers.delete(subscriber))).pipe(Effect.andThen(Queue.shutdown(subscriber.queue)));
+        }));
+        const closed = () => Predicate.isTagged(scope.state, "Closed");
+        const subscriber = yield* coordinate(Effect.gen(function* () {
+            const selection = yield* select;
+            const created = {
+                // Reserve one slot for a final event behind a rescan marker.
+                queue: yield* Queue.bounded(capacity + 1),
+                selection,
+                overflowed: false
+            };
             yield* afterSubscribe;
-        subscribers.add(subscriber);
-        return subscriber;
-    })), (subscriber) => coordinate(Effect.sync(() => {
-        subscribers.delete(subscriber);
-    })).pipe(Effect.andThen(Queue.shutdown(subscriber.queue))), { interruptible: true }).pipe(Effect.map((subscriber) => Stream.fromEffectRepeat(Queue.take(subscriber.queue)).pipe(Stream.map((event) => {
-        if (subscriber.overflowed && event === subscriber.marker) {
-            subscriber.overflowed = false;
-            subscriber.marker = undefined;
-        }
-        return event;
-    }))));
-    return { publishUnsafe, publishManyUnsafe, subscribe };
+            // Cleanup may have run before registration; discard the subscriber if the scope closed.
+            if (closed()) {
+                yield* Queue.shutdown(created.queue);
+                return undefined;
+            }
+            subscribers.add(created);
+            registered = created;
+            return created;
+        }));
+        return subscriber === undefined ? Stream.empty : Stream.fromEffectRepeat(Queue.take(subscriber.queue));
+    });
+    return { publishUnsafe, subscribe };
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-vfs/core",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "A runtime-neutral virtual filesystem core for Effect.",
   "homepage": "https://github.com/lloydrichards/effect-virtual-fs#readme",
   "bugs": {
@@ -21,18 +21,18 @@
   "scripts": {
     "build": "tsc --project tsconfig.build.json && tsc --project compatibility/node-next/tsconfig.json",
     "clean": "git clean -xdf .cache .turbo dist docs node_modules tsconfig.tsbuildinfo",
-    "test": "vitest run",
+    "test": "bun --bun run vitest run --config ../../vitest.config.ts --project core",
     "type-check": "tsc --noEmit && tsc --project contracts/tsconfig.json"
   },
   "peerDependencies": {
-    "effect": "4.0.0-rc.115"
+    "effect": "4.0.0-rc.117"
   },
   "devDependencies": {
-    "@effect/platform-bun": "4.0.0-rc.115",
-    "@effect/platform-node-shared": "4.0.0-rc.115",
-    "@effect/vitest": "4.0.0-rc.115",
+    "@effect/platform-bun": "4.0.0-rc.117",
+    "@effect/platform-node-shared": "4.0.0-rc.117",
+    "@effect/vitest": "4.0.0-rc.117",
     "@repo/config-typescript": "workspace:*",
-    "effect": "4.0.0-rc.115"
+    "effect": "4.0.0-rc.117"
   },
   "exports": {
     ".": {
@@ -43,14 +43,58 @@
       "types": "./dist/VirtualFileSystem.d.ts",
       "import": "./dist/VirtualFileSystem.js"
     },
-    "./VirtualFileSystemError": {
-      "types": "./dist/VirtualFileSystemError.d.ts",
-      "import": "./dist/VirtualFileSystemError.js"
+    "./VfsError": {
+      "types": "./dist/VfsError.d.ts",
+      "import": "./dist/VfsError.js"
     },
     "./LiveVolume": {
       "types": "./dist/LiveVolume.d.ts",
       "import": "./dist/LiveVolume.js"
     },
+    "./Caller": {
+      "types": "./dist/Caller.d.ts",
+      "import": "./dist/Caller.js"
+    },
+    "./FileHandle": {
+      "types": "./dist/FileHandle.d.ts",
+      "import": "./dist/FileHandle.js"
+    },
+    "./Fixture": {
+      "types": "./dist/Fixture.d.ts",
+      "import": "./dist/Fixture.js"
+    },
+    "./Metadata": {
+      "types": "./dist/Metadata.d.ts",
+      "import": "./dist/Metadata.js"
+    },
+    "./Target": {
+      "types": "./dist/Target.d.ts",
+      "import": "./dist/Target.js"
+    },
+    "./Volume": {
+      "types": "./dist/Volume.d.ts",
+      "import": "./dist/Volume.js"
+    },
+    "./Watch": {
+      "types": "./dist/Watch.d.ts",
+      "import": "./dist/Watch.js"
+    },
+    "./BytePath": {
+      "types": "./dist/BytePath.d.ts",
+      "import": "./dist/BytePath.js"
+    },
+    "./Snapshot": {
+      "types": "./dist/Snapshot.d.ts",
+      "import": "./dist/Snapshot.js"
+    },
+    "./SnapshotDelta": {
+      "types": "./dist/SnapshotDelta.d.ts",
+      "import": "./dist/SnapshotDelta.js"
+    },
+    "./Testing": {
+      "types": "./dist/Testing.d.ts",
+      "import": "./dist/Testing.js"
+    },
     "./internal/*": null,
     "./index": null,
     "./*/index": null,

package/dist/VirtualFileSystemError.d.ts

@@ -1,54 +0,0 @@
-import type { FsCode, PathInput } from "./VirtualFileSystem.js";
-declare const FsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-    readonly _tag: "FsError";
-} & Readonly<A>;
-/**
- * An expected filesystem operation failure.
- *
- * The `code` distinguishes portable failures while `operation` names the action.
- * Byte paths are intentionally omitted from the formatted message.
- *
- * @example
- * ```ts
- * import { VirtualFileSystemError } from "@effect-vfs/core"
- *
- * const error = new VirtualFileSystemError.FsError({ code: "NotFound", operation: "readFile" })
- * console.log(error.code, error.message)
- * // NotFound readFile failed with NotFound
- * ```
- *
- * @category errors
- * @since 0.1.0
- */
-export declare class FsError extends FsError_base<{
-    readonly code: FsCode;
-    readonly operation: string;
-    readonly path?: PathInput;
-}> {
-    get message(): string;
-}
-declare const ConfigurationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-    readonly _tag: "ConfigurationError";
-} & Readonly<A>;
-/**
- * An invalid volume or caller option, identified by its field name.
- *
- * @example
- * ```ts
- * import { VirtualFileSystemError } from "@effect-vfs/core"
- *
- * const error = new VirtualFileSystemError.ConfigurationError({ field: "maxEntries" })
- * console.log(error.field, error.message)
- * // maxEntries Invalid option: maxEntries
- * ```
- *
- * @category errors
- * @since 0.1.0
- */
-export declare class ConfigurationError extends ConfigurationError_base<{
-    readonly field: string;
-}> {
-    get message(): string;
-}
-export {};
-//# sourceMappingURL=VirtualFileSystemError.d.ts.map

package/dist/VirtualFileSystemError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VirtualFileSystemError.d.ts","sourceRoot":"","sources":["../src/VirtualFileSystemError.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;;;;AAE/D;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,OAAQ,SAAQ,aAA4B;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAA;CAC1B,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC7E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF"}