@nicia-ai/typegraph 0.33.0 → 0.34.0

package/dist/graph-merge/index.d.cts

@@ -1,10 +1,10 @@
-import { G as GraphDef, t as NodeKinds, u as GetNodeType } from '../manager-BYl_zyZR.cjs';
-import { S as Store, N as Node, U as UniqueIntrospection } from '../store-view-9jQ2rPum.cjs';
+import { G as GraphDef, t as NodeKinds, u as GetNodeType } from '../manager-ms9cKdc6.cjs';
+import { S as Store, N as Node, U as UniqueIntrospection } from '../store-view-D09po4H6.cjs';
 import { d as NodeId, N as NodeType, e as EdgeId, J as JsonValue, f as KindAnnotations, g as EdgeType, D as DeleteBehavior, T as TemporalMode, h as GraphExtensionVersion, i as ExtensionNodeDef, j as ExtensionEdgeDef, k as ExtensionOntologyRelation, l as ExtensionIndex } from '../extension-types-YGFJPrzK.cjs';
 import { T as TypeGraphError } from '../index-SEvUHDA6.cjs';
 import { R as Result } from '../result-DWo6mUVz.cjs';
 export { i as isErr, a as isOk, u as unwrap } from '../result-DWo6mUVz.cjs';
-import { G as GraphBackend, M as MetaEdge, I as IndexDeclaration } from '../types-C_UnQOQp.cjs';
+import { G as GraphBackend, M as MetaEdge, I as IndexDeclaration } from '../types-DkNnF-7K.cjs';
 import { z } from 'zod';
 import '../materialize-indexes-D20xNluI.cjs';
 import 'drizzle-orm';

package/dist/graph-merge/index.d.ts

@@ -1,10 +1,10 @@
-import { G as GraphDef, t as NodeKinds, u as GetNodeType } from '../manager-C0_r0ALf.js';
-import { S as Store, N as Node, U as UniqueIntrospection } from '../store-view-FfE5_7eo.js';
+import { G as GraphDef, t as NodeKinds, u as GetNodeType } from '../manager-BZUeN_BU.js';
+import { S as Store, N as Node, U as UniqueIntrospection } from '../store-view-BlgnhEYf.js';
 import { d as NodeId, N as NodeType, e as EdgeId, J as JsonValue, f as KindAnnotations, g as EdgeType, D as DeleteBehavior, T as TemporalMode, h as GraphExtensionVersion, i as ExtensionNodeDef, j as ExtensionEdgeDef, k as ExtensionOntologyRelation, l as ExtensionIndex } from '../extension-types-YGFJPrzK.js';
 import { T as TypeGraphError } from '../index-DGX6D9j1.js';
 import { R as Result } from '../result-DWo6mUVz.js';
 export { i as isErr, a as isOk, u as unwrap } from '../result-DWo6mUVz.js';
-import { G as GraphBackend, M as MetaEdge, I as IndexDeclaration } from '../types-DGylBhWo.js';
+import { G as GraphBackend, M as MetaEdge, I as IndexDeclaration } from '../types-D1Sqeyxy.js';
 import { z } from 'zod';
 import '../materialize-indexes-CAkIYFV-.js';
 import 'drizzle-orm';

package/dist/graph-merge/index.js

@@ -1,19 +1,28 @@
-import { createStoreWithSchema, generateId, computeUniqueKey } from '../chunk-WLP6TKFB.js';
+import { createStoreWithSchema } from '../chunk-WLRIWYHQ.js';
 import '../chunk-3EUKJEQ3.js';
-import { exportGraph, importGraph } from '../chunk-SPT5JMME.js';
-import { defineNode, computeSchemaHash, serializeSchema } from '../chunk-XVUJY72M.js';
-import { getNodeKinds, getEdgeKinds, defineGraph } from '../chunk-QBYTJSAY.js';
-import '../chunk-PIHXFF73.js';
-import '../chunk-6NRFUHMS.js';
-import '../chunk-IZ4PCL47.js';
-import '../chunk-454I6GDF.js';
-import { ok, err, isErr, computeTransitiveClosure, isReachable } from '../chunk-YCV72E6L.js';
-export { isErr, isOk, unwrap } from '../chunk-YCV72E6L.js';
-import '../chunk-PYD3UCDU.js';
-import { sortedReplacer } from '../chunk-GYVBEZAO.js';
-import '../chunk-C4C4Q7A6.js';
-import { sha256Hex } from '../chunk-2YMGNYXY.js';
+import '../chunk-QV245VMN.js';
+import { exportGraph, importGraph } from '../chunk-T2DWPQNE.js';
+import '../chunk-6SCVW4AS.js';
+import { defineNode, computeSchemaHash, serializeSchema } from '../chunk-K2TGS3EN.js';
+import { sortedReplacer } from '../chunk-UR7W5YQK.js';
+import { getNodeKinds, getEdgeKinds, defineGraph } from '../chunk-CHXTTSC6.js';
+import '../chunk-SHLY4MCM.js';
+import '../chunk-KUTNI6SI.js';
+import '../chunk-4DIBPQNJ.js';
+import { sha256Hex } from '../chunk-K34OPSJK.js';
+import '../chunk-BVTWD66D.js';
+import { ok, err, isErr, computeTransitiveClosure, isReachable } from '../chunk-ZURTTSCM.js';
+export { isErr, isOk, unwrap } from '../chunk-ZURTTSCM.js';
+import { compareStrings } from '../chunk-4S2FXGBJ.js';
+import { generateId, computeUniqueKey } from '../chunk-A7SZZFAG.js';
+import '../chunk-V3QNTB7Z.js';
+import '../chunk-XXVEULWX.js';
+import '../chunk-2MRAX3UE.js';
+import '../chunk-GZCNZ7QW.js';
+import '../chunk-2EBMPJBO.js';
+import '../chunk-Z5XBMDXU.js';
 import '../chunk-XLUNB2TZ.js';
+import '../chunk-ITE4IXAK.js';
 import { TypeGraphError } from '../chunk-TQOYM4LN.js';
 import '../chunk-K5P5OZXS.js';
 import { z } from 'zod';
@@ -25,6 +34,16 @@ function canonicalizeProps(props) {
 function canonicalValueKey(value) {
   return JSON.stringify(value, sortedReplacer);
 }
+function edgeStateSignature(edge) {
+  return JSON.stringify([
+    edge.fromKind,
+    edge.fromId,
+    edge.toKind,
+    edge.toId,
+    edge.live,
+    canonicalizeProps(edge.props)
+  ]);
+}
 function parseRowProps(props) {
   let parsed;
   try {
@@ -48,9 +67,6 @@ function mergeKey(kind, id) {
   }
   return `${kind}${SEPARATOR}${id}`;
 }
-function compareStrings(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
 function mergeKeyOf(node) {
   return mergeKey(node.kind, node.id);
 }
@@ -226,13 +242,14 @@ function diffEdgeKind(kind, baseRows, forkRows) {
 function byId(left, right) {
   return compareStrings(left.id, right.id);
 }
-async function diffAgainstBase(baseStore, forkStore) {
+async function diffAgainstBase(baseStore, forkStore, captureForkState = true) {
   const graph = baseStore.graph;
   const nodeKinds = getNodeKinds(graph);
   const edgeKinds = getEdgeKinds(graph);
   const newNodes = [];
   const modifiedNodes = [];
   const deletedNodes = [];
+  const forkNodeVersions = /* @__PURE__ */ new Map();
   for (const kind of nodeKinds) {
     const baseRows = await enumerateAllNodes(
       baseStore.backend,
@@ -244,6 +261,11 @@ async function diffAgainstBase(baseStore, forkStore) {
       forkStore.graphId,
       kind
     );
+    if (captureForkState) {
+      for (const row of forkRows) {
+        forkNodeVersions.set(mergeKey(kind, row.id), row.version);
+      }
+    }
     const delta = diffNodeKind(kind, baseRows, forkRows);
     for (const entry of delta.new) {
       newNodes.push(entry);
@@ -258,6 +280,7 @@ async function diffAgainstBase(baseStore, forkStore) {
   const newEdges = [];
   const modifiedEdges = [];
   const deletedEdges = [];
+  const forkEdgeSignatures = /* @__PURE__ */ new Map();
   for (const kind of edgeKinds) {
     const baseRows = await enumerateAllEdges(
       baseStore.backend,
@@ -269,6 +292,21 @@ async function diffAgainstBase(baseStore, forkStore) {
       forkStore.graphId,
       kind
     );
+    if (captureForkState) {
+      for (const row of forkRows) {
+        forkEdgeSignatures.set(
+          mergeKey(kind, row.id),
+          edgeStateSignature({
+            fromKind: row.from_kind,
+            fromId: row.from_id,
+            toKind: row.to_kind,
+            toId: row.to_id,
+            live: isLive(row),
+            props: parseRowProps(row.props)
+          })
+        );
+      }
+    }
     const delta = diffEdgeKind(kind, baseRows, forkRows);
     for (const entry of delta.new) {
       newEdges.push(entry);
@@ -290,7 +328,9 @@ async function diffAgainstBase(baseStore, forkStore) {
       new: newEdges.sort((left, right) => byId(left, right)),
       modified: modifiedEdges.sort((left, right) => byId(left, right)),
       deleted: deletedEdges.sort((left, right) => byId(left, right))
-    }
+    },
+    forkNodeVersions,
+    forkEdgeSignatures
   };
 }
 
@@ -2461,16 +2501,26 @@ function groupByKind(items) {
   }
   return ordered;
 }
-async function stageBranches(baseStore, branches) {
+async function stageBranches(baseStore, branches, captureTargetStateFor) {
   const newNodes = [];
   const modifiedNodes = [];
   const deletedNodes = [];
   const newEdges = [];
   const modifiedEdges = [];
   const deletedEdges = [];
+  let targetNodeVersions = /* @__PURE__ */ new Map();
+  let targetEdgeSignatures = /* @__PURE__ */ new Map();
   for (const branch2 of branches) {
-    const diff = await diffAgainstBase(baseStore, branch2.store);
     const branchId = branch2.id;
+    const diff = await diffAgainstBase(
+      baseStore,
+      branch2.store,
+      branchId === captureTargetStateFor
+    );
+    if (branchId === captureTargetStateFor) {
+      targetNodeVersions = diff.forkNodeVersions;
+      targetEdgeSignatures = diff.forkEdgeSignatures;
+    }
     for (const node of diff.nodes.new) {
       newNodes.push({ branchId, node, kind: node.kind, id: node.id });
     }
@@ -2504,7 +2554,9 @@ async function stageBranches(baseStore, branches) {
     ),
     deletedEdges: [...deletedEdges].sort(
       (left, right) => compareByKindIdBranch(left, right)
-    )
+    ),
+    targetNodeVersions,
+    targetEdgeSignatures
   };
 }
 
@@ -3381,8 +3433,8 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
     }
   }
   try {
-    const staging = await stageBranches(store, branches);
     const preferredBranchId = incremental?.targetBranchId;
+    const staging = await stageBranches(store, branches, preferredBranchId);
     const branchIds = branches.map((branch2) => branch2.id);
     const branchOrder = preferredBranchId === void 0 ? options.branchOrder ?? [] : [
       preferredBranchId,
@@ -3436,7 +3488,9 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
       // anything NEW the in-tx re-probe surfaces is a window write.
       plannedBaseMatchKeys: new Set(
         candidates.data.baseMembers.map((member) => mergeKeyOf(member))
-      )
+      ),
+      targetNodeVersions: staging.targetNodeVersions,
+      targetEdgeSignatures: staging.targetEdgeSignatures
     });
     const provenance = options.provenance ? buildProvenanceIndex(plan.provenanceRecords) : { byBranch: () => ({ nodeIds: [], edgeIds: [] }) };
     const warnings = [...plan.warnings];
@@ -3866,6 +3920,99 @@ async function assertBaseResolutionStable(lookupStore, guard) {
     }
   );
 }
+function bucketInheritedRefsByKind(refs, identities) {
+  const seen = /* @__PURE__ */ new Set();
+  const idsByKind = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const identity = mergeKey(ref.kind, ref.id);
+    if (!identities.has(identity) || seen.has(identity)) {
+      continue;
+    }
+    seen.add(identity);
+    const bucket = idsByKind.get(ref.kind) ?? [];
+    bucket.push(ref.id);
+    idsByKind.set(ref.kind, bucket);
+  }
+  return idsByKind;
+}
+async function assertInheritedUnchanged(args) {
+  if (args.expected.size === 0) {
+    return;
+  }
+  const idsByKind = bucketInheritedRefsByKind(args.refs, args.expected);
+  for (const [kind, ids] of idsByKind) {
+    const rows = await args.fetchRows(kind, ids);
+    for (const [index, id] of ids.entries()) {
+      const expected = args.expected.get(mergeKey(kind, id));
+      const current = args.deriveValue(rows[index]);
+      if (current === expected) {
+        continue;
+      }
+      throw args.buildError(id, kind, expected, current);
+    }
+  }
+}
+async function assertInheritedTargetUnchanged(nodesApi, edgesApi, guard, plan) {
+  await Promise.all([
+    assertInheritedNodesUnchanged(nodesApi, guard, plan),
+    assertInheritedEdgesUnchanged(edgesApi, guard, plan)
+  ]);
+}
+async function assertInheritedNodesUnchanged(nodesApi, guard, plan) {
+  const nodeRefs = plannedNodeWrites(plan).map(
+    (write) => ({ kind: write.kind, id: write.id })
+  );
+  for (const [identity, kind] of plan.nodeDeletions) {
+    nodeRefs.push({ kind, id: idOf(identity) });
+  }
+  await assertInheritedUnchanged({
+    refs: nodeRefs,
+    expected: guard.targetNodeVersions,
+    fetchRows: (kind, ids) => nodeCollection(nodesApi, kind).getByIds(ids, INCLUDE_TOMBSTONES),
+    deriveValue: (row) => row?.meta.version,
+    buildError: (id, kind, expected, current) => new BaseVersionMismatchError(
+      `mergeIncremental() observed committed node "${id}" (kind "${kind}") at version ${expected} while planning, but it changed before the commit transaction; the resolved plan no longer describes the live target and was not applied.`,
+      {
+        details: {
+          id,
+          kind,
+          expectedVersion: expected,
+          currentVersion: current
+        },
+        suggestion: "Re-run mergeIncremental(); the re-planned merge resolves the inherited modifications against the now-committed rows."
+      }
+    )
+  });
+}
+async function assertInheritedEdgesUnchanged(edgesApi, guard, plan) {
+  const edgeRefs = plan.mergedEdges.map((edge) => ({
+    kind: edge.kind,
+    id: edge.id
+  }));
+  for (const [identity, kind] of plan.edgeDeletions) {
+    edgeRefs.push({ kind, id: idOf(identity) });
+  }
+  await assertInheritedUnchanged({
+    refs: edgeRefs,
+    expected: guard.targetEdgeSignatures,
+    fetchRows: (kind, ids) => edgeCollection(edgesApi, kind).getByIds(ids, INCLUDE_TOMBSTONES),
+    deriveValue: (row) => row === void 0 ? void 0 : edgeStateSignature({
+      fromKind: row.fromKind,
+      fromId: row.fromId,
+      toKind: row.toKind,
+      toId: row.toId,
+      live: row.meta.deletedAt === void 0,
+      props: edgeProps(row)
+    }),
+    buildError: (id, kind) => new BaseVersionMismatchError(
+      `mergeIncremental() observed committed edge "${id}" (kind "${kind}") while planning, but its endpoints, liveness, or props changed before the commit transaction; the resolved plan no longer describes the live target and was not applied.`,
+      {
+        details: { id, kind },
+        suggestion: "Re-run mergeIncremental(); the re-planned merge resolves the inherited modifications against the now-committed rows."
+      }
+    )
+  });
+}
 async function commitIncrementalPlan(target, plan, guard) {
   if (!target.backend.capabilities.transactions) {
     throw new MergeError(
@@ -3878,6 +4025,7 @@ async function commitIncrementalPlan(target, plan, guard) {
       const nodesApi = tx.nodes;
       const edgesApi = tx.edges;
       await assertBaseResolutionStable(tx, guard);
+      await assertInheritedTargetUnchanged(nodesApi, edgesApi, guard, plan);
       await validateIncrementalNodeWrites(target, nodesApi, plan);
       await validateIncrementalEdgeWrites(target, edgesApi, plan);
       return applyMergePlan(plan, nodesApi, edgesApi);