@effect-vfs/core 0.0.1 → 0.2.0

package/dist/internal/canonicalBase64.d.ts

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

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

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

package/dist/internal/canonicalBase64.js

@@ -0,0 +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. */
+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. */
+export const decodedLength = (value) => value.length / 4 * 3 - (value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0);
+/** Decodes base64 previously accepted by `isCanonical`. */
+export const decodeTrusted = (value) => Result.getOrThrowWith(Encoding.decodeBase64(value), () => new Error("Invalid trusted canonical base64"));

package/dist/internal/content.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Immutable regular-file payloads shared by overlay workspaces.
+ *
+ * @internal
+ */
+import type { Snapshot } from "../Snapshot.js";
+import * as Image from "./image.js";
+/** @internal */
+export interface Content {
+    readonly bytes: Uint8Array;
+}
+/** @internal */
+export declare const hasOverlayContents: (snapshot: Snapshot) => boolean;
+/** @internal */
+export declare const make: (bytes: Uint8Array) => Content;
+/** @internal */
+export declare const empty: () => Content;
+/**
+ * Returns the immutable file payloads associated with the identity of a base
+ * snapshot. The cache is weak so it cannot extend the snapshot's lifetime.
+ *
+ * @internal
+ */
+export declare const forOverlay: (snapshot: Snapshot, image: Image.Document) => ReadonlyMap<string, Content>;
+//# sourceMappingURL=content.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../src/internal/content.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC,gBAAgB;AAChB,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;CAC3B;AAID,gBAAgB;AAChB,eAAO,MAAM,kBAAkB,aAAc,QAAQ,KAAG,OAAwC,CAAA;AAEhG,gBAAgB;AAChB,eAAO,MAAM,IAAI,UAAW,UAAU,KAAG,OAAsB,CAAA;AAE/D,gBAAgB;AAChB,eAAO,MAAM,KAAK,QAAO,OAAkC,CAAA;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,UAAU,aAAc,QAAQ,SAAS,KAAK,CAAC,QAAQ,KAAG,WAAW,CAAC,MAAM,EAAE,OAAO,CASjG,CAAA"}

package/dist/internal/content.js

@@ -0,0 +1,26 @@
+import * as Image from "./image.js";
+const overlayContents = new WeakMap();
+/** @internal */
+export const hasOverlayContents = (snapshot) => overlayContents.has(snapshot);
+/** @internal */
+export const make = (bytes) => ({ bytes });
+/** @internal */
+export const empty = () => make(new Uint8Array(0));
+/**
+ * Returns the immutable file payloads associated with the identity of a base
+ * snapshot. The cache is weak so it cannot extend the snapshot's lifetime.
+ *
+ * @internal
+ */
+export const forOverlay = (snapshot, image) => {
+    const cached = overlayContents.get(snapshot);
+    if (cached !== undefined)
+        return cached;
+    const decoded = new Map();
+    for (const record of image.records) {
+        if (record.kind === "file")
+            decoded.set(record.id, make(Image.bytes(record.data)));
+    }
+    overlayContents.set(snapshot, decoded);
+    return decoded;
+};

package/dist/internal/image.d.ts

@@ -3,9 +3,11 @@
  *
  * @internal
  */
+import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import { ImageError, type Snapshot } from "../Snapshot.js";
+import * as CanonicalBase64 from "./canonicalBase64.js";
 /** @internal */
 export declare const StoredMetadata: Schema.Struct<{
     readonly uid: Schema.Finite;
@@ -116,7 +118,7 @@ export declare const Document: Schema.Struct<{
 /** @internal */
 export type Document = typeof Document.Type;
 /** @internal */
-export declare const decodedLength: (value: string) => number;
+export declare const decodedLength: typeof CanonicalBase64.decodedLength;
 /** @internal */
 export declare const base64: (input: Uint8Array) => string;
 /** @internal */
@@ -125,18 +127,18 @@ export declare const bytes: (value: string) => Uint8Array;
 export declare const inspect: (snapshot: Snapshot) => Effect.Effect<Document, ImageError>;
 /** @internal */
 export declare const capture: (input: unknown, limits?: {
-    readonly maxEncodedBytes: number;
+    readonly maxEncodedBytes: ByteSize.ByteSize;
     readonly maxRecords: number;
     readonly maxEntries: number;
-    readonly maxDecodedBytes: number;
+    readonly maxDecodedBytes: ByteSize.ByteSize;
 } | undefined) => Effect.Effect<Snapshot, ImageError, never>;
 /** @internal */
 export declare const encodeSnapshot: (snapshot: Snapshot) => Effect.Effect<Uint8Array<ArrayBuffer>, ImageError, never>;
 /** @internal */
 export declare const decodeSnapshot: (input: Uint8Array<ArrayBufferLike>, limits: {
-    readonly maxEncodedBytes: number;
+    readonly maxEncodedBytes: ByteSize.ByteSize;
     readonly maxRecords: number;
     readonly maxEntries: number;
-    readonly maxDecodedBytes: number;
+    readonly maxDecodedBytes: ByteSize.ByteSize;
 }) => Effect.Effect<Snapshot, ImageError, never>;
 //# sourceMappingURL=image.d.ts.map

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,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAgB,UAAU,EAAE,KAAK,QAAQ,EAAkB,MAAM,gBAAgB,CAAA;AAaxF,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;AAO3C,gBAAgB;AAChB,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,MACmC,CAAA;AACjF,gBAAgB;AAChB,eAAO,MAAM,MAAM,UAAW,UAAU,KAAG,MAU1C,CAAA;AAGD,gBAAgB;AAChB,eAAO,MAAM,KAAK,UAAW,MAAM,KAAG,UAIrC,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;;;;;gDAmB1B,CAAA"}
+{"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"}

package/dist/internal/image.js

@@ -3,11 +3,13 @@
  *
  * @internal
  */
+import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
 import * as Encoding from "effect/Encoding";
 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;
@@ -43,12 +45,8 @@ export const Document = Schema.Struct({
     records: Schema.Array(Record)
 });
 const snapshots = new WeakMap();
-const canonicalBase64Tail = /^(?:[A-Za-z0-9+/]{4}|[A-Za-z0-9+/][AQgw]==|[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=)?(?![\s\S])/;
-// Only the final quartet can contain padding. Scanning the alphabet separately avoids
-// the regexp stack growth caused by repeating a four-character group over large files.
-const canonicalBase64 = (value) => value.length % 4 === 0 && !/[^A-Za-z0-9+/]/.test(value.slice(0, -4)) && canonicalBase64Tail.test(value.slice(-4));
 /** @internal */
-export const decodedLength = (value) => value.length / 4 * 3 - (value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0);
+export const decodedLength = CanonicalBase64.decodedLength;
 /** @internal */
 export const base64 = (input) => {
     // Effect's encoder concatenates individual characters. Join bounded chunks so snapshots
@@ -64,10 +62,7 @@ export const base64 = (input) => {
 const error = (code, field) => new ImageError({ code, ...(field === undefined ? {} : { field }) });
 /** @internal */
 export const bytes = (value) => {
-    const result = Encoding.decodeBase64(value);
-    if (Result.isFailure(result))
-        throw new Error("Invalid trusted snapshot base64");
-    return result.success;
+    return CanonicalBase64.decodeTrusted(value);
 };
 /** @internal */
 export const inspect = (snapshot) => Effect.suspend(() => {
@@ -82,7 +77,7 @@ export const capture = Effect.fnUntraced(function* (input, limits) {
     const document = decoded.success;
     const records = new Map();
     let entries = 0;
-    let payload = 0;
+    let payload = ByteSize.zero;
     if (limits !== undefined && document.records.length > limits.maxRecords) {
         return yield* error("LimitExceeded", "records");
     }
@@ -101,10 +96,10 @@ export const capture = Effect.fnUntraced(function* (input, limits) {
             ? record.entries.map((entry) => entry.name)
             : [record.kind === "file" ? record.data : record.target];
         for (const value of values) {
-            if (!canonicalBase64(value))
+            if (!CanonicalBase64.isCanonical(value))
                 return yield* error("InvalidEncoding", record.id);
-            payload += decodedLength(value);
-            if (!Number.isSafeInteger(payload) || (limits !== undefined && payload > limits.maxDecodedBytes)) {
+            payload = ByteSize.sum(payload, ByteSize.bytes(decodedLength(value)));
+            if (limits !== undefined && ByteSize.isGreaterThan(payload, limits.maxDecodedBytes)) {
                 return yield* error("LimitExceeded", "bytes");
             }
         }
@@ -173,8 +168,9 @@ export const decodeSnapshot = Effect.fn("VirtualFileSystem.decodeSnapshot")(func
         return yield* error("InvalidStructure", "limits");
     if (!(input instanceof Uint8Array) || !(input.buffer instanceof ArrayBuffer))
         return yield* error("InvalidEncoding");
-    if (input.byteLength > checked.success.maxEncodedBytes)
+    if (ByteSize.isGreaterThan(ByteSize.bytes(input.byteLength), checked.success.maxEncodedBytes)) {
         return yield* error("LimitExceeded", "encodedBytes");
+    }
     const text = yield* Effect.try({
         try: () => new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array(input)),
         catch: () => error("InvalidEncoding")

package/dist/internal/overlayChanges.d.ts

@@ -0,0 +1,50 @@
+/** @internal */
+export interface ObservationMetadata {
+    readonly uid: number;
+    readonly gid: number;
+    readonly mode: number;
+    readonly atimeNs: string;
+    readonly mtimeNs: string;
+    readonly ctimeNs: string;
+    readonly birthtimeNs: string;
+}
+/** @internal */
+export interface ObservationEntry {
+    readonly path: Uint8Array;
+    readonly lineage: string | undefined;
+    readonly kind: "directory" | "file" | "symlink";
+    readonly content: Uint8Array | undefined;
+    readonly metadata: ObservationMetadata;
+}
+/** @internal */
+export type OverlayDifference = "content" | "mode" | "uid" | "gid" | "atimeNs" | "mtimeNs" | "ctimeNs" | "birthtimeNs";
+/** @internal */
+export type RawOverlayChange = {
+    readonly _tag: "Added";
+    readonly path: Uint8Array;
+    readonly kind: ObservationEntry["kind"];
+} | {
+    readonly _tag: "Removed";
+    readonly path: Uint8Array;
+    readonly kind: ObservationEntry["kind"];
+} | {
+    readonly _tag: "Replaced";
+    readonly path: Uint8Array;
+    readonly beforeKind: ObservationEntry["kind"];
+    readonly afterKind: ObservationEntry["kind"];
+    readonly differences: ReadonlyArray<OverlayDifference>;
+} | {
+    readonly _tag: "Renamed";
+    readonly from: Uint8Array;
+    readonly to: Uint8Array;
+    readonly kind: ObservationEntry["kind"];
+    readonly differences: ReadonlyArray<OverlayDifference>;
+} | {
+    readonly _tag: "Updated";
+    readonly path: Uint8Array;
+    readonly kind: ObservationEntry["kind"];
+    readonly differences: ReadonlyArray<OverlayDifference>;
+};
+/** @internal */
+export declare const compareOverlay: (base: ReadonlyArray<ObservationEntry>, current: ReadonlyArray<ObservationEntry>, includeTimestamps?: boolean) => ReadonlyArray<RawOverlayChange>;
+//# sourceMappingURL=overlayChanges.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"overlayChanges.d.ts","sourceRoot":"","sources":["../../src/internal/overlayChanges.ts"],"names":[],"mappings":"AAGA,gBAAgB;AAChB,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;AAED,gBAAgB;AAChB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAAA;IAC/C,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,SAAS,CAAA;IACxC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAA;CACvC;AAED,gBAAgB;AAChB,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CAAA;AAEtH,gBAAgB;AAChB,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;CAAE,GAC9F;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;CAAE,GAChG;IACA,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAC7C,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAC5C,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;CACvD,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IACvC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;CACvD,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAA;IACvC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;CACvD,CAAA;AA4EH,gBAAgB;AAChB,eAAO,MAAM,cAAc,SACnB,aAAa,CAAC,gBAAgB,CAAC,WAC5B,aAAa,CAAC,gBAAgB,CAAC,kCAEvC,aAAa,CAAC,gBAAgB,CAoEhC,CAAA"}

package/dist/internal/overlayChanges.js

@@ -0,0 +1,146 @@
+import * as Encoding from "effect/Encoding";
+import * as Equal from "effect/Equal";
+const timestampFields = new Set(["atimeNs", "mtimeNs", "ctimeNs", "birthtimeNs"]);
+const differenceOrder = [
+    "content",
+    "mode",
+    "uid",
+    "gid",
+    "atimeNs",
+    "mtimeNs",
+    "ctimeNs",
+    "birthtimeNs"
+];
+const tagOrder = {
+    Added: 0,
+    Removed: 1,
+    Replaced: 2,
+    Renamed: 3,
+    Updated: 4
+};
+const key = Encoding.encodeHex;
+const comparePaths = (left, right) => {
+    const length = Math.min(left.length, right.length);
+    for (let index = 0; index < length; index++) {
+        const difference = left[index] - right[index];
+        if (difference !== 0)
+            return difference;
+    }
+    return left.length - right.length;
+};
+const sameBytes = (left, right) => {
+    return Equal.equals(left, right);
+};
+const differences = (before, after, includeTimestamps) => differenceOrder.filter((field) => {
+    if (!includeTimestamps && timestampFields.has(field))
+        return false;
+    if (field === "content")
+        return before.kind !== after.kind || !sameBytes(before.content, after.content);
+    return before.metadata[field] !== after.metadata[field];
+});
+const byLineage = (entries) => {
+    const result = new Map();
+    for (const entry of entries) {
+        if (entry.lineage === undefined)
+            continue;
+        const group = result.get(entry.lineage);
+        if (group === undefined)
+            result.set(entry.lineage, new Map([[key(entry.path), entry]]));
+        else
+            group.set(key(entry.path), entry);
+    }
+    return result;
+};
+const copyChange = (change) => {
+    switch (change._tag) {
+        case "Added":
+        case "Removed":
+            return Object.freeze({ ...change, path: change.path.slice() });
+        case "Replaced":
+        case "Updated":
+            return Object.freeze({
+                ...change,
+                path: change.path.slice(),
+                differences: Object.freeze([...change.differences])
+            });
+        case "Renamed":
+            return Object.freeze({
+                ...change,
+                from: change.from.slice(),
+                to: change.to.slice(),
+                differences: Object.freeze([...change.differences])
+            });
+    }
+};
+/** @internal */
+export const compareOverlay = (base, current, includeTimestamps = false) => {
+    const basePaths = new Map(base.map((entry) => [key(entry.path), entry]));
+    const currentPaths = new Map(current.map((entry) => [key(entry.path), entry]));
+    const baseLineages = byLineage(base);
+    const currentLineages = byLineage(current);
+    const consumedBase = new Set();
+    const consumedCurrent = new Set();
+    const changes = [];
+    for (const [lineage, beforeEntries] of baseLineages) {
+        const afterEntries = currentLineages.get(lineage);
+        if (afterEntries === undefined)
+            continue;
+        const removed = [...beforeEntries].filter(([pathKey]) => !afterEntries.has(pathKey)).map(([, entry]) => entry);
+        const added = [...afterEntries].filter(([pathKey]) => !beforeEntries.has(pathKey)).map(([, entry]) => entry);
+        if (removed.length !== 1 || added.length !== 1)
+            continue;
+        const before = removed[0];
+        const after = added[0];
+        consumedBase.add(key(before.path));
+        consumedCurrent.add(key(after.path));
+        changes.push({
+            _tag: "Renamed",
+            from: before.path,
+            to: after.path,
+            kind: after.kind,
+            differences: differences(before, after, includeTimestamps)
+        });
+    }
+    for (const before of base) {
+        const pathKey = key(before.path);
+        if (consumedBase.has(pathKey))
+            continue;
+        const after = currentPaths.get(pathKey);
+        if (after === undefined || consumedCurrent.has(pathKey)) {
+            changes.push({ _tag: "Removed", path: before.path, kind: before.kind });
+            continue;
+        }
+        consumedCurrent.add(pathKey);
+        if (before.lineage === undefined || before.lineage !== after.lineage) {
+            changes.push({
+                _tag: "Replaced",
+                path: before.path,
+                beforeKind: before.kind,
+                afterKind: after.kind,
+                differences: differences(before, after, includeTimestamps)
+            });
+            continue;
+        }
+        const changed = differences(before, after, includeTimestamps);
+        if (changed.length > 0)
+            changes.push({ _tag: "Updated", path: before.path, kind: after.kind, differences: changed });
+    }
+    for (const after of current) {
+        const pathKey = key(after.path);
+        if (!consumedCurrent.has(pathKey) && (!basePaths.has(pathKey) || consumedBase.has(pathKey))) {
+            changes.push({ _tag: "Added", path: after.path, kind: after.kind });
+        }
+    }
+    changes.sort((left, right) => {
+        const leftPath = left._tag === "Renamed" ? left.from : left.path;
+        const rightPath = right._tag === "Renamed" ? right.from : right.path;
+        const pathOrder = comparePaths(leftPath, rightPath);
+        if (pathOrder !== 0)
+            return pathOrder;
+        const typeOrder = tagOrder[left._tag] - tagOrder[right._tag];
+        if (typeOrder !== 0)
+            return typeOrder;
+        return left._tag === "Renamed" && right._tag === "Renamed" ? comparePaths(left.to, right.to) : 0;
+    });
+    return Object.freeze(changes.map(copyChange));
+};

package/dist/internal/overlayTesting.d.ts

@@ -0,0 +1,12 @@
+/** Package-internal synchronization hooks for deterministic overlay tests. @internal */
+import type * as Effect from "effect/Effect";
+import type { Snapshot } from "../Snapshot.js";
+/** @internal */
+export interface ObservationHook {
+    readonly betweenSnapshotAndSummary: Effect.Effect<void>;
+}
+/** @internal */
+export declare const getObservationHook: (snapshot: Snapshot) => ObservationHook | undefined;
+/** @internal */
+export declare const setObservationHook: (snapshot: Snapshot, hook: ObservationHook) => () => void;
+//# sourceMappingURL=overlayTesting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"overlayTesting.d.ts","sourceRoot":"","sources":["../../src/internal/overlayTesting.ts"],"names":[],"mappings":"AAAA,wFAAwF;AAExF,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAE9C,gBAAgB;AAChB,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,yBAAyB,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CACxD;AAID,gBAAgB;AAChB,eAAO,MAAM,kBAAkB,aAAc,QAAQ,KAAG,eAAe,GAAG,SAA2C,CAAA;AAErH,gBAAgB;AAChB,eAAO,MAAM,kBAAkB,aAAc,QAAQ,QAAQ,eAAe,KAAG,MAAM,IAKpF,CAAA"}

package/dist/internal/overlayTesting.js

@@ -0,0 +1,12 @@
+/** Package-internal synchronization hooks for deterministic overlay tests. @internal */
+const observationHooks = new WeakMap();
+/** @internal */
+export const getObservationHook = (snapshot) => observationHooks.get(snapshot);
+/** @internal */
+export const setObservationHook = (snapshot, hook) => {
+    observationHooks.set(snapshot, hook);
+    return () => {
+        if (observationHooks.get(snapshot) === hook)
+            observationHooks.delete(snapshot);
+    };
+};

package/dist/internal/snapshotDelta.d.ts

@@ -0,0 +1,88 @@
+/** 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";
+import { ImageError, type Snapshot } from "../Snapshot.js";
+import { type SnapshotDelta, SnapshotDeltaError } from "../SnapshotDelta.js";
+/** @internal */
+export declare const diffSnapshots: (base: Snapshot, target: Snapshot, limits: {
+    readonly maxEncodedBytes: ByteSize.ByteSize;
+    readonly maxIdentityBytes: ByteSize.ByteSize;
+    readonly maxDeltaRecords: number;
+    readonly maxDecodedDeltaBytes: ByteSize.ByteSize;
+    readonly maxBaseRecords: number;
+    readonly maxTargetRecords: number;
+    readonly maxEntries: number;
+    readonly maxOutputRecords: number;
+    readonly maxOutputBytes: ByteSize.ByteSize;
+    readonly maxInheritedRecords: number;
+}) => Effect.Effect<SnapshotDelta, ImageError | import("effect/PlatformError").PlatformError, Crypto.Crypto>;
+/** @internal */
+export declare const inspectSnapshotDelta: (base: Snapshot, delta: SnapshotDelta, options: {
+    readonly includeTimestamps?: boolean;
+}, limits: {
+    readonly maxEncodedBytes: ByteSize.ByteSize;
+    readonly maxIdentityBytes: ByteSize.ByteSize;
+    readonly maxDeltaRecords: number;
+    readonly maxDecodedDeltaBytes: ByteSize.ByteSize;
+    readonly maxBaseRecords: number;
+    readonly maxTargetRecords: number;
+    readonly maxEntries: number;
+    readonly maxOutputRecords: number;
+    readonly maxOutputBytes: ByteSize.ByteSize;
+    readonly maxInheritedRecords: number;
+}) => Effect.Effect<readonly ({
+    readonly _tag: "Added";
+    readonly path: import("../BytePath.js").BytePath;
+    readonly kind: "directory" | "file" | "symlink";
+} | {
+    readonly _tag: "Removed";
+    readonly path: import("../BytePath.js").BytePath;
+    readonly kind: "directory" | "file" | "symlink";
+} | {
+    readonly _tag: "Updated";
+    readonly path: import("../BytePath.js").BytePath;
+    readonly beforeKind: "directory" | "file" | "symlink";
+    readonly afterKind: "directory" | "file" | "symlink";
+    readonly differences: readonly ("atimeNs" | "birthtimeNs" | "content" | "ctimeNs" | "gid" | "hardLinks" | "kind" | "mode" | "mtimeNs" | "target" | "uid")[];
+})[], ImageError | import("effect/PlatformError").PlatformError | SnapshotDeltaError, Crypto.Crypto>;
+/** @internal */
+export declare const encodeSnapshotDelta: (delta: SnapshotDelta, limits: {
+    readonly maxEncodedBytes: ByteSize.ByteSize;
+    readonly maxIdentityBytes: ByteSize.ByteSize;
+    readonly maxDeltaRecords: number;
+    readonly maxDecodedDeltaBytes: ByteSize.ByteSize;
+    readonly maxBaseRecords: number;
+    readonly maxTargetRecords: number;
+    readonly maxEntries: number;
+    readonly maxOutputRecords: number;
+    readonly maxOutputBytes: ByteSize.ByteSize;
+    readonly maxInheritedRecords: number;
+}) => Effect.Effect<Uint8Array<ArrayBuffer>, ImageError, never>;
+/** @internal */
+export declare const decodeSnapshotDelta: (input: Uint8Array<ArrayBufferLike>, limits: {
+    readonly maxEncodedBytes: ByteSize.ByteSize;
+    readonly maxIdentityBytes: ByteSize.ByteSize;
+    readonly maxDeltaRecords: number;
+    readonly maxDecodedDeltaBytes: ByteSize.ByteSize;
+    readonly maxBaseRecords: number;
+    readonly maxTargetRecords: number;
+    readonly maxEntries: number;
+    readonly maxOutputRecords: number;
+    readonly maxOutputBytes: ByteSize.ByteSize;
+    readonly maxInheritedRecords: number;
+}) => Effect.Effect<SnapshotDelta, ImageError, never>;
+/** @internal */
+export declare const applySnapshotDelta: (base: Snapshot, delta: SnapshotDelta, limits: {
+    readonly maxEncodedBytes: ByteSize.ByteSize;
+    readonly maxIdentityBytes: ByteSize.ByteSize;
+    readonly maxDeltaRecords: number;
+    readonly maxDecodedDeltaBytes: ByteSize.ByteSize;
+    readonly maxBaseRecords: number;
+    readonly maxTargetRecords: number;
+    readonly maxEntries: number;
+    readonly maxOutputRecords: number;
+    readonly maxOutputBytes: ByteSize.ByteSize;
+    readonly maxInheritedRecords: number;
+}) => Effect.Effect<Snapshot, ImageError | import("effect/PlatformError").PlatformError | SnapshotDeltaError, Crypto.Crypto>;
+//# sourceMappingURL=snapshotDelta.d.ts.map

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

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