@effect-vfs/core 0.2.0 → 0.3.0

package/dist/internal/bytePath.d.ts

@@ -0,0 +1,10 @@
+import type { BytePath } from "../BytePath.js";
+/** @internal */
+export declare const BytePathId: "@effect-vfs/core/BytePath";
+/** @internal */
+export declare const isBytePath: (value: unknown) => value is BytePath;
+/** @internal */
+export declare const make: (bytes: Uint8Array) => BytePath;
+/** @internal */
+export declare const getBytes: (path: BytePath) => Uint8Array | undefined;
+//# sourceMappingURL=bytePath.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bytePath.d.ts","sourceRoot":"","sources":["../../src/internal/bytePath.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAE9C,gBAAgB;AAChB,eAAO,MAAM,UAAU,EAAG,2BAAoC,CAAA;AAgC9D,gBAAgB;AAChB,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,QAC4B,CAAA;AAEjF,gBAAgB;AAChB,eAAO,MAAM,IAAI,UAAW,UAAU,KAAG,QAIxC,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,QAAQ,SAAU,QAAQ,KAAG,UAAU,GAAG,SAAgC,CAAA"}

package/dist/internal/bytePath.js

@@ -0,0 +1,46 @@
+// Opaque byte path representation and value protocols.
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+import { pipeArguments } from "effect/Pipeable";
+/** @internal */
+export const BytePathId = "@effect-vfs/core/BytePath";
+const bytePaths = new WeakMap();
+const hashBytes = (bytes) => {
+    let hash = Hash.string("@effect-vfs/core/BytePath");
+    for (const byte of bytes) {
+        hash = Hash.combine(Hash.number(byte))(hash);
+    }
+    return Hash.combine(Hash.number(bytes.length))(hash);
+};
+const BytePathProto = {
+    [BytePathId]: BytePathId,
+    [Equal.symbol](that) {
+        if (!isBytePath(that))
+            return false;
+        const selfBytes = bytePaths.get(this);
+        const thatBytes = bytePaths.get(that);
+        if (selfBytes.length !== thatBytes.length)
+            return false;
+        for (let index = 0; index < selfBytes.length; index++) {
+            if (selfBytes[index] !== thatBytes[index])
+                return false;
+        }
+        return true;
+    },
+    [Hash.symbol]() {
+        return hashBytes(bytePaths.get(this));
+    },
+    pipe() {
+        return pipeArguments(this, arguments);
+    }
+};
+/** @internal */
+export const isBytePath = (value) => typeof value === "object" && value !== null && bytePaths.has(value);
+/** @internal */
+export const make = (bytes) => {
+    const path = Object.create(BytePathProto);
+    bytePaths.set(path, bytes);
+    return Object.freeze(path);
+};
+/** @internal */
+export const getBytes = (path) => bytePaths.get(path);

package/dist/internal/canonicalBase64.d.ts

@@ -1,7 +1,7 @@
-/** Strict padded base64 check, including canonical unused pad bits and no ignored whitespace. */
+/** @internal */
 export declare const isCanonical: (value: string) => boolean;
-/** Decoded length for an already canonical base64 string, without allocating its payload. */
+/** @internal */
 export declare const decodedLength: (value: string) => number;
-/** Decodes base64 previously accepted by `isCanonical`. */
+/** @internal */
 export declare const decodeTrusted: (value: string) => Uint8Array;
 //# sourceMappingURL=canonicalBase64.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"canonicalBase64.d.ts","sourceRoot":"","sources":["../../src/internal/canonicalBase64.ts"],"names":[],"mappings":"AAKA,iGAAiG;AACjG,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,OAGP,CAAA;AAErC,6FAA6F;AAC7F,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,MACmC,CAAA;AAEjF,2DAA2D;AAC3D,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,UAC4D,CAAA"}
+{"version":3,"file":"canonicalBase64.d.ts","sourceRoot":"","sources":["../../src/internal/canonicalBase64.ts"],"names":[],"mappings":"AAKA,gBAAgB;AAChB,eAAO,MAAM,WAAW,UAAW,MAAM,KAAG,OAGP,CAAA;AAErC,gBAAgB;AAChB,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,MACmC,CAAA;AAEjF,gBAAgB;AAChB,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,UAC4D,CAAA"}

package/dist/internal/canonicalBase64.js

@@ -1,11 +1,11 @@
 import * as Encoding from "effect/Encoding";
 import * as Result from "effect/Result";
 const canonicalTail = /^(?:[A-Za-z0-9+/]{4}|[A-Za-z0-9+/][AQgw]==|[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=)?(?![\s\S])/;
-/** Strict padded base64 check, including canonical unused pad bits and no ignored whitespace. */
+/** @internal */
 export const isCanonical = (value) => value.length % 4 === 0 &&
     !/[^A-Za-z0-9+/]/.test(value.slice(0, -4)) &&
     canonicalTail.test(value.slice(-4));
-/** Decoded length for an already canonical base64 string, without allocating its payload. */
+/** @internal */
 export const decodedLength = (value) => value.length / 4 * 3 - (value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0);
-/** Decodes base64 previously accepted by `isCanonical`. */
+/** @internal */
 export const decodeTrusted = (value) => Result.getOrThrowWith(Encoding.decodeBase64(value), () => new Error("Invalid trusted canonical base64"));

package/dist/internal/image.d.ts

@@ -1,8 +1,3 @@
-/**
- * Snapshot validation and serialization used by `VirtualFileSystem`.
- *
- * @internal
- */
 import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
@@ -10,9 +5,9 @@ import { ImageError, type Snapshot } from "../Snapshot.js";
 import * as CanonicalBase64 from "./canonicalBase64.js";
 /** @internal */
 export declare const StoredMetadata: Schema.Struct<{
-    readonly uid: Schema.Finite;
-    readonly gid: Schema.Finite;
-    readonly mode: Schema.Finite;
+    readonly uid: Schema.Natural;
+    readonly gid: Schema.Natural;
+    readonly mode: Schema.Natural;
     readonly atimeNs: Schema.String;
     readonly mtimeNs: Schema.String;
     readonly ctimeNs: Schema.String;
@@ -25,9 +20,9 @@ export declare const Record: Schema.Union<readonly [Schema.Struct<{
     readonly id: Schema.String;
     readonly kind: Schema.Literal<"directory">;
     readonly metadata: Schema.Struct<{
-        readonly uid: Schema.Finite;
-        readonly gid: Schema.Finite;
-        readonly mode: Schema.Finite;
+        readonly uid: Schema.Natural;
+        readonly gid: Schema.Natural;
+        readonly mode: Schema.Natural;
         readonly atimeNs: Schema.String;
         readonly mtimeNs: Schema.String;
         readonly ctimeNs: Schema.String;
@@ -41,9 +36,9 @@ export declare const Record: Schema.Union<readonly [Schema.Struct<{
     readonly id: Schema.String;
     readonly kind: Schema.Literal<"file">;
     readonly metadata: Schema.Struct<{
-        readonly uid: Schema.Finite;
-        readonly gid: Schema.Finite;
-        readonly mode: Schema.Finite;
+        readonly uid: Schema.Natural;
+        readonly gid: Schema.Natural;
+        readonly mode: Schema.Natural;
         readonly atimeNs: Schema.String;
         readonly mtimeNs: Schema.String;
         readonly ctimeNs: Schema.String;
@@ -54,9 +49,9 @@ export declare const Record: Schema.Union<readonly [Schema.Struct<{
     readonly id: Schema.String;
     readonly kind: Schema.Literal<"symlink">;
     readonly metadata: Schema.Struct<{
-        readonly uid: Schema.Finite;
-        readonly gid: Schema.Finite;
-        readonly mode: Schema.Finite;
+        readonly uid: Schema.Natural;
+        readonly gid: Schema.Natural;
+        readonly mode: Schema.Natural;
         readonly atimeNs: Schema.String;
         readonly mtimeNs: Schema.String;
         readonly ctimeNs: Schema.String;
@@ -75,9 +70,9 @@ export declare const Document: Schema.Struct<{
         readonly id: Schema.String;
         readonly kind: Schema.Literal<"directory">;
         readonly metadata: Schema.Struct<{
-            readonly uid: Schema.Finite;
-            readonly gid: Schema.Finite;
-            readonly mode: Schema.Finite;
+            readonly uid: Schema.Natural;
+            readonly gid: Schema.Natural;
+            readonly mode: Schema.Natural;
             readonly atimeNs: Schema.String;
             readonly mtimeNs: Schema.String;
             readonly ctimeNs: Schema.String;
@@ -91,9 +86,9 @@ export declare const Document: Schema.Struct<{
         readonly id: Schema.String;
         readonly kind: Schema.Literal<"file">;
         readonly metadata: Schema.Struct<{
-            readonly uid: Schema.Finite;
-            readonly gid: Schema.Finite;
-            readonly mode: Schema.Finite;
+            readonly uid: Schema.Natural;
+            readonly gid: Schema.Natural;
+            readonly mode: Schema.Natural;
             readonly atimeNs: Schema.String;
             readonly mtimeNs: Schema.String;
             readonly ctimeNs: Schema.String;
@@ -104,9 +99,9 @@ export declare const Document: Schema.Struct<{
         readonly id: Schema.String;
         readonly kind: Schema.Literal<"symlink">;
         readonly metadata: Schema.Struct<{
-            readonly uid: Schema.Finite;
-            readonly gid: Schema.Finite;
-            readonly mode: Schema.Finite;
+            readonly uid: Schema.Natural;
+            readonly gid: Schema.Natural;
+            readonly mode: Schema.Natural;
             readonly atimeNs: Schema.String;
             readonly mtimeNs: Schema.String;
             readonly ctimeNs: Schema.String;

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

@@ -1 +1 @@
-{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/internal/image.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAgB,UAAU,EAAE,KAAK,QAAQ,EAAkB,MAAM,gBAAgB,CAAA;AACxF,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAavD,gBAAgB;AAChB,eAAO,MAAM,cAAc;;;;;;;;EAQzB,CAAA;AACF,gBAAgB;AAChB,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAEvD,gBAAgB;AAChB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASjB,CAAA;AACF,gBAAgB;AAChB,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AACvC,gBAAgB;AAChB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKnB,CAAA;AACF,gBAAgB;AAChB,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C,gBAAgB;AAChB,eAAO,MAAM,aAAa,sCAAgC,CAAA;AAC1D,gBAAgB;AAChB,eAAO,MAAM,MAAM,UAAW,UAAU,KAAG,MAU1C,CAAA;AAGD,gBAAgB;AAChB,eAAO,MAAM,KAAK,UAAW,MAAM,KAAG,UAErC,CAAA;AACD,gBAAgB;AAChB,eAAO,MAAM,OAAO,aAAc,QAAQ,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAI3E,CAAA;AAEJ,gBAAgB;AAChB,eAAO,MAAM,OAAO;;;;;4DAwElB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc,mFAKzB,CAAA;AACF,gBAAgB;AAChB,eAAO,MAAM,cAAc;;;;;gDAqB1B,CAAA"}
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../src/internal/image.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAgB,UAAU,EAAE,KAAK,QAAQ,EAAkB,MAAM,gBAAgB,CAAA;AACxF,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAQvD,gBAAgB;AAChB,eAAO,MAAM,cAAc;;;;;;;;EAQzB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAIvD,gBAAgB;AAChB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASjB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC,gBAAgB;AAChB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKnB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAI3C,gBAAgB;AAChB,eAAO,MAAM,aAAa,sCAAgC,CAAA;AAE1D,gBAAgB;AAChB,eAAO,MAAM,MAAM,UAAW,UAAU,KAAG,MAU1C,CAAA;AAKD,gBAAgB;AAChB,eAAO,MAAM,KAAK,UAAW,MAAM,KAAG,UAErC,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,OAAO,aAAc,QAAQ,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAI3E,CAAA;AAEJ,gBAAgB;AAChB,eAAO,MAAM,OAAO;;;;;4DAwElB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc,mFAKzB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc;;;;;gDAqB1B,CAAA"}

package/dist/internal/image.js

@@ -1,8 +1,4 @@
-/**
- * Snapshot validation and serialization used by `VirtualFileSystem`.
- *
- * @internal
- */
+// Snapshot validation and serialization used by VirtualFileSystem.
 import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
 import * as Encoding from "effect/Encoding";
@@ -10,16 +6,15 @@ import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
 import { DecodeLimits, ImageError, SnapshotTypeId } from "../Snapshot.js";
 import * as CanonicalBase64 from "./canonicalBase64.js";
-const natural = Schema.Finite.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER));
 class SnapshotImpl {
     [SnapshotTypeId] = SnapshotTypeId;
 }
 const integer = Schema.String.check(Schema.isPattern(/^(?:0|-?[1-9][0-9]{0,127})(?![\s\S])/));
 /** @internal */
 export const StoredMetadata = Schema.Struct({
-    uid: natural,
-    gid: natural,
-    mode: natural.check(Schema.isLessThanOrEqualTo(0o7777)),
+    uid: Schema.Natural,
+    gid: Schema.Natural,
+    mode: Schema.Natural.check(Schema.isLessThanOrEqualTo(0o7777)),
     atimeNs: integer,
     mtimeNs: integer,
     ctimeNs: integer,

package/dist/internal/snapshotDelta.d.ts

@@ -1,4 +1,3 @@
-/** Exact snapshot delta construction, inspection, serialization, and application. @internal */
 import * as ByteSize from "effect/ByteSize";
 import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";

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

@@ -1 +1 @@
-{"version":3,"file":"snapshotDelta.d.ts","sourceRoot":"","sources":["../../src/internal/snapshotDelta.ts"],"names":[],"mappings":"AAAA,+FAA+F;AAC/F,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAMvC,OAAO,EAAE,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC1D,OAAO,EAIL,KAAK,aAAa,EAClB,kBAAkB,EAKnB,MAAM,qBAAqB,CAAA;AA6d5B,gBAAgB;AAChB,eAAO,MAAM,aAAa;;;;;;;;;;;4GAgDzB,CAAA;AAwBD,gBAAgB;AAChB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;oGAgBhC,CAAA;AACD,gBAAgB;AAChB,eAAO,MAAM,mBAAmB;;;;;;;;;;;+DAS9B,CAAA;AACF,gBAAgB;AAChB,eAAO,MAAM,mBAAmB;;;;;;;;;;;qDAkB9B,CAAA;AACF,gBAAgB;AAChB,eAAO,MAAM,kBAAkB;;;;;;;;;;;4HAI9B,CAAA"}
+{"version":3,"file":"snapshotDelta.d.ts","sourceRoot":"","sources":["../../src/internal/snapshotDelta.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC,OAAO,EAAE,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC1D,OAAO,EAGL,KAAK,aAAa,EAClB,kBAAkB,EAInB,MAAM,qBAAqB,CAAA;AA6e5B,gBAAgB;AAChB,eAAO,MAAM,aAAa;;;;;;;;;;;4GAgDzB,CAAA;AAyBD,gBAAgB;AAChB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;oGAgBhC,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,mBAAmB;;;;;;;;;;;+DAS9B,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,mBAAmB;;;;;;;;;;;qDAkB9B,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,kBAAkB;;;;;;;;;;;4HAI9B,CAAA"}

package/dist/internal/snapshotDelta.js

@@ -1,4 +1,4 @@
-/** Exact snapshot delta construction, inspection, serialization, and application. @internal */
+// Exact snapshot delta construction, inspection, serialization, and application.
 import * as ByteSize from "effect/ByteSize";
 import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
@@ -6,11 +6,12 @@ import * as Encoding from "effect/Encoding";
 import * as Equal from "effect/Equal";
 import * as Result from "effect/Result";
 import * as Schema from "effect/Schema";
-import { make as makeBytePath } from "../BytePath.js";
 import { ImageError } from "../Snapshot.js";
-import { makeSnapshotDelta, SnapshotDeltaError, snapshotDeltaValue } from "../SnapshotDelta.js";
+import { SnapshotDeltaError, SnapshotDifference, SnapshotNodeKind } from "../SnapshotDelta.js";
+import { make as makeBytePath } from "./bytePath.js";
 import * as CanonicalBase64 from "./canonicalBase64.js";
 import * as Image from "./image.js";
+import * as SnapshotDeltaModel from "./snapshotDeltaModel.js";
 const Path = Schema.String;
 const Payload = Schema.Union([
     Schema.TaggedStruct("Inline", { bytes: Schema.String }),
@@ -31,28 +32,14 @@ const Record = Schema.Union([
         payload: Payload
     })
 ]);
-const Kind = Schema.Literals(["directory", "file", "symlink"]);
-const Difference = Schema.Literals([
-    "kind",
-    "content",
-    "target",
-    "hardLinks",
-    "mode",
-    "uid",
-    "gid",
-    "atimeNs",
-    "mtimeNs",
-    "ctimeNs",
-    "birthtimeNs"
-]);
 const Change = Schema.Union([
-    Schema.TaggedStruct("Added", { path: Path, kind: Kind }),
-    Schema.TaggedStruct("Removed", { path: Path, kind: Kind }),
+    Schema.TaggedStruct("Added", { path: Path, kind: SnapshotNodeKind }),
+    Schema.TaggedStruct("Removed", { path: Path, kind: SnapshotNodeKind }),
     Schema.TaggedStruct("Updated", {
         path: Path,
-        beforeKind: Kind,
-        afterKind: Kind,
-        differences: Schema.Array(Difference).check(Schema.isMinLength(1))
+        beforeKind: SnapshotNodeKind,
+        afterKind: SnapshotNodeKind,
+        differences: Schema.Array(SnapshotDifference).check(Schema.isMinLength(1))
     })
 ]);
 const Document = Schema.Struct({
@@ -325,7 +312,7 @@ const compare = (base, target) => {
     return changes.map(({ change }) => change);
 };
 const getDocument = (delta) => Effect.suspend(() => {
-    const value = snapshotDeltaValue(delta);
+    const value = SnapshotDeltaModel.value(delta);
     return value !== undefined && Schema.is(Document)(value)
         ? Effect.succeed(value)
         : Effect.fail(failure("InvalidStructure", "delta"));
@@ -471,7 +458,7 @@ const validate = Effect.fnUntraced(function* (document, limits) {
     yield* buildImage(document, undefined, limits);
 });
 /** @internal */
-export const diffSnapshots = Effect.fn("VirtualFileSystem.diffSnapshots")(function* (base, target, limits) {
+export const diffSnapshots = Effect.fnUntraced(function* (base, target, limits) {
     const before = yield* normalize(base, limits, "base");
     const after = yield* normalize(target, limits, "target");
     const changes = [...compare(before, after)];
@@ -518,7 +505,7 @@ export const diffSnapshots = Effect.fn("VirtualFileSystem.diffSnapshots")(functi
         changes
     };
     yield* validate(document, limits);
-    return makeSnapshotDelta(document);
+    return SnapshotDeltaModel.make(document);
 });
 /** @internal */
 const verify = Effect.fnUntraced(function* (base, document, limits) {
@@ -536,7 +523,7 @@ const verify = Effect.fnUntraced(function* (base, document, limits) {
     return { changes, target };
 });
 /** @internal */
-export const inspectSnapshotDelta = Effect.fn("VirtualFileSystem.inspectSnapshotDelta")(function* (base, delta, options, limits) {
+export const inspectSnapshotDelta = Effect.fnUntraced(function* (base, delta, options, limits) {
     const output = [];
     const { changes } = yield* verify(base, yield* getDocument(delta), limits);
     for (const change of changes) {
@@ -581,9 +568,9 @@ export const decodeSnapshotDelta = Effect.fnUntraced(function* (input, limits) {
     if (Result.isFailure(parsed))
         return yield* failure("InvalidStructure");
     yield* validate(parsed.success, limits);
-    return makeSnapshotDelta(parsed.success);
+    return SnapshotDeltaModel.make(parsed.success);
 });
 /** @internal */
-export const applySnapshotDelta = Effect.fn("VirtualFileSystem.applySnapshotDelta")(function* (base, delta, limits) {
+export const applySnapshotDelta = Effect.fnUntraced(function* (base, delta, limits) {
     return (yield* verify(base, yield* getDocument(delta), limits)).target;
 });

package/dist/internal/snapshotDeltaModel.d.ts

@@ -0,0 +1,10 @@
+import type { SnapshotDelta } from "../SnapshotDelta.js";
+/** @internal */
+export declare const SnapshotDeltaTypeId: "@effect-vfs/core/SnapshotDelta";
+/** @internal */
+export declare const make: (value: object) => SnapshotDelta;
+/** @internal */
+export declare const value: (delta: SnapshotDelta) => object | undefined;
+/** @internal */
+export declare const isSnapshotDelta: (input: unknown) => input is SnapshotDelta;
+//# sourceMappingURL=snapshotDeltaModel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"snapshotDeltaModel.d.ts","sourceRoot":"","sources":["../../src/internal/snapshotDeltaModel.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAExD,gBAAgB;AAChB,eAAO,MAAM,mBAAmB,EAAG,gCAAyC,CAAA;AAI5E,gBAAgB;AAChB,eAAO,MAAM,IAAI,UAAW,MAAM,KAAG,aAIpC,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,KAAK,UAAW,aAAa,KAAG,MAAM,GAAG,SAAsC,CAAA;AAE5F,gBAAgB;AAChB,eAAO,MAAM,eAAe,UAAW,OAAO,KAAG,KAAK,IAAI,aACiC,CAAA"}

package/dist/internal/snapshotDeltaModel.js

@@ -0,0 +1,13 @@
+/** @internal */
+export const SnapshotDeltaTypeId = "@effect-vfs/core/SnapshotDelta";
+const snapshotDeltas = new WeakMap();
+/** @internal */
+export const make = (value) => {
+    const delta = Object.freeze({ [SnapshotDeltaTypeId]: SnapshotDeltaTypeId });
+    snapshotDeltas.set(delta, value);
+    return delta;
+};
+/** @internal */
+export const value = (delta) => snapshotDeltas.get(delta);
+/** @internal */
+export const isSnapshotDelta = (input) => typeof input === "object" && input !== null && snapshotDeltas.has(input);

package/dist/internal/virtualFileSystem/errors.d.ts

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+import type { PathInput } from "../../VirtualFileSystem.js";
+/** @internal */
+export declare const FsCode: Schema.Literals<readonly ["NotFound", "AlreadyExists", "NotEmpty", "NotDirectory", "AccessDenied", "InvalidHandle", "ForeignHandle", "InvalidReference", "ForeignReference", "StaleReference", "ClosedCaller", "InvalidArgument", "InvalidPathEncoding", "PathTooLong", "NoSpace", "IsDirectory", "FileTooLarge", "NoData", "SymlinkLoop", "UnrepresentableName"]>;
+/** @internal */
+export type FsCode = typeof FsCode.Type;
+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>;
+/** @internal */
+export declare class FsError extends FsError_base<{
+    readonly code: FsCode;
+    readonly operation: string;
+    readonly path?: PathInput;
+}> {
+}
+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>;
+/** @internal */
+export declare class ConfigurationError extends ConfigurationError_base<{
+    readonly field: string;
+}> {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/internal/virtualFileSystem/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/internal/virtualFileSystem/errors.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAE3D,gBAAgB;AAChB,eAAO,MAAM,MAAM,oWAqBjB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;;;;AAEvC,gBAAgB;AAChB,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;CAAG;;;;AAEL,gBAAgB;AAChB,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC7E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB,CAAC;CAAG"}

package/dist/internal/virtualFileSystem/errors.js

@@ -0,0 +1,32 @@
+// Virtual filesystem failure schemas and identities shared by the runtime implementation.
+import * as Data from "effect/Data";
+import * as Schema from "effect/Schema";
+/** @internal */
+export const FsCode = Schema.Literals([
+    "NotFound",
+    "AlreadyExists",
+    "NotEmpty",
+    "NotDirectory",
+    "AccessDenied",
+    "InvalidHandle",
+    "ForeignHandle",
+    "InvalidReference",
+    "ForeignReference",
+    "StaleReference",
+    "ClosedCaller",
+    "InvalidArgument",
+    "InvalidPathEncoding",
+    "PathTooLong",
+    "NoSpace",
+    "IsDirectory",
+    "FileTooLarge",
+    "NoData",
+    "SymlinkLoop",
+    "UnrepresentableName"
+]);
+/** @internal */
+export class FsError extends Data.TaggedError("FsError") {
+}
+/** @internal */
+export class ConfigurationError extends Data.TaggedError("ConfigurationError") {
+}

package/dist/internal/virtualFileSystem/fixture.d.ts

@@ -0,0 +1,63 @@
+import * as Effect from "effect/Effect";
+import { ImageError } from "../../Snapshot.js";
+/** @internal */
+export declare const fromFixture: (fixture: {
+    readonly rootMetadata?: {
+        readonly uid?: number;
+        readonly gid?: number;
+        readonly mode?: number;
+        readonly atimeNs?: bigint;
+        readonly mtimeNs?: bigint;
+        readonly ctimeNs?: bigint;
+        readonly birthtimeNs?: bigint;
+    };
+    readonly entries: readonly ({
+        readonly kind: "directory";
+        readonly path: string | import("../../BytePath.js").BytePath;
+        readonly metadata?: {
+            readonly uid?: number;
+            readonly gid?: number;
+            readonly mode?: number;
+            readonly atimeNs?: bigint;
+            readonly mtimeNs?: bigint;
+            readonly ctimeNs?: bigint;
+            readonly birthtimeNs?: bigint;
+        };
+    } | {
+        readonly kind: "file";
+        readonly path: string | import("../../BytePath.js").BytePath;
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+        readonly metadata?: {
+            readonly uid?: number;
+            readonly gid?: number;
+            readonly mode?: number;
+            readonly atimeNs?: bigint;
+            readonly mtimeNs?: bigint;
+            readonly ctimeNs?: bigint;
+            readonly birthtimeNs?: bigint;
+        };
+    } | {
+        readonly kind: "symlink";
+        readonly path: string | import("../../BytePath.js").BytePath;
+        readonly target: string | import("../../BytePath.js").BytePath;
+        readonly metadata?: {
+            readonly uid?: number;
+            readonly gid?: number;
+            readonly mode?: number;
+            readonly atimeNs?: bigint;
+            readonly mtimeNs?: bigint;
+            readonly ctimeNs?: bigint;
+            readonly birthtimeNs?: bigint;
+        };
+    } | {
+        readonly kind: "hardLink";
+        readonly path: string | import("../../BytePath.js").BytePath;
+        readonly target: string | import("../../BytePath.js").BytePath;
+    })[];
+}, options?: {
+    readonly maxEntries?: number;
+    readonly maxBytes?: import("effect/ByteSize").ByteSize;
+    readonly maxFileBytes?: import("effect/ByteSize").ByteSize;
+    readonly maxPathBytes?: import("effect/ByteSize").ByteSize;
+} | undefined) => Effect.Effect<import("../../VirtualFileSystem.js").Volume, import("./errors.js").ConfigurationError | ImageError, never>;
+//# sourceMappingURL=fixture.d.ts.map

package/dist/internal/virtualFileSystem/fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixture.d.ts","sourceRoot":"","sources":["../../../src/internal/virtualFileSystem/fixture.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAY9C,gBAAgB;AAChB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0IAuIvB,CAAA"}