@nicia-ai/typegraph 0.55.0 → 0.56.0

package/dist/graph-merge/index.js

@@ -1,20 +1,20 @@
-import { createStoreWithSchema } from '../chunk-VU65FXEG.js';
-import '../chunk-HW3IX2RF.js';
-import { InterchangeIdentitySchema, importGraphStream, exportGraphStream, importGraph, exportGraph, registerIngestionImportTarget } from '../chunk-NXRSR6QG.js';
-import '../chunk-FCUSVSYX.js';
-import { storeBackend, storeRuntime, transactionBackend } from '../chunk-74FNI3PT.js';
-import '../chunk-45WPPI64.js';
-import '../chunk-7EOJO6QB.js';
-import '../chunk-SLNH62T3.js';
-import { computeSchemaHash, serializeSchema } from '../chunk-FFR3YUY2.js';
+import { NODE_TEMPORAL_READ_NAMES, CURRENT_ONLY_READ_NAMES, createStoreWithSchema, IDENTITY_READ_NAMES, EDGE_TEMPORAL_READ_NAMES } from '../chunk-LFXBFPI2.js';
+import '../chunk-EWRLWI7W.js';
+import { InterchangeIdentitySchema, importGraphStream, exportGraphStream, importGraph, exportGraph, registerIngestionImportTarget } from '../chunk-MHM6OGZR.js';
+import '../chunk-MRGWM5LE.js';
+import { storeBackend, storeRuntime, transactionBackend } from '../chunk-C3TJU4KQ.js';
+import '../chunk-FMCPKMQI.js';
+import '../chunk-7MHENVRG.js';
+import '../chunk-KQYUKOGX.js';
+import { computeSchemaHash, serializeSchema } from '../chunk-E4QYEWVH.js';
 import '../chunk-RFMSZ7CF.js';
 import { defineNode } from '../chunk-P5J256Q7.js';
-import { normalizeIdentityPair, identityReferenceKey, identityValidityWindowsOverlap, identityAssertionSemanticKey } from '../chunk-MJXEO7YA.js';
-import { generateId, readRevisionOrigin, readRecordedClock, forceRecordedGraphRevision, forceWriteTransactionRevision, advanceRevisionClock, lockSchemaVersionForStoreWrite, lockRecordedGraphWrite } from '../chunk-SIQ4BFL5.js';
+import { normalizeIdentityPair, identityReferenceKey, identityValidityWindowsOverlap, identityAssertionSemanticKey } from '../chunk-762VPGHN.js';
+import { generateId, readRevisionOrigin, readRecordedClock, forceRecordedGraphRevision, forceWriteTransactionRevision, advanceRevisionClock, lockSchemaVersionForStoreWrite, lockRecordedGraphWrite } from '../chunk-AZP5CCHL.js';
 import '../chunk-JYY2EB5K.js';
 import { sortedReplacer } from '../chunk-U4SGJQKQ.js';
-import '../chunk-IDQZI6GL.js';
-import { snapshotExportContention, resolveWriteFencePlan, requireWriteFence, createSqlSchema } from '../chunk-YVKPUSHS.js';
+import '../chunk-XH75W3O5.js';
+import { snapshotExportContention, resolveWriteFencePlan, requireWriteFence, createSqlSchema, graphCommandCoordinationIsolation } from '../chunk-75KH6Y2W.js';
 import { getNodeKinds, getEdgeKinds, defineInternalGraph } from '../chunk-4PNRH5BO.js';
 import { encodeTupleKey, validateEdgeEndpoints, computeUniqueKey } from '../chunk-HFZWYHYC.js';
 import '../chunk-EMORF4PV.js';
@@ -128,7 +128,8 @@ var MERGE_ERROR_CODES = {
   planningStale: "GRAPH_MERGE_PLANNING_STALE",
   candidateSource: "GRAPH_MERGE_CANDIDATE_SOURCE",
   evidence: "GRAPH_MERGE_EVIDENCE",
-  candidateWriteSet: "GRAPH_MERGE_CANDIDATE_WRITE_SET"
+  candidateWriteSet: "GRAPH_MERGE_CANDIDATE_WRITE_SET",
+  review: "GRAPH_MERGE_REVIEW"
 };
 function toTypeGraphErrorOptions(category, options) {
   return {
@@ -158,6 +159,14 @@ var InvalidMergeOptionsError = class extends MergeError {
     this.name = "InvalidMergeOptionsError";
   }
 };
+var MergeReviewError = class extends MergeError {
+  static errorCategory = "user";
+  code = MERGE_ERROR_CODES.review;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "MergeReviewError";
+  }
+};
 var BranchError = class extends TypeGraphError {
   constructor(message, options = {}) {
     super(
@@ -2097,6 +2106,45 @@ function unwrapMergeBranches(inputs) {
   return inputs.map((input) => unwrapMergeBranch(input));
 }
 
+// src/graph-merge/apply-callbacks.ts
+var NODE_READ_NAMES = [
+  ...NODE_TEMPORAL_READ_NAMES,
+  ...CURRENT_ONLY_READ_NAMES
+];
+function pickReadMethods(source, names) {
+  return Object.fromEntries(names.map((name) => [name, source[name]]));
+}
+function mergePlanReadContext(tx, graph) {
+  return {
+    nodes: Object.fromEntries(
+      Object.keys(graph.nodes).map((kind) => [
+        kind,
+        pickReadMethods(requireDefined(tx.nodes[kind]), NODE_READ_NAMES)
+      ])
+    ),
+    edges: Object.fromEntries(
+      Object.keys(graph.edges).map((kind) => [
+        kind,
+        pickReadMethods(
+          requireDefined(tx.edges[kind]),
+          EDGE_TEMPORAL_READ_NAMES
+        )
+      ])
+    ),
+    ..."identity" in tx ? {
+      identity: pickReadMethods(tx.identity, IDENTITY_READ_NAMES)
+    } : {}
+  };
+}
+function assertMergeCallbackResult(result, callback) {
+  if (result !== void 0) {
+    throw new InvalidMergeOptionsError(
+      `${callback} must resolve without a return value; throw or reject to abort merge application.`,
+      { cause: result, details: { callback } }
+    );
+  }
+}
+
 // src/graph-merge/blocking.ts
 var UNBLOCKED_BUCKET_KEY = "unblocked";
 var KEY_PART_SEPARATOR = "\0";
@@ -5895,7 +5943,20 @@ async function lockMergeTargetWrite(txBackend, input) {
     throw input.staleSchemaError(error);
   }
   if (input.graphLock === "required") {
-    await lockRecordedGraphWrite(txBackend, input.graphId);
+    const lock = await lockRecordedGraphWrite(txBackend, input.graphId);
+    if (input.requireFreshSnapshot && lock.coordination !== void 0) {
+      const isolation = graphCommandCoordinationIsolation(
+        txBackend.commands,
+        input.graphId,
+        lock.coordination
+      );
+      if (isolation !== "read_committed") {
+        throw new MergePlanCapabilityError(
+          "Merge callbacks require read-committed isolation so their reads observe the target after acquiring its graph lock.",
+          { details: { capability: "mergeCallbackIsolation", isolation } }
+        );
+      }
+    }
   }
 }
 
@@ -8023,11 +8084,12 @@ async function preflightWireMergeWrites(target, nodesApi, edgesApi, artifact) {
     }
   }
 }
-async function assertMergePlanFenceInsideTransaction(target, txBackend, artifact) {
+async function assertMergePlanFenceInsideTransaction(target, txBackend, artifact, requireFreshSnapshot) {
   await lockMergeTargetWrite(txBackend, {
     graphId: target.graphId,
     schemaVersion: artifact.target.schema.managed ? artifact.target.schema.version : void 0,
     graphLock: "required",
+    requireFreshSnapshot,
     staleSchemaError: (cause) => new MergePlanSchemaMismatchError(
       "The target's active schema no longer matches the merge plan.",
       { cause, details: { expected: artifact.target.schema } }
@@ -8181,7 +8243,7 @@ function reportFromArtifact(artifact, merged, warnings, provenancePersisted) {
     ...provenancePersisted === void 0 ? {} : { provenancePersisted }
   };
 }
-async function applyMergePlan(target, input) {
+async function applyMergePlan(target, input, options = {}) {
   let validation;
   try {
     validation = await validateMergePlanArtifact(input);
@@ -8210,6 +8272,9 @@ async function applyMergePlan(target, input) {
     );
   }
   try {
+    const { beforeApply, afterApply } = options;
+    const composed = beforeApply !== void 0 || afterApply !== void 0;
+    const transactionOptions = composed ? { isolationLevel: "read_committed" } : mergeCommitTransactionOptions(target);
     assertPublicPlanCapability(target);
     const provenanceStore = artifact.provenance.persist ? await tryOpenProvenanceStore(target) : void 0;
     if (provenanceStore !== void 0 && isErr(provenanceStore)) {
@@ -8221,8 +8286,15 @@ async function applyMergePlan(target, input) {
         await assertMergePlanFenceInsideTransaction(
           target,
           txBackend,
-          artifact
+          artifact,
+          composed
         );
+        if (beforeApply !== void 0) {
+          assertMergeCallbackResult(
+            await beforeApply(mergePlanReadContext(tx, target.graph)),
+            "beforeApply"
+          );
+        }
         await preflightWireMergeWrites(
           target,
           tx.nodes,
@@ -8233,14 +8305,21 @@ async function applyMergePlan(target, input) {
           identityAssertions: artifact.writes.identityAssertions,
           identityRetractions: artifact.writes.identityRetractions
         });
-        return applyWireMergeWrites(
+        const applied = await applyWireMergeWrites(
           target,
           tx.nodes,
           tx.edges,
           txBackend,
           artifact
         );
-      }, mergeCommitTransactionOptions(target))
+        if (afterApply !== void 0) {
+          assertMergeCallbackResult(
+            await afterApply(tx, { merged: structuredClone(applied) }),
+            "afterApply"
+          );
+        }
+        return applied;
+      }, transactionOptions)
     );
     const warnings = [...artifact.review.warnings];
     let provenancePersisted;
@@ -8965,6 +9044,401 @@ async function planCandidateWriteSet(args) {
   }
 }
 
-export { BaseVersionMismatchError, BranchError, CANDIDATE_WRITE_SET_FORMAT_VERSION, CandidateSourceError, CandidateWriteSetError, CandidateWriteSetSchema, CandidateWriteSetTargetSchema, IdentityMergeConflictError, InvalidMergeOptionsError, InvalidMergePlanError, MERGE_ERROR_CODES, MERGE_OPTION_DEFAULTS, MERGE_PLAN_DIGEST_ALGORITHM, MERGE_PLAN_FORMAT_VERSION, MatchEvidenceError, MergeConflictError, MergeConstraintConflictError, MergeError, MergePlanCapabilityError, MergePlanDigestMismatchError, MergePlanOriginMismatchError, MergePlanSchemaMismatchError, MergePlanTargetMismatchError, MergePlanningStaleError, SimilarityUnavailableError, StaleMergePlanError, UnsupportedMergePlanVersionError, VALIDITY_END_TARGET_PRECEDENCE, applyMergePlan, asBaseVersion, asBranchId, branch, captureCandidateWriteSetTarget, cloneWorkingCopyStrategy, computeBaseVersion, ingestionBranch, merge, mergeIncremental, normalizeMergeOptions, openProvenanceStore, persistProvenanceRecords, planCandidateWriteSet, planMerge, planMergeIncremental, provenanceGraphId, readProvenance };
+// src/graph-merge/review-evidence.ts
+function reviewJson(value) {
+  if (value === void 0) return "undefined";
+  return JSON.stringify(value, sortedReplacer);
+}
+async function reviewDigest(value) {
+  return sha256Hex(reviewJson(value), 32);
+}
+function reviewOptionEvidence(options) {
+  return encodeOption(normalizeMergeOptions(options), /* @__PURE__ */ new Set());
+}
+function encodeOption(value, ancestors) {
+  if (value === void 0) return ["undefined"];
+  if (typeof value === "function") return ["callback"];
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return ["literal", value];
+  }
+  if (typeof value === "number" && Number.isFinite(value))
+    return ["number", value];
+  if (typeof value !== "object" || ancestors.has(value)) {
+    throw new MergeReviewError(
+      "Merge options contain unsupported or cyclic review evidence."
+    );
+  }
+  const nextAncestors = /* @__PURE__ */ new Set([...ancestors, value]);
+  if (Array.isArray(value)) {
+    return [
+      "array",
+      value.map((item) => encodeOption(item, nextAncestors))
+    ];
+  }
+  if (value instanceof Map) {
+    const entries = [...value].map(
+      ([key, entry]) => [
+        encodeOption(key, nextAncestors),
+        encodeOption(entry, nextAncestors)
+      ]
+    );
+    entries.sort(
+      (left, right) => compareStrings(reviewJson(left), reviewJson(right))
+    );
+    return ["map", entries];
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+    throw new MergeReviewError(
+      "Merge options contain a non-JSON object without a review representation."
+    );
+  }
+  return [
+    "object",
+    Object.entries(value).sort(([left], [right]) => compareStrings(left, right)).map(([key, entry]) => [key, encodeOption(entry, nextAncestors)])
+  ];
+}
+
+// src/graph-merge/review-baseline.ts
+function reviewRowKey(row) {
+  return JSON.stringify([row.role, row.kind, row.id]);
+}
+async function captureReviewBaseline(target) {
+  const backend = storeBackend(target);
+  const rows = [];
+  for (const kind of getNodeKinds(target.graph)) {
+    for (const row of await enumerateAllNodes(backend, target.graphId, kind)) {
+      rows.push({
+        role: "node",
+        kind,
+        id: row.id,
+        digest: await reviewDigest({ ...row, props: parseRowProps(row.props) })
+      });
+    }
+  }
+  for (const kind of getEdgeKinds(target.graph)) {
+    for (const row of await enumerateAllEdges(backend, target.graphId, kind)) {
+      rows.push({
+        role: "edge",
+        kind,
+        id: row.id,
+        digest: await reviewDigest({ ...row, props: parseRowProps(row.props) })
+      });
+    }
+  }
+  const identity = await storeRuntime(target).readCurrentIdentityAssertions(
+    "archival",
+    {
+      includeDeleted: true
+    }
+  );
+  return {
+    rows: rows.sort(
+      (left, right) => compareStrings(reviewRowKey(left), reviewRowKey(right))
+    ),
+    identityDigest: await reviewDigest(
+      [...identity].sort((left, right) => compareStrings(left.id, right.id))
+    )
+  };
+}
+function withReviewAbsences(baseline, writeSet, plan, graph) {
+  const rows = new Map(baseline.rows.map((row) => [reviewRowKey(row), row]));
+  function addNode(entity) {
+    for (const kind of getNodeKinds(graph)) {
+      const row = { role: "node", kind, id: entity.id };
+      if (!rows.has(reviewRowKey(row))) rows.set(reviewRowKey(row), row);
+    }
+  }
+  for (const row of baseline.rows) if (row.role === "node") addNode(row);
+  function addEdge(entity) {
+    for (const kind of getEdgeKinds(graph)) {
+      const row = { role: "edge", kind, id: entity.id };
+      if (!rows.has(reviewRowKey(row))) rows.set(reviewRowKey(row), row);
+    }
+  }
+  for (const node of [
+    ...writeSet.nodes,
+    ...plan.writes.nodeUpserts,
+    ...plan.writes.nodeDeletes,
+    ...plan.guards.deletedNodes
+  ])
+    addNode(node);
+  for (const edge of [...writeSet.edges, ...plan.writes.edgeUpserts]) {
+    addEdge(edge);
+    addNode(edge.from);
+    addNode(edge.to);
+  }
+  for (const edge of plan.writes.edgeDeletes) addEdge(edge);
+  for (const assertion of [
+    ...writeSet.identity?.assertions ?? [],
+    ...plan.writes.identityAssertions,
+    ...plan.writes.identityRetractions
+  ]) {
+    addNode(assertion.a);
+    addNode(assertion.b);
+    if (assertion.endedBy !== void 0) addNode(assertion.endedBy);
+  }
+  for (const mapping of plan.guards.canonicalMappings) {
+    addNode(mapping.member);
+    addNode(mapping.canonical);
+  }
+  for (const retype of plan.guards.retypes) {
+    addNode(retype.entity);
+    addNode({ kind: retype.toKind, id: retype.entity.id });
+  }
+  return {
+    ...baseline,
+    rows: [...rows.values()].sort(
+      (left, right) => compareStrings(reviewRowKey(left), reviewRowKey(right))
+    )
+  };
+}
+function compareReviewBaseline(reviewed, current) {
+  const currentRows = new Map(
+    current.rows.map((row) => [reviewRowKey(row), row])
+  );
+  const differences = [];
+  for (const row of reviewed.rows) {
+    if (row.digest !== currentRows.get(reviewRowKey(row))?.digest) {
+      differences.push({
+        category: "baseline",
+        path: "baseline.rows",
+        entity: { role: row.role, kind: row.kind, id: row.id }
+      });
+    }
+  }
+  if (reviewed.identityDigest !== current.identityDigest) {
+    differences.push({ category: "baseline", path: "baseline.identityDigest" });
+  }
+  return differences;
+}
+var MERGE_REVIEW_FORMAT_VERSION = 1;
+var digestSchema = z.string().regex(/^[\da-f]{64}$/u);
+var mergeReviewPolicySchema = z.object({
+  id: z.string().min(1),
+  context: z.json()
+}).strict();
+var mergeReviewArtifactSchema = z.object({
+  formatVersion: z.literal(MERGE_REVIEW_FORMAT_VERSION),
+  kind: z.literal("candidate-write-set"),
+  digest: z.object({ algorithm: z.literal("sha256"), value: digestSchema }).strict(),
+  writeSet: CandidateWriteSetSchema,
+  policy: mergeReviewPolicySchema,
+  options: z.json(),
+  plan: mergePlanArtifactV1Schema,
+  baseline: z.object({
+    rows: z.array(
+      z.object({
+        role: z.enum(["node", "edge"]),
+        kind: z.string().min(1),
+        id: z.string().min(1),
+        digest: digestSchema.optional()
+      }).strict()
+    ),
+    identityDigest: digestSchema
+  }).strict()
+}).strict();
+
+// src/graph-merge/candidate-review.ts
+async function planCandidateWriteSetReview(args) {
+  try {
+    const writeSet = CandidateWriteSetSchema.parse(args.writeSet);
+    const policy = mergeReviewPolicySchema.parse(args.policy);
+    const options = reviewOptionEvidence(args.options);
+    const startingFence = await captureMergePlanTargetFence(args.target);
+    const baseline = await captureReviewBaseline(args.target);
+    const planned = await planCandidateWriteSet({ ...args, writeSet });
+    if (isErr(planned)) return planned;
+    assertReviewPlanFence(startingFence, planned.data);
+    await assertPlanningFenceUnchanged(args.target, startingFence);
+    assertOptionsUnchanged(options, reviewOptionEvidence(args.options));
+    const input = {
+      formatVersion: MERGE_REVIEW_FORMAT_VERSION,
+      kind: "candidate-write-set",
+      writeSet,
+      policy,
+      options,
+      plan: planned.data,
+      baseline: withReviewAbsences(
+        baseline,
+        writeSet,
+        planned.data,
+        args.target.graph
+      )
+    };
+    const review = {
+      ...input,
+      digest: { algorithm: "sha256", value: await reviewDigest(input) }
+    };
+    mergeReviewArtifactSchema.parse(review);
+    return ok(review);
+  } catch (error) {
+    return err(asReviewError(error));
+  }
+}
+async function revalidateCandidateWriteSetReview(args) {
+  try {
+    const review = await validateReview(args.review);
+    const policy = mergeReviewPolicySchema.parse(args.policy);
+    const options = reviewOptionEvidence(args.options);
+    const startingFence = await captureMergePlanTargetFence(args.target);
+    const targetDifferences = compareReviewTarget(
+      review.plan.target,
+      startingFence
+    );
+    if (targetDifferences.length > 0)
+      return ok({
+        status: "incompatible",
+        reviewDigest: review.digest,
+        differences: targetDifferences
+      });
+    if (withReviewAbsences(
+      review.baseline,
+      review.writeSet,
+      review.plan,
+      args.target.graph
+    ).rows.length !== review.baseline.rows.length) {
+      throw new MergeReviewError(
+        "The merge review is missing required baseline evidence.",
+        { details: { reason: "incomplete-baseline" } }
+      );
+    }
+    const policyDifferences = compareFields(
+      "policy",
+      { policy: review.policy, options: review.options },
+      { policy, options }
+    );
+    if (policyDifferences.length > 0)
+      return ok({
+        status: "changed",
+        reviewDigest: review.digest,
+        differences: policyDifferences
+      });
+    const baseline = await captureReviewBaseline(args.target);
+    const baselineDifferences = compareReviewBaseline(
+      review.baseline,
+      baseline
+    );
+    if (baselineDifferences.length > 0) {
+      await assertPlanningFenceUnchanged(args.target, startingFence);
+      return ok({
+        status: "changed",
+        reviewDigest: review.digest,
+        differences: baselineDifferences
+      });
+    }
+    const planned = await planCandidateWriteSet({
+      ...args,
+      writeSet: review.writeSet
+    });
+    if (isErr(planned)) return planned;
+    assertReviewPlanFence(startingFence, planned.data);
+    await assertPlanningFenceUnchanged(args.target, startingFence);
+    assertOptionsUnchanged(options, reviewOptionEvidence(args.options));
+    const differences = compareFields(
+      "plan",
+      reviewPlanContent(review.plan),
+      reviewPlanContent(planned.data)
+    );
+    return ok(
+      differences.length === 0 ? {
+        status: "compatible",
+        reviewDigest: review.digest,
+        plan: planned.data
+      } : {
+        status: "changed",
+        reviewDigest: review.digest,
+        differences,
+        plan: planned.data
+      }
+    );
+  } catch (error) {
+    return err(asReviewError(error));
+  }
+}
+async function validateReview(input) {
+  const review = mergeReviewArtifactSchema.parse(input);
+  if (reviewJson(input) !== reviewJson(review)) {
+    throw new MergeReviewError(
+      "Stored merge review evidence must not require normalization.",
+      {
+        details: { reason: "noncanonical-shape" }
+      }
+    );
+  }
+  const { digest, ...content } = review;
+  if (digest.value !== await reviewDigest(content)) {
+    throw new MergeReviewError(
+      "The merge review digest does not match its content.",
+      { details: { reason: "digest-mismatch" } }
+    );
+  }
+  const plan = await validateMergePlanArtifact(review.plan);
+  if (!plan.success)
+    throw new MergeReviewError("The reviewed execution plan is invalid.", {
+      details: { reason: "invalid-plan", error: plan.error }
+    });
+  const anchors = plan.artifact.anchors;
+  if (plan.artifact.mode !== "incremental" || anchors.kind !== "incremental" || anchors.forkPoint.graphId !== review.writeSet.target.graphId || plan.artifact.target.graphId !== review.writeSet.target.graphId || plan.artifact.target.schema.version !== review.writeSet.target.schemaVersion || plan.artifact.target.schema.hash !== review.writeSet.target.schemaHash || reviewJson(anchors.forkPoint.schema) !== reviewJson(plan.artifact.target.schema) || anchors.branches.length !== 1 || anchors.branches[0]?.branchId !== review.writeSet.sourceId || anchors.branches[0].baseVersion !== anchors.forkPoint.baseVersion) {
+    throw new MergeReviewError(
+      "The reviewed plan does not describe the retained candidate source and target.",
+      { details: { reason: "incompatible-plan" } }
+    );
+  }
+  if (new Set(review.baseline.rows.map((row) => reviewRowKey(row))).size !== review.baseline.rows.length) {
+    throw new MergeReviewError(
+      "The merge review contains duplicate baseline references.",
+      { details: { reason: "duplicate-baseline" } }
+    );
+  }
+  return { ...review, plan: plan.artifact };
+}
+function assertReviewPlanFence(fence, plan) {
+  if (!sameMergePlanTargetFence(fence, plan.target)) {
+    throw new MergePlanningStaleError(
+      "The target changed between review evidence capture and planning."
+    );
+  }
+}
+function assertOptionsUnchanged(before, after) {
+  if (reviewJson(before) !== reviewJson(after))
+    throw new MergeReviewError(
+      "Merge options changed while review evidence was being captured."
+    );
+}
+function compareReviewTarget(reviewed, current) {
+  return compareFields(
+    "target",
+    {
+      graphId: reviewed.graphId,
+      schema: reviewed.schema,
+      origin: reviewed.revision.origin
+    },
+    {
+      graphId: current.graphId,
+      schema: current.schema,
+      origin: current.revision.origin
+    }
+  );
+}
+function reviewPlanContent(plan) {
+  const {
+    digest: _digest,
+    target: _target,
+    anchors: _anchors,
+    ...content
+  } = plan;
+  return content;
+}
+function compareFields(category, reviewed, current) {
+  return [.../* @__PURE__ */ new Set([...Object.keys(reviewed), ...Object.keys(current)])].sort().filter((key) => reviewJson(reviewed[key]) !== reviewJson(current[key])).map((key) => ({ category, path: `${category}.${key}` }));
+}
+function asReviewError(error) {
+  return error instanceof MergeError ? error : new MergeReviewError(
+    "Unable to validate or capture merge review evidence.",
+    { cause: error }
+  );
+}
+
+export { BaseVersionMismatchError, BranchError, CANDIDATE_WRITE_SET_FORMAT_VERSION, CandidateSourceError, CandidateWriteSetError, CandidateWriteSetSchema, CandidateWriteSetTargetSchema, IdentityMergeConflictError, InvalidMergeOptionsError, InvalidMergePlanError, MERGE_ERROR_CODES, MERGE_OPTION_DEFAULTS, MERGE_PLAN_DIGEST_ALGORITHM, MERGE_PLAN_FORMAT_VERSION, MERGE_REVIEW_FORMAT_VERSION, MatchEvidenceError, MergeConflictError, MergeConstraintConflictError, MergeError, MergePlanCapabilityError, MergePlanDigestMismatchError, MergePlanOriginMismatchError, MergePlanSchemaMismatchError, MergePlanTargetMismatchError, MergePlanningStaleError, MergeReviewError, SimilarityUnavailableError, StaleMergePlanError, UnsupportedMergePlanVersionError, VALIDITY_END_TARGET_PRECEDENCE, applyMergePlan, asBaseVersion, asBranchId, branch, captureCandidateWriteSetTarget, cloneWorkingCopyStrategy, computeBaseVersion, ingestionBranch, merge, mergeIncremental, normalizeMergeOptions, openProvenanceStore, persistProvenanceRecords, planCandidateWriteSet, planCandidateWriteSetReview, planMerge, planMergeIncremental, provenanceGraphId, readProvenance, revalidateCandidateWriteSetReview };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map