@effect-vfs/core 0.5.0 → 0.6.0

package/dist/internal/merkle.js

@@ -0,0 +1,179 @@
+// This versioned digest covers namespace content and hard-link groups, independent of inode numbers. Framing,
+// byte order, and domain prefix are part of the persisted delta contract.
+import * as ByteSize from "effect/ByteSize";
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import { bytesOrder } from "./bytes.js";
+import { imageFailure } from "./errors.js";
+import { joinPath, nameBytes, ROOT_PATH } from "./path.js";
+import { byEntryName, getNode, payloadOf, ROOT_INO } from "./volumeState.js";
+const ALGORITHM = "effect-vfs-semantic-sha256-v1";
+/** @internal */
+export const DIGEST_BYTES = 32;
+const U64_BYTES = 8;
+const encoder = new TextEncoder();
+const IDENTITY_PREFIX = encoder.encode(`${ALGORITHM}\0`);
+const KIND_BYTE = { directory: 0, file: 1, symlink: 2 };
+const u64 = (out, offset, n) => {
+    new DataView(out.buffer, out.byteOffset).setBigUint64(offset, BigInt(n), false);
+    return offset + U64_BYTES;
+};
+const frame = (out, offset, bytes) => {
+    const at = u64(out, offset, bytes.length);
+    out.set(bytes, at);
+    return at + bytes.length;
+};
+const stamps = (node) => [node.metadata.atimeNs, node.metadata.mtimeNs, node.metadata.ctimeNs, node.metadata.birthtimeNs].map((value) => encoder.encode(String(value)));
+const layout = (node) => {
+    const times = stamps(node);
+    const entries = node.kind === "directory"
+        ? [...node.entries].sort(byEntryName).map(([name, ino]) => [nameBytes(name), ino])
+        : [];
+    const body = payloadOf(node);
+    const length = 1 + 3 * U64_BYTES + times.reduce((sum, stamp) => sum + U64_BYTES + stamp.length, 0) +
+        (body === undefined
+            ? U64_BYTES + entries.reduce((sum, [name]) => sum + U64_BYTES + name.length + DIGEST_BYTES, 0)
+            : U64_BYTES + body.length);
+    return { times, entries, body, length };
+};
+/** @internal */
+export const nodeBytes = (node) => layout(node).length;
+const preimage = (node, { body, entries, length, times }, childDigest) => {
+    const out = new Uint8Array(length);
+    out[0] = KIND_BYTE[node.kind];
+    let offset = u64(out, 1, node.metadata.uid);
+    offset = u64(out, offset, node.metadata.gid);
+    offset = u64(out, offset, node.metadata.mode);
+    for (const stamp of times)
+        offset = frame(out, offset, stamp);
+    if (body !== undefined)
+        frame(out, offset, body);
+    else {
+        offset = u64(out, offset, entries.length);
+        for (const [name, ino] of entries) {
+            offset = frame(out, offset, name);
+            out.set(childDigest(ino), offset);
+            offset += DIGEST_BYTES;
+        }
+    }
+    return out;
+};
+/** @internal */
+export const meter = (budget) => {
+    let hashed = 0;
+    return {
+        charge: (bytes) => Effect.suspend(() => {
+            hashed += bytes;
+            return ByteSize.isGreaterThan(ByteSize.bytes(hashed), budget.identityBytes)
+                ? Effect.fail(imageFailure(budget.operation, "LimitExceeded", { field: "identityBytes" }))
+                : Effect.void;
+        }),
+        spent: () => hashed
+    };
+};
+/** @internal */
+export const nodeDigest = Effect.fnUntraced(function* (node, childDigest, meter) {
+    const crypto = yield* Crypto.Crypto;
+    const planned = layout(node);
+    // Reject oversized nodes before allocating their preimage.
+    yield* meter.charge(planned.length);
+    return yield* crypto.digest("SHA-256", preimage(node, planned, childDigest));
+});
+/** @internal */
+export const identityDigest = Effect.fnUntraced(function* (root, groups, meter) {
+    const crypto = yield* Crypto.Crypto;
+    const sorted = [...groups].sort((a, b) => bytesOrder(a[0], b[0]));
+    const length = IDENTITY_PREFIX.length + DIGEST_BYTES + U64_BYTES +
+        sorted.reduce((sum, group) => group.reduce((inner, path) => inner + U64_BYTES + path.length, sum + U64_BYTES), 0);
+    yield* meter.charge(length);
+    const out = new Uint8Array(length);
+    out.set(IDENTITY_PREFIX);
+    out.set(root, IDENTITY_PREFIX.length);
+    let offset = u64(out, IDENTITY_PREFIX.length + DIGEST_BYTES, sorted.length);
+    for (const group of sorted) {
+        offset = u64(out, offset, group.length);
+        for (const path of group)
+            offset = frame(out, offset, path);
+    }
+    return yield* crypto.digest("SHA-256", out);
+});
+// Digest leaves first and directories in reverse walk order so every child digest exists before its parent.
+/** @internal */
+export const identify = Effect.fnUntraced(function* (state, budget) {
+    const root = getNode(state, ROOT_INO);
+    if (root?.kind !== "directory") {
+        return yield* imageFailure(budget.operation, "InvalidStructure", { field: "root" });
+    }
+    const order = [root];
+    // The root is a record too, so a limit of zero refuses even an empty snapshot.
+    if (order.length > budget.records) {
+        return yield* imageFailure(budget.operation, "LimitExceeded", { field: budget.recordsField });
+    }
+    const seen = new Set([ROOT_INO]);
+    const directoryPaths = new Map([[ROOT_INO, ROOT_PATH]]);
+    const named = new Map();
+    let entries = 0;
+    for (let index = 0; index < order.length; index++) {
+        const node = order[index];
+        if (node.kind !== "directory")
+            continue;
+        const path = directoryPaths.get(node.ino);
+        for (const [name, ino] of node.entries) {
+            if (++entries > budget.entries) {
+                return yield* imageFailure(budget.operation, "LimitExceeded", { field: "entries" });
+            }
+            const child = getNode(state, ino);
+            if (child === undefined)
+                continue;
+            if (child.kind === "directory")
+                directoryPaths.set(ino, joinPath(path, nameBytes(name)));
+            else if (child.links.length > 1) {
+                const paths = named.get(ino);
+                const childPath = joinPath(path, nameBytes(name));
+                if (paths === undefined)
+                    named.set(ino, [childPath]);
+                else
+                    paths.push(childPath);
+            }
+            if (seen.has(ino))
+                continue;
+            seen.add(ino);
+            order.push(child);
+            if (order.length > budget.records) {
+                return yield* imageFailure(budget.operation, "LimitExceeded", { field: budget.recordsField });
+            }
+        }
+    }
+    const digests = new Map();
+    const measure = meter(budget);
+    const lookup = (ino) => digests.get(ino);
+    let payloadBytes = 0;
+    const leavesFirst = [
+        ...order.filter((node) => node.kind !== "directory"),
+        ...order.filter((node) => node.kind === "directory").reverse()
+    ];
+    for (const node of leavesFirst) {
+        const body = payloadOf(node);
+        if (body !== undefined) {
+            payloadBytes += body.length;
+            if (budget.payloadBytes !== undefined &&
+                ByteSize.isGreaterThan(ByteSize.bytes(payloadBytes), budget.payloadBytes.limit)) {
+                return yield* imageFailure(budget.operation, "LimitExceeded", { field: budget.payloadBytes.field });
+            }
+        }
+        digests.set(node.ino, yield* nodeDigest(node, lookup, measure));
+    }
+    const groups = new Map();
+    for (const [ino, paths] of named)
+        if (paths.length > 1)
+            groups.set(ino, paths.sort(bytesOrder));
+    const nodeBytes = measure.spent();
+    return {
+        digest: yield* identityDigest(digests.get(ROOT_INO), groups.values(), measure),
+        digests,
+        groups,
+        records: order.length,
+        payloadBytes,
+        nodeBytes
+    };
+});

package/dist/internal/metadata.d.ts

@@ -1,18 +1,7 @@
 import * as Schema from "effect/Schema";
+import { Timestamp } from "../Metadata.js";
 /** @internal */
-export declare const Timestamp: Schema.BigInt;
-/** @internal */
-export declare const TimestampFromString: Schema.decodeTo<Schema.BigInt, Schema.String, never, never>;
-/** @internal */
-export declare const WireStoredMetadata: Schema.Struct<{
-    readonly uid: Schema.Natural;
-    readonly gid: Schema.Natural;
-    readonly mode: Schema.Natural;
-    readonly atimeNs: Schema.String;
-    readonly mtimeNs: Schema.String;
-    readonly ctimeNs: Schema.String;
-    readonly birthtimeNs: Schema.String;
-}>;
+export { Timestamp };
 /** @internal */
 export declare const StoredMetadata: Schema.Struct<{
     readonly uid: Schema.Natural;

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

@@ -1 +1 @@
-{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/internal/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC,gBAAgB;AAChB,eAAO,MAAM,SAAS,eAGrB,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,mBAAmB,6DAE0C,CAAA;AAE1E,gBAAgB;AAChB,eAAO,MAAM,kBAAkB;;;;;;;;EAQ7B,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,cAAc;;;;;;;;EAQzB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA"}
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/internal/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAG1C,gBAAgB;AAChB,OAAO,EAAE,SAAS,EAAE,CAAA;AAMpB,gBAAgB;AAChB,eAAO,MAAM,cAAc;;;;;;;;EAQzB,CAAA;AAEF,gBAAgB;AAChB,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA"}

package/dist/internal/metadata.js

@@ -1,23 +1,13 @@
 import * as Schema from "effect/Schema";
 import * as SchemaTransformation from "effect/SchemaTransformation";
-const MAX_TIMESTAMP = 10n ** 128n - 1n;
+import { Timestamp } from "../Metadata.js";
+import { ENCODING_CHECK } from "./errors.js";
 /** @internal */
-export const Timestamp = Schema.BigInt.check(Schema.isGreaterThanOrEqualToBigInt(-MAX_TIMESTAMP), Schema.isLessThanOrEqualToBigInt(MAX_TIMESTAMP));
-/** @internal */
-export const TimestampFromString = Schema.String
-    .check(Schema.isPattern(/^-?[0-9]{1,128}$/))
+export { Timestamp };
+const TimestampFromString = Schema.String
+    .check(Schema.isPattern(/^-?[0-9]{1,128}$/, { [ENCODING_CHECK]: true }))
     .pipe(Schema.decodeTo(Timestamp, SchemaTransformation.bigintFromString));
 /** @internal */
-export const WireStoredMetadata = Schema.Struct({
-    uid: Schema.Natural,
-    gid: Schema.Natural,
-    mode: Schema.Natural.check(Schema.isLessThanOrEqualTo(0o7777)),
-    atimeNs: Schema.String,
-    mtimeNs: Schema.String,
-    ctimeNs: Schema.String,
-    birthtimeNs: Schema.String
-});
-/** @internal */
 export const StoredMetadata = Schema.Struct({
     uid: Schema.Natural,
     gid: Schema.Natural,

package/dist/internal/overlayDiff.d.ts

@@ -7,8 +7,7 @@ export interface ObservationEntry {
     readonly content: Uint8Array | undefined;
     readonly metadata: StoredMetadata;
 }
-/** @internal */
-export type OverlayDifference = "content" | "mode" | "uid" | "gid" | "atimeNs" | "mtimeNs" | "ctimeNs" | "birthtimeNs";
+type OverlayDifference = "content" | "mode" | "uid" | "gid" | "atimeNs" | "mtimeNs" | "ctimeNs" | "birthtimeNs";
 /** @internal */
 export type RawOverlayChange = {
     readonly _tag: "Added";
@@ -38,4 +37,5 @@ export type RawOverlayChange = {
 };
 /** @internal */
 export declare const compareOverlay: (base: ReadonlyArray<ObservationEntry>, current: ReadonlyArray<ObservationEntry>, includeTimestamps?: boolean) => ReadonlyArray<RawOverlayChange>;
+export {};
 //# sourceMappingURL=overlayDiff.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"overlayDiff.d.ts","sourceRoot":"","sources":["../../src/internal/overlayDiff.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAEnD,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,cAAc,CAAA;CAClC;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;AA4DH,gBAAgB;AAChB,eAAO,MAAM,cAAc,SACnB,aAAa,CAAC,gBAAgB,CAAC,WAC5B,aAAa,CAAC,gBAAgB,CAAC,kCAEvC,aAAa,CAAC,gBAAgB,CAgFhC,CAAA"}
+{"version":3,"file":"overlayDiff.d.ts","sourceRoot":"","sources":["../../src/internal/overlayDiff.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAEnD,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,cAAc,CAAA;CAClC;AAED,KAAK,iBAAiB,GAAG,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CAAA;AAE/G,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;AA2DH,gBAAgB;AAChB,eAAO,MAAM,cAAc,SACnB,aAAa,CAAC,gBAAgB,CAAC,WAC5B,aAAa,CAAC,gBAAgB,CAAC,kCAEvC,aAAa,CAAC,gBAAgB,CA8EhC,CAAA"}

package/dist/internal/overlayDiff.js

@@ -23,7 +23,6 @@ const tagOrder = {
     Updated: 4
 };
 const key = Encoding.encodeHex;
-// Output order: source path bytewise (a rename sorts by its `from`), then Added, Removed, Replaced, Renamed, Updated.
 const sourcePath = (change) => Predicate.isTagged("Renamed")(change) ? change.from : change.path;
 const changeOrder = Order.combine(Order.mapInput(bytesOrder, sourcePath), Order.mapInput(Order.Number, (change) => tagOrder[change._tag]));
 const differences = (before, after, includeTimestamps) => Object.freeze(differenceOrder.filter((field) => {
@@ -88,7 +87,6 @@ export const compareOverlay = (base, current, includeTimestamps = false) => {
         if (renameSources.has(pathKey))
             continue;
         const after = currentPaths.get(pathKey);
-        // Gone, or the path's current occupant arrived by rename: the base entry was removed either way.
         if (after === undefined || renameTargets.has(pathKey)) {
             changes.push(RawOverlayChange.Removed({ path: before.path.slice(), kind: before.kind }));
             continue;
@@ -109,7 +107,6 @@ export const compareOverlay = (base, current, includeTimestamps = false) => {
     }
     for (const after of current) {
         const pathKey = key(after.path);
-        // A new path, or one whose base occupant was renamed away; rename targets were already reported.
         if (!renameTargets.has(pathKey) && (!basePaths.has(pathKey) || renameSources.has(pathKey))) {
             changes.push(RawOverlayChange.Added({ path: after.path.slice(), kind: after.kind }));
         }

package/dist/internal/path.d.ts

@@ -2,8 +2,8 @@ import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
 import * as Result from "effect/Result";
 import type { BytePath } from "../BytePath.js";
+import type { FsFailure } from "../VfsError.js";
 import type { PathInput } from "../VirtualFileSystem.js";
-import { FsError } from "./errors.js";
 /** @internal */
 export declare const SLASH_HEX = "2f";
 /** @internal */
@@ -13,21 +13,31 @@ export declare const DOT_DOT_HEX = "2e2e";
 /** @internal */
 export declare const SLASH_BYTE = 47;
 /** @internal */
+export declare const NUL_BYTE = 0;
+/** @internal */
+export declare const MAX_SYMLINK_TRAVERSALS = 40;
+/** @internal */
 export declare const MAX_NAME_BYTES = 255;
 /** @internal */
+export declare const isNameBytes: (name: Uint8Array) => boolean;
+/** @internal */
+export declare const ROOT_PATH: Uint8Array<ArrayBuffer>;
+/** @internal */
+export declare const joinPath: (prefix: Uint8Array, name: Uint8Array) => Uint8Array;
+/** @internal */
 export declare const isDotComponent: (name: string | undefined) => name is undefined | typeof DOT_HEX | typeof DOT_DOT_HEX;
 /** @internal */
 export declare const ownedPath: (bytes: Uint8Array) => BytePath;
 /** @internal */
-export declare const strictString: (bytes: Uint8Array, operation: string) => Effect.Effect<string, FsError, never>;
+export declare const strictString: (bytes: Uint8Array, operation: string) => Effect.Effect<string, FsFailure, never>;
 /** @internal */
 export declare const nameBytes: (name: string) => Uint8Array;
 /** @internal */
 export declare const isAttachedBytes: (bytes: Uint8Array) => boolean;
 /** @internal */
-export declare const pathFromBytes: (bytes: Uint8Array<ArrayBufferLike>) => Effect.Effect<BytePath, FsError, never>;
+export declare const pathFromBytes: (bytes: Uint8Array<ArrayBufferLike>) => Effect.Effect<BytePath, FsFailure, never>;
 /** @internal */
-export declare const pathToBytes: (path: BytePath) => Effect.Effect<Uint8Array<ArrayBuffer>, FsError, never>;
+export declare const pathToBytes: (path: BytePath) => Effect.Effect<Uint8Array<ArrayBuffer>, FsFailure, never>;
 /** @internal */
 export interface PreparedPath {
     readonly input: PathInput;
@@ -38,7 +48,9 @@ export interface PreparedPath {
     readonly components: ReadonlyArray<string>;
 }
 /** @internal */
+export declare const isWellFormed: (value: string) => boolean;
+/** @internal */
 export declare const inputBytes: (input: PathInput) => Result.Result<Uint8Array, "InvalidPathEncoding" | "InvalidArgument">;
 /** @internal */
-export declare const preparePath: (input: PathInput, operation: string, maxPathBytes: ByteSize.ByteSize | undefined) => Result.Result<PreparedPath, FsError>;
+export declare const preparePath: (input: PathInput, operation: string, maxPathBytes: ByteSize.ByteSize | undefined) => Result.Result<PreparedPath, FsFailure>;
 //# sourceMappingURL=path.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/internal/path.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,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAExD,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAGrC,gBAAgB;AAChB,eAAO,MAAM,SAAS,OAAO,CAAA;AAE7B,gBAAgB;AAChB,eAAO,MAAM,OAAO,OAAO,CAAA;AAE3B,gBAAgB;AAChB,eAAO,MAAM,WAAW,SAAS,CAAA;AAEjC,gBAAgB;AAChB,eAAO,MAAM,UAAU,KAAK,CAAA;AAG5B,gBAAgB;AAChB,eAAO,MAAM,cAAc,MAAM,CAAA;AAKjC,gBAAgB;AAChB,eAAO,MAAM,cAAc,SAAU,MAAM,GAAG,SAAS,KAAG,IAAI,IAAI,SAAS,GAAG,OAAO,OAAO,GAAG,OAAO,WACtC,CAAA;AAEhE,gBAAgB;AAChB,eAAO,MAAM,SAAS,UAAW,UAAU,KAAG,QAA+B,CAAA;AAE7E,gBAAgB;AAChB,eAAO,MAAM,YAAY,UAAW,UAAU,aAAa,MAAM,0CAI7D,CAAA;AAEJ,gBAAgB;AAChB,eAAO,MAAM,SAAS,SAAU,MAAM,KAAG,UAAyD,CAAA;AAgBlG,gBAAgB;AAChB,eAAO,MAAM,eAAe,UAAW,UAAU,KAAG,OAC2C,CAAA;AAE/F,gBAAgB;AAChB,eAAO,MAAM,aAAa,iFASxB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,WAAW,4EAMtB,CAAA;AAEF,gBAAgB;AAChB,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IAC5C,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAC3C;AAoBD,gBAAgB;AAChB,eAAO,MAAM,UAAU,UAAW,SAAS,KAAG,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,qBAAqB,GAAG,iBAAiB,CAG5B,CAAA;AAErF,gBAAgB;AAChB,eAAO,MAAM,WAAW,UACf,SAAS,aACL,MAAM,gBACH,QAAQ,CAAC,QAAQ,GAAG,SAAS,KAC1C,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,OAAO,CAgDrC,CAAA"}
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/internal/path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAIxD,gBAAgB;AAChB,eAAO,MAAM,SAAS,OAAO,CAAA;AAC7B,gBAAgB;AAChB,eAAO,MAAM,OAAO,OAAO,CAAA;AAC3B,gBAAgB;AAChB,eAAO,MAAM,WAAW,SAAS,CAAA;AACjC,gBAAgB;AAChB,eAAO,MAAM,UAAU,KAAK,CAAA;AAE5B,gBAAgB;AAChB,eAAO,MAAM,QAAQ,IAAI,CAAA;AACzB,gBAAgB;AAChB,eAAO,MAAM,sBAAsB,KAAK,CAAA;AACxC,gBAAgB;AAChB,eAAO,MAAM,cAAc,MAAM,CAAA;AAEjC,gBAAgB;AAChB,eAAO,MAAM,WAAW,SAAU,UAAU,KAAG,OAEuE,CAAA;AAEtH,gBAAgB;AAChB,eAAO,MAAM,SAAS,yBAA+B,CAAA;AAErD,gBAAgB;AAChB,eAAO,MAAM,QAAQ,WAAY,UAAU,QAAQ,UAAU,KAAG,UAS/D,CAAA;AAGD,gBAAgB;AAChB,eAAO,MAAM,cAAc,SAAU,MAAM,GAAG,SAAS,KAAG,IAAI,IAAI,SAAS,GAAG,OAAO,OAAO,GAAG,OAAO,WACtC,CAAA;AAEhE,gBAAgB;AAChB,eAAO,MAAM,SAAS,UAAW,UAAU,KAAG,QAA+B,CAAA;AAE7E,gBAAgB;AAChB,eAAO,MAAM,YAAY,UAAW,UAAU,aAAa,MAAM,4CAI7D,CAAA;AAEJ,gBAAgB;AAChB,eAAO,MAAM,SAAS,SAAU,MAAM,KAAG,UAAyD,CAAA;AAelG,gBAAgB;AAChB,eAAO,MAAM,eAAe,UAAW,UAAU,KAAG,OAC2C,CAAA;AAE/F,gBAAgB;AAChB,eAAO,MAAM,aAAa,mFASxB,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,WAAW,8EAMtB,CAAA;AAEF,gBAAgB;AAChB,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IAC5C,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAC3C;AAGD,gBAAgB;AAChB,eAAO,MAAM,YAAY,UAAW,MAAM,KAAG,OAY5C,CAAA;AAID,gBAAgB;AAChB,eAAO,MAAM,UAAU,UAAW,SAAS,KAAG,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,qBAAqB,GAAG,iBAAiB,CAG5B,CAAA;AAErF,gBAAgB;AAChB,eAAO,MAAM,WAAW,UACf,SAAS,aACL,MAAM,gBACH,QAAQ,CAAC,QAAQ,GAAG,SAAS,KAC1C,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,CAgDvC,CAAA"}

package/dist/internal/path.js

@@ -1,12 +1,10 @@
-// Byte-preserving path validation and conversion.
 import * as ByteSize from "effect/ByteSize";
 import * as Effect from "effect/Effect";
 import * as Encoding from "effect/Encoding";
 import * as Predicate from "effect/Predicate";
 import * as Result from "effect/Result";
 import { getBytes as getBytePathBytes, make as makeBytePath } from "./bytePath.js";
-import { FsError } from "./errors.js";
-// Components are hex-encoded bytes so names compare as bytes, not text: 2f is "/", 2e is ".", 2e2e is "..".
+import { fsFailure } from "./errors.js";
 /** @internal */
 export const SLASH_HEX = "2f";
 /** @internal */
@@ -15,12 +13,29 @@ export const DOT_HEX = "2e";
 export const DOT_DOT_HEX = "2e2e";
 /** @internal */
 export const SLASH_BYTE = 47;
-// POSIX NAME_MAX: the longest single path component.
+const DOT_BYTE = 46;
+/** @internal */
+export const NUL_BYTE = 0;
+/** @internal */
+export const MAX_SYMLINK_TRAVERSALS = 40;
 /** @internal */
 export const MAX_NAME_BYTES = 255;
-// A missing final component is rejected wherever "." and ".." are, so it counts as a dot component.
-// Callers pass the code POSIX gives their operation, so the codes differ on purpose: EEXIST for
-// create (link, symlink, mkdir), EISDIR for open and unlink, EINVAL for rename and rmdir.
+/** @internal */
+export const isNameBytes = (name) => name.length >= 1 && name.length <= MAX_NAME_BYTES && !name.includes(NUL_BYTE) && !name.includes(SLASH_BYTE) &&
+    !(name.length === 1 && name[0] === DOT_BYTE) && !(name.length === 2 && name[0] === DOT_BYTE && name[1] === DOT_BYTE);
+/** @internal */
+export const ROOT_PATH = new Uint8Array([SLASH_BYTE]);
+/** @internal */
+export const joinPath = (prefix, name) => {
+    const separator = prefix.length === 0 || prefix[prefix.length - 1] === SLASH_BYTE ? 0 : 1;
+    const joined = new Uint8Array(prefix.length + separator + name.length);
+    joined.set(prefix);
+    if (separator === 1)
+        joined[prefix.length] = SLASH_BYTE;
+    joined.set(name, prefix.length + separator);
+    return joined;
+};
+// A missing final component follows the same rejection path as "." and ".."; callers choose the POSIX error code.
 /** @internal */
 export const isDotComponent = (name) => name === undefined || name === DOT_HEX || name === DOT_DOT_HEX;
 /** @internal */
@@ -28,11 +43,11 @@ export const ownedPath = (bytes) => makeBytePath(bytes);
 /** @internal */
 export const strictString = (bytes, operation) => Effect.try({
     try: () => new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes),
-    catch: () => new FsError({ code: "UnrepresentableName", operation })
+    catch: () => fsFailure("UnrepresentableName", operation)
 });
 /** @internal */
 export const nameBytes = (name) => Result.getOrThrow(Encoding.decodeHex(name));
-// A zero-length view distinguishes a detached buffer from a valid empty buffer.
+// Constructing a view detects detached buffers, including empty ones.
 const attachedBuffer = (bytes) => {
     try {
         const probe = new Uint8Array(bytes.buffer, bytes.byteOffset, 0);
@@ -44,17 +59,16 @@ const attachedBuffer = (bytes) => {
         throw error;
     }
 };
-// Accepts any Uint8Array, subclasses such as Node's Buffer included; rejects views over a
-// SharedArrayBuffer or a detached buffer before the bytes are copied or trusted.
+// Reject shared or detached buffers before copying; Buffer subclasses remain valid.
 /** @internal */
 export const isAttachedBytes = (bytes) => Predicate.isUint8Array(bytes) && bytes.buffer instanceof ArrayBuffer && attachedBuffer(bytes);
 /** @internal */
 export const pathFromBytes = Effect.fn("VirtualFileSystem.pathFromBytes")(function* (bytes) {
     if (!isAttachedBytes(bytes))
-        return yield* new FsError({ code: "InvalidArgument", operation: "pathFromBytes" });
+        return yield* fsFailure("InvalidArgument", "pathFromBytes");
     const owned = new Uint8Array(bytes);
     if (owned.length === 0 || owned.includes(0)) {
-        return yield* new FsError({ code: "InvalidArgument", operation: "pathFromBytes" });
+        return yield* fsFailure("InvalidArgument", "pathFromBytes");
     }
     return makeBytePath(owned);
 });
@@ -62,11 +76,12 @@ export const pathFromBytes = Effect.fn("VirtualFileSystem.pathFromBytes")(functi
 export const pathToBytes = Effect.fn("VirtualFileSystem.pathToBytes")(function* (path) {
     const bytes = getBytePathBytes(path);
     if (bytes === undefined)
-        return yield* new FsError({ code: "InvalidArgument", operation: "pathToBytes" });
+        return yield* fsFailure("InvalidArgument", "pathToBytes");
     return new Uint8Array(bytes);
 });
-// Hand-rolled because String.prototype.isWellFormed is ES2024 and the package targets ES2023.
-const wellFormed = (value) => {
+// String.prototype.isWellFormed requires ES2024; this package targets ES2023.
+/** @internal */
+export const isWellFormed = (value) => {
     for (let index = 0; index < value.length; index++) {
         const code = value.charCodeAt(index);
         if (code >= 0xd800 && code <= 0xdbff) {
@@ -80,26 +95,25 @@ const wellFormed = (value) => {
     return true;
 };
 const UTF8_ENCODER = new TextEncoder();
-// Strings must be well-formed UTF-16 before encoding; BytePaths must belong to this package.
 /** @internal */
 export const inputBytes = (input) => Predicate.isString(input)
-    ? wellFormed(input) ? Result.succeed(UTF8_ENCODER.encode(input)) : Result.fail("InvalidPathEncoding")
+    ? isWellFormed(input) ? Result.succeed(UTF8_ENCODER.encode(input)) : Result.fail("InvalidPathEncoding")
     : Result.fromNullishOr(getBytePathBytes(input), () => "InvalidArgument");
 /** @internal */
 export const preparePath = (input, operation, maxPathBytes) => {
     const encoded = inputBytes(input);
     if (Result.isFailure(encoded)) {
         return Result.fail(encoded.failure === "InvalidPathEncoding"
-            ? new FsError({ code: "InvalidPathEncoding", operation, path: input })
-            : new FsError({ code: "InvalidArgument", operation }));
+            ? fsFailure("InvalidPathEncoding", operation, { path: input })
+            : fsFailure("InvalidArgument", operation));
     }
     const bytes = encoded.success;
     if (bytes.length === 0)
-        return Result.fail(new FsError({ code: "NotFound", operation, path: input }));
+        return Result.fail(fsFailure("NotFound", operation, { path: input }));
     if (bytes.includes(0))
-        return Result.fail(new FsError({ code: "InvalidArgument", operation, path: input }));
+        return Result.fail(fsFailure("InvalidArgument", operation, { path: input }));
     if (maxPathBytes !== undefined && ByteSize.isGreaterThan(ByteSize.bytes(bytes.length), maxPathBytes)) {
-        return Result.fail(new FsError({ code: "PathTooLong", operation, path: input }));
+        return Result.fail(fsFailure("PathTooLong", operation, { path: input }));
     }
     const components = [];
     const suffixes = [];
@@ -109,7 +123,7 @@ export const preparePath = (input, operation, maxPathBytes) => {
             continue;
         if (index > start) {
             if (index - start > MAX_NAME_BYTES) {
-                return Result.fail(new FsError({ code: "PathTooLong", operation, path: input }));
+                return Result.fail(fsFailure("PathTooLong", operation, { path: input }));
             }
             components.push(Encoding.encodeHex(bytes.subarray(start, index)));
             suffixes.push(bytes.subarray(index));

package/dist/internal/snapshotDelta.d.ts

@@ -1,35 +1,36 @@
 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";
+import type { Snapshot } from "../Snapshot.js";
+import { type SnapshotDelta } from "../SnapshotDelta.js";
+import type { ImageFailure } from "../VfsError.js";
+import { VfsError } from "./errors.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>;
+    readonly encodedBytes: ByteSize.ByteSize;
+    readonly records: number;
+    readonly entries: number;
+    readonly decodedBytes: ByteSize.ByteSize;
+    readonly identityBytes: ByteSize.ByteSize;
+    readonly baseRecords: number;
+    readonly targetRecords: number;
+    readonly outputRecords: number;
+    readonly outputBytes: ByteSize.ByteSize;
+    readonly inheritedRecords: number;
+}) => Effect.Effect<SnapshotDelta, import("effect/PlatformError").PlatformError | ImageFailure, import("effect/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;
+    readonly encodedBytes: ByteSize.ByteSize;
+    readonly records: number;
+    readonly entries: number;
+    readonly decodedBytes: ByteSize.ByteSize;
+    readonly identityBytes: ByteSize.ByteSize;
+    readonly baseRecords: number;
+    readonly targetRecords: number;
+    readonly outputRecords: number;
+    readonly outputBytes: ByteSize.ByteSize;
+    readonly inheritedRecords: number;
 }) => Effect.Effect<readonly ({
     readonly _tag: "Added";
     readonly path: import("../BytePath.js").BytePath;
@@ -44,44 +45,44 @@ export declare const inspectSnapshotDelta: (base: Snapshot, delta: SnapshotDelta
     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>;
+})[], import("effect/PlatformError").PlatformError | VfsError, import("effect/Crypto").Crypto>;
+/** @internal */
+export declare const applySnapshotDelta: (base: Snapshot, delta: SnapshotDelta, limits: {
+    readonly encodedBytes: ByteSize.ByteSize;
+    readonly records: number;
+    readonly entries: number;
+    readonly decodedBytes: ByteSize.ByteSize;
+    readonly identityBytes: ByteSize.ByteSize;
+    readonly baseRecords: number;
+    readonly targetRecords: number;
+    readonly outputRecords: number;
+    readonly outputBytes: ByteSize.ByteSize;
+    readonly inheritedRecords: number;
+}) => Effect.Effect<Snapshot, import("effect/PlatformError").PlatformError | VfsError, import("effect/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>;
+    readonly encodedBytes: ByteSize.ByteSize;
+    readonly records: number;
+    readonly entries: number;
+    readonly decodedBytes: ByteSize.ByteSize;
+    readonly identityBytes: ByteSize.ByteSize;
+    readonly baseRecords: number;
+    readonly targetRecords: number;
+    readonly outputRecords: number;
+    readonly outputBytes: ByteSize.ByteSize;
+    readonly inheritedRecords: number;
+}) => Effect.Effect<Uint8Array<ArrayBuffer>, ImageFailure, 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>;
+    readonly encodedBytes: ByteSize.ByteSize;
+    readonly records: number;
+    readonly entries: number;
+    readonly decodedBytes: ByteSize.ByteSize;
+    readonly identityBytes: ByteSize.ByteSize;
+    readonly baseRecords: number;
+    readonly targetRecords: number;
+    readonly outputRecords: number;
+    readonly outputBytes: ByteSize.ByteSize;
+    readonly inheritedRecords: number;
+}) => Effect.Effect<SnapshotDelta, ImageFailure, never>;
 //# sourceMappingURL=snapshotDelta.d.ts.map

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

@@ -1 +1 @@
-{"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;AAOvC,OAAO,EAAE,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC1D,OAAO,EAGL,KAAK,aAAa,EAClB,kBAAkB,EAInB,MAAM,qBAAqB,CAAA;AAmuB5B,gBAAgB;AAChB,eAAO,MAAM,aAAa;;;;;;;;;;;4GAgDzB,CAAA;AAyBD,gBAAgB;AAChB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;oGAoBhC,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,mBAAmB;;;;;;;;;;;+DAe9B,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,mBAAmB;;;;;;;;;;;qDAkC9B,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,kBAAkB;;;;;;;;;;;4HAI9B,CAAA"}
+{"version":3,"file":"snapshotDelta.d.ts","sourceRoot":"","sources":["../../src/internal/snapshotDelta.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,EAGL,KAAK,aAAa,EAGnB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAKlD,OAAO,EAA4C,QAAQ,EAAE,MAAM,aAAa,CAAA;AA01BhF,gBAAgB;AAChB,eAAO,MAAM,aAAa;;;;;;;;;;;+HA2BxB,CAAA;AA2BF,gBAAgB;AAChB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;8FAchC,CAAA;AAED,gBAAgB;AAChB,eAAO,MAAM,kBAAkB;;;;;;;;;;;sHAI9B,CAAA;AAID,gBAAgB;AAChB,eAAO,MAAM,mBAAmB;;;;;;;;;;;iEAe9B,CAAA;AAEF,gBAAgB;AAChB,eAAO,MAAM,mBAAmB;;;;;;;;;;;uDAyB9B,CAAA"}