@effect-vfs/core 0.7.1 → 0.9.0

package/dist/internal/snapshotDelta.js

@@ -18,19 +18,24 @@ import { isAttachedBytes, isNameBytes, joinPath, nameBytes, NUL_BYTE, ROOT_PATH,
 import * as SnapshotDeltaModel from "./snapshotDeltaModel.js";
 import { UNCHECKED } from "./tree.js";
 import { byEntryName, getNode, Ino, MAX_INO, payloadOf, ROOT_INO, storedMetadata } from "./volumeState.js";
-const FORMAT = "effect-vfs-delta";
-const OPERATION = "snapshotDelta";
+/** @internal */
+export const FORMAT = "effect-vfs-delta";
+/** @internal */
+export const OPERATION = "snapshotDelta";
 const RULE_CHECK = "@effect-vfs/core/deltaRuleCheck";
 const Path = CanonicalBase64.Encoded;
 // Unchanged payloads come from the base; a new hard link points to the group's first changed path.
-const InlineContent = Schema.TaggedStruct("Inline", { bytes: CanonicalBase64.Encoded });
-const DeltaNode = Schema.TaggedUnion({
+/** @internal */
+export const InlineContent = Schema.TaggedStruct("Inline", { bytes: CanonicalBase64.Encoded });
+/** @internal */
+export const DeltaNode = Schema.TaggedUnion({
     directory: { metadata: StoredMetadata },
     file: { metadata: StoredMetadata, content: Schema.optionalKey(InlineContent) },
     symlink: { metadata: StoredMetadata, target: Schema.optionalKey(CanonicalBase64.Encoded) },
     link: { to: Path }
 });
-const Change = Schema.TaggedUnion({
+/** @internal */
+export const Change = Schema.TaggedUnion({
     Added: { path: Path, kind: SnapshotNodeKind, node: DeltaNode },
     Removed: { path: Path, kind: SnapshotNodeKind },
     Updated: {
@@ -41,7 +46,8 @@ const Change = Schema.TaggedUnion({
         node: DeltaNode
     }
 });
-const Document = Schema.Struct({
+/** @internal */
+export const Document = Schema.Struct({
     format: Schema.Literal(FORMAT),
     version: Schema.Literal(1),
     base: CanonicalBase64.Encoded,
@@ -52,9 +58,12 @@ const VersionProbe = Schema.Struct({
     format: Schema.Literal(FORMAT),
     version: Schema.Unknown
 });
-const differenceOrder = SnapshotDifference.literals;
-const timestampFields = new Set(["atimeNs", "mtimeNs", "ctimeNs", "birthtimeNs"]);
-const key = Hex.encode;
+/** @internal */
+export const differenceOrder = SnapshotDifference.literals;
+/** @internal */
+export const timestampFields = new Set(["atimeNs", "mtimeNs", "ctimeNs", "birthtimeNs"]);
+/** @internal */
+export const key = Hex.encode;
 const validPath = (path) => {
     if (path[0] !== SLASH_BYTE)
         return false;
@@ -68,7 +77,8 @@ const validPath = (path) => {
     }
     return true;
 };
-const splitNames = (path) => {
+/** @internal */
+export const splitNames = (path) => {
     const names = [];
     if (path.length === 1)
         return names;
@@ -81,12 +91,16 @@ const splitNames = (path) => {
     }
     return names;
 };
-const kindOf = (change) => Change.guards.Updated(change) ? change.afterKind : change.kind;
-const payloadDifference = (kind) => (kind === "file" ? "content" : "target");
-const carriesPayload = (change) => Change.guards.Added(change) ||
+/** @internal */
+export const kindOf = (change) => Change.guards.Updated(change) ? change.afterKind : change.kind;
+/** @internal */
+export const payloadDifference = (kind) => (kind === "file" ? "content" : "target");
+/** @internal */
+export const carriesPayload = (change) => Change.guards.Added(change) ||
     (Change.guards.Updated(change) &&
         (change.differences.includes("kind") || change.differences.includes(payloadDifference(change.afterKind))));
-const carriedPayload = (node) => DeltaNode.guards.file(node) ? node.content?.bytes : DeltaNode.guards.symlink(node) ? node.target : undefined;
+/** @internal */
+export const carriedPayload = (node) => DeltaNode.guards.file(node) ? node.content?.bytes : DeltaNode.guards.symlink(node) ? node.target : undefined;
 const changesIssue = (changes) => {
     const at = (path, issue) => ({ path: ["changes", ...path], issue });
     const heads = new Map();
@@ -168,7 +182,8 @@ const decodeFailure = (error) => {
         });
 };
 const exceeds = (value, limit) => ByteSize.isGreaterThan(ByteSize.bytes(value), limit);
-const validate = (document, limits) => {
+/** @internal */
+export const validate = (document, limits) => {
     const fail = (code, field) => Result.fail(imageFailure(OPERATION, code, { field }));
     if (document.changes.length > limits.records)
         return fail("LimitExceeded", "deltaRecords");
@@ -203,14 +218,16 @@ const validate = (document, limits) => {
         return fail("LimitExceeded", "outputBytes");
     return Result.void;
 };
-const baseBudget = (limits) => ({
+/** @internal */
+export const baseBudget = (limits) => ({
     operation: OPERATION,
     records: limits.baseRecords,
     recordsField: "baseRecords",
     entries: limits.entries,
     identityBytes: limits.identityBytes
 });
-const targetBudget = (limits) => ({
+/** @internal */
+export const targetBudget = (limits) => ({
     operation: OPERATION,
     records: limits.targetRecords,
     recordsField: "targetRecords",
@@ -219,7 +236,8 @@ const targetBudget = (limits) => ({
     payloadBytes: { limit: limits.outputBytes, field: "outputBytes" }
 });
 // Check target bounds first so applying and diffing report the same limit.
-const outputIssue = (limits, output) => {
+/** @internal */
+export const outputIssue = (limits, output) => {
     const fail = (field) => Result.fail(imageFailure(OPERATION, "LimitExceeded", { field }));
     if (output.records > limits.targetRecords)
         return fail("targetRecords");
@@ -234,7 +252,8 @@ const outputIssue = (limits, output) => {
     return Result.void;
 };
 const groupKey = (paths) => paths.map(key).join("/");
-const side = (value, identity) => {
+/** @internal */
+export const side = (value, identity) => {
     const groupOf = new Map();
     const firstOf = new Map();
     for (const [ino, paths] of identity.groups) {
@@ -246,7 +265,8 @@ const side = (value, identity) => {
     return { value, identity, groupOf, firstOf };
 };
 const groupAt = (side, pathKey) => side.groupOf.get(pathKey) ?? pathKey;
-const differencesOf = (before, after, hardLinks) => differenceOrder.filter((field) => {
+/** @internal */
+export const differencesOf = (before, after, hardLinks) => differenceOrder.filter((field) => {
     if (field === "kind")
         return before.kind !== after.kind;
     if (field === "content" || field === "target") {
@@ -267,7 +287,8 @@ const deltaNode = (target, path, node, withPayload) => {
         ? { metadata, content: InlineContent.make({ bytes: CanonicalBase64.encode(file.data) }, UNCHECKED) }
         : { metadata }, UNCHECKED)), Match.discriminator("kind")("symlink", (symlink) => DeltaNode.cases.symlink.make(withPayload ? { metadata, target: CanonicalBase64.encode(symlink.target) } : { metadata }, UNCHECKED)), Match.exhaustive);
 };
-const lookup = (get, entriesOf, path) => {
+/** @internal */
+export const lookup = (get, entriesOf, path) => {
     let parent = ROOT_INO;
     let node = get(ROOT_INO);
     let name = "";
@@ -283,7 +304,8 @@ const lookup = (get, entriesOf, path) => {
     }
     return node === undefined ? undefined : { parent, name, node };
 };
-const valueEntries = (directory) => directory.entries;
+/** @internal */
+export const valueEntries = (directory) => directory.entries;
 // Equal digests skip a subtree; hard-link groups still need a separate path comparison.
 const compare = (base, target) => {
     const changes = [];
@@ -361,7 +383,8 @@ const compare = (base, target) => {
     }
     return changes.sort(Order.mapInput(bytesOrder, (entry) => entry.path)).map(({ change }) => change);
 };
-const getDocument = (delta) => Effect.suspend(() => {
+/** @internal */
+export const getDocument = (delta) => Effect.suspend(() => {
     const value = SnapshotDeltaModel.value(delta);
     return value !== undefined && Schema.is(Document)(value)
         ? Effect.succeed(value)
@@ -369,7 +392,8 @@ const getDocument = (delta) => Effect.suspend(() => {
 });
 // Detach deepest paths first, then attach from the root. Check each claimed change against the base: a matching
 // target digest alone cannot detect unreachable children or forged hard-link groups.
-const fold = (base, identity, document) => {
+/** @internal */
+export const fold = (base, identity, document) => {
     const fail = (index, field) => Result.fail(imageFailure(OPERATION, "InvalidStructure", {
         field: field === undefined ? `changes.${index}` : `changes.${index}.${field}`
     }));
@@ -587,7 +611,8 @@ const fold = (base, identity, document) => {
     return Result.succeed({ value, dirty, removed, groups, records, entries, payloadBytes, written });
 };
 // Reuse base digests for untouched nodes, but charge the meter for the whole target.
-const foldedIdentity = Effect.fnUntraced(function* (base, folded, identity, limits) {
+/** @internal */
+export const foldedIdentity = Effect.fnUntraced(function* (base, folded, identity, limits) {
     const digests = new Map();
     const measure = Merkle.meter(targetBudget(limits));
     let inherited = identity.nodeBytes;
@@ -626,6 +651,15 @@ const verify = Effect.fnUntraced(function* (base, document, limits) {
     yield* Effect.fromResult(validate(document, limits));
     const value = yield* Image.valueOf(base);
     const identity = yield* Merkle.identify(value, baseBudget(limits));
+    return yield* verifyValidated(value, identity, document, limits);
+});
+// Verify a document against a base whose identity is already known; returns the folded target value.
+/** @internal */
+export const verifyWith = Effect.fnUntraced(function* (value, identity, document, limits) {
+    yield* Effect.fromResult(validate(document, limits));
+    return yield* verifyValidated(value, identity, document, limits);
+});
+const verifyValidated = Effect.fnUntraced(function* (value, identity, document, limits) {
     if (!sameBytes(identity.digest, CanonicalBase64.toBytes(document.base))) {
         return yield* new VfsError({ code: "BaseMismatch", operation: OPERATION });
     }

package/dist/internal/snapshotMerge.d.ts

@@ -0,0 +1,54 @@
+import * as Effect from "effect/Effect";
+import type { Snapshot } from "../Snapshot.js";
+import { type SnapshotDelta } from "../SnapshotDelta.js";
+/** @internal */
+export declare const mergeSnapshotDeltas: (base: Snapshot, ours: SnapshotDelta, theirs: SnapshotDelta, resolutions: readonly {
+    readonly path: import("../BytePath.js").BytePath;
+    readonly take: "base" | "ours" | "theirs";
+}[], limits: {
+    readonly encodedBytes: import("effect/ByteSize").ByteSize;
+    readonly records: number;
+    readonly entries: number;
+    readonly decodedBytes: import("effect/ByteSize").ByteSize;
+    readonly identityBytes: import("effect/ByteSize").ByteSize;
+    readonly baseRecords: number;
+    readonly targetRecords: number;
+    readonly outputRecords: number;
+    readonly outputBytes: import("effect/ByteSize").ByteSize;
+    readonly inheritedRecords: number;
+}) => Effect.Effect<{
+    delta: SnapshotDelta;
+    conflicts: {
+        readonly path: import("../BytePath.js").BytePath;
+        readonly reason: "BothAddedDifferent" | "BothChanged" | "ChangedRemoved" | "HardLinkGroupDiverged" | "KindDiverged" | "ParentRemoved";
+        readonly ours: {
+            readonly _tag: "Added";
+            readonly kind: "directory" | "file" | "symlink";
+        } | {
+            readonly _tag: "Removed";
+            readonly kind: "directory" | "file" | "symlink";
+        } | {
+            readonly _tag: "Unchanged";
+        } | {
+            readonly _tag: "Updated";
+            readonly beforeKind: "directory" | "file" | "symlink";
+            readonly afterKind: "directory" | "file" | "symlink";
+            readonly differences: readonly ("atimeNs" | "birthtimeNs" | "content" | "ctimeNs" | "gid" | "hardLinks" | "kind" | "mode" | "mtimeNs" | "target" | "uid")[];
+        };
+        readonly theirs: {
+            readonly _tag: "Added";
+            readonly kind: "directory" | "file" | "symlink";
+        } | {
+            readonly _tag: "Removed";
+            readonly kind: "directory" | "file" | "symlink";
+        } | {
+            readonly _tag: "Unchanged";
+        } | {
+            readonly _tag: "Updated";
+            readonly beforeKind: "directory" | "file" | "symlink";
+            readonly afterKind: "directory" | "file" | "symlink";
+            readonly differences: readonly ("atimeNs" | "birthtimeNs" | "content" | "ctimeNs" | "gid" | "hardLinks" | "kind" | "mode" | "mtimeNs" | "target" | "uid")[];
+        };
+    }[];
+}, import("effect/PlatformError").PlatformError | import("./errors.js").VfsError, import("effect/Crypto").Crypto>;
+//# sourceMappingURL=snapshotMerge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"snapshotMerge.d.ts","sourceRoot":"","sources":["../../src/internal/snapshotMerge.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,EAML,KAAK,aAAa,EAGnB,MAAM,qBAAqB,CAAA;AA8tC5B,gBAAgB;AAChB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iHAkD9B,CAAA"}