@nicia-ai/typegraph 0.37.1 → 0.38.0

package/dist/graph-merge/index.js

@@ -1,28 +1,39 @@
-import { createStoreWithSchema } from '../chunk-GA4TT3DH.js';
-import '../chunk-M6VES7V6.js';
-import { importGraphStream, exportGraphStream } from '../chunk-TKT2XHED.js';
-import '../chunk-RCVLFTCT.js';
-import { defineNode, computeSchemaHash, serializeSchema } from '../chunk-3RWZPJKV.js';
-import { getNodeKinds, getEdgeKinds, defineGraph } from '../chunk-3SLPDKHQ.js';
+import { createStoreWithSchema } from '../chunk-A2FGSWMQ.js';
+import { compareStrings } from '../chunk-DRACN6XG.js';
+import '../chunk-AOL64O4Z.js';
+import { importGraphStream, exportGraphStream } from '../chunk-E6YZRKMM.js';
+import '../chunk-UPXDVI3T.js';
+import { storeBackend, generateId, computeUniqueKey, transactionBackend, lockRecordedGraphWrite, readRevisionOrigin, readRecordedClock } from '../chunk-RQPRCEIO.js';
+import '../chunk-35S6P5ZU.js';
+import '../chunk-PZHC5GCD.js';
+import '../chunk-J6IJARLG.js';
+import { computeSchemaHash, serializeSchema } from '../chunk-VBH7ZXSZ.js';
+import { defineNode } from '../chunk-76HE7DJP.js';
+import '../chunk-ZE6NVENI.js';
 import { sortedReplacer } from '../chunk-UR7W5YQK.js';
-import '../chunk-KQJ54OG5.js';
-import '../chunk-YTSN73ND.js';
-import '../chunk-K5UBVGJN.js';
-import { sha256Hex } from '../chunk-W63OVYY4.js';
-import '../chunk-EXU3RASM.js';
-import '../chunk-UGZUAYAR.js';
-import { ok, err, isErr, computeTransitiveClosure, isReachable } from '../chunk-L7HQ2OSI.js';
-export { isErr, isOk, unwrap } from '../chunk-L7HQ2OSI.js';
-import '../chunk-TPF25IG6.js';
-import { compareStrings } from '../chunk-BYPOGQWK.js';
-import { generateId, computeUniqueKey, lockRecordedGraphWrite, readRevisionOrigin, readRecordedClock } from '../chunk-VKGKDOKR.js';
-import '../chunk-44TA22QT.js';
-import '../chunk-XGPUQ56G.js';
-import '../chunk-OHMP6N2J.js';
-import '../chunk-PC2UBAUB.js';
+import '../chunk-KFLXWVUJ.js';
+import { getNodeKinds, getEdgeKinds, defineGraph } from '../chunk-PH4IJ3V5.js';
+import '../chunk-I6FX7AAG.js';
+import '../chunk-U4JDJKPD.js';
+import '../chunk-BQITNFQJ.js';
+import '../chunk-VDYA2HMS.js';
+import { sha256Hex } from '../chunk-K34OPSJK.js';
+import '../chunk-2EBMPJBO.js';
+import '../chunk-G3CSQLLT.js';
+import '../chunk-DDCIXXOO.js';
+import '../chunk-Y7M44XEK.js';
+import '../chunk-6XDBRDZE.js';
+import '../chunk-D7PG5D5K.js';
 import '../chunk-SNXVDZAJ.js';
+import { requireDefined } from '../chunk-QMQLUA66.js';
+import '../chunk-PC2UBAUB.js';
+import { ok, err, isErr, computeTransitiveClosure, isReachable } from '../chunk-SCTZRFW5.js';
+export { isErr, isOk, unwrap } from '../chunk-SCTZRFW5.js';
+import '../chunk-GYA4JRP5.js';
+import '../chunk-TAUGGLNQ.js';
 import '../chunk-ITE4IXAK.js';
-import { TypeGraphError } from '../chunk-5PNMDJ7J.js';
+import '../chunk-XZA3Y4YH.js';
+import { TypeGraphError } from '../chunk-DPNA466P.js';
 import '../chunk-G6Q5UM7U.js';
 import { z } from 'zod';
 
@@ -112,7 +123,7 @@ async function enumerateAllNodes(backend, graphId, kind) {
     if (page.length < ENUMERATION_PAGE_SIZE) {
       break;
     }
-    after = page.at(-1).id;
+    after = requireDefined(page.at(-1)).id;
   }
   return collected;
 }
@@ -134,7 +145,7 @@ async function enumerateAllEdges(backend, graphId, kind) {
     if (page.length < ENUMERATION_PAGE_SIZE) {
       break;
     }
-    after = page.at(-1).id;
+    after = requireDefined(page.at(-1)).id;
   }
   return collected;
 }
@@ -255,12 +266,12 @@ async function diffAgainstBase(baseStore, forkStore, captureForkState = true) {
   const forkNodeVersions = /* @__PURE__ */ new Map();
   for (const kind of nodeKinds) {
     const baseRows = await enumerateAllNodes(
-      baseStore.backend,
+      storeBackend(baseStore),
       baseStore.graphId,
       kind
     );
     const forkRows = await enumerateAllNodes(
-      forkStore.backend,
+      storeBackend(forkStore),
       forkStore.graphId,
       kind
     );
@@ -286,12 +297,12 @@ async function diffAgainstBase(baseStore, forkStore, captureForkState = true) {
   const forkEdgeSignatures = /* @__PURE__ */ new Map();
   for (const kind of edgeKinds) {
     const baseRows = await enumerateAllEdges(
-      baseStore.backend,
+      storeBackend(baseStore),
       baseStore.graphId,
       kind
     );
     const forkRows = await enumerateAllEdges(
-      forkStore.backend,
+      storeBackend(forkStore),
       forkStore.graphId,
       kind
     );
@@ -356,7 +367,10 @@ async function readActiveSchemaVersion(backend, graphId) {
   return active?.version ?? FALLBACK_SCHEMA_VERSION;
 }
 async function computeSchemaComponent(store) {
-  const version = await readActiveSchemaVersion(store.backend, store.graphId);
+  const version = await readActiveSchemaVersion(
+    storeBackend(store),
+    store.graphId
+  );
   return computeSchemaHash(serializeSchema(store.graph, version));
 }
 function byDigestEntry(left, right) {
@@ -422,7 +436,7 @@ async function computeBaseVersion(store) {
   }
   const [schemaComponent, contentComponent] = await Promise.all([
     computeSchemaComponent(store),
-    computeContentComponent(store.backend, store.graphId, store.graph)
+    computeContentComponent(storeBackend(store), store.graphId, store.graph)
   ]);
   return asBaseVersion(
     `${schemaComponent}${TOKEN_SEPARATOR}${contentComponent}`
@@ -644,7 +658,7 @@ function blockNodes(newNodes, resolveConfig, uniqueConstraints = []) {
   );
   const ordered = /* @__PURE__ */ new Map();
   for (const key of sortedKeys) {
-    const members = [...buckets.get(key)].sort(
+    const members = [...requireDefined(buckets.get(key))].sort(
       (left, right) => compareStrings(left.id, right.id)
     );
     ordered.set(key, members);
@@ -672,7 +686,7 @@ function buildBranchRank(branchOrder, allBranchIds) {
   return rank;
 }
 function pickByPriority(values, branchRank) {
-  let chosen = values[0];
+  let chosen = requireDefined(values[0]);
   let chosenRank = branchRank.get(chosen.branchId) ?? Number.MAX_SAFE_INTEGER;
   for (const candidate of values.slice(1)) {
     const candidateRank = branchRank.get(candidate.branchId) ?? Number.MAX_SAFE_INTEGER;
@@ -686,7 +700,7 @@ function pickByPriority(values, branchRank) {
   return chosen.value;
 }
 function pickByWeight(values, weights, branchRank) {
-  let chosen = values[0];
+  let chosen = requireDefined(values[0]);
   let chosenWeight = weights.get(chosen.branchId) ?? 0;
   let chosenRank = branchRank.get(chosen.branchId) ?? Number.MAX_SAFE_INTEGER;
   for (const candidate of values.slice(1)) {
@@ -713,7 +727,7 @@ function allValuesEqual(values) {
   if (values.length <= 1) {
     return true;
   }
-  const first = canonicalValueKey(values[0].value);
+  const first = canonicalValueKey(requireDefined(values[0]).value);
   return values.every(
     (candidate) => canonicalValueKey(candidate.value) === first
   );
@@ -799,7 +813,7 @@ function pickClusterSurvivor(members, cluster, canonicalOverride, preferKind) {
   const byKey = (left, right) => compareMergeKeys(mergeKeyOf(left), mergeKeyOf(right));
   const baseMembers = members.filter((member) => member.origin === "base").sort(byKey);
   if (baseMembers.length > 0) {
-    return baseMembers[0];
+    return requireDefined(baseMembers[0]);
   }
   let canonicalId;
   if (canonicalOverride !== void 0) {
@@ -812,15 +826,15 @@ function pickClusterSurvivor(members, cluster, canonicalOverride, preferKind) {
     const minIdentity = [...cluster.members].sort(
       (left, right) => compareMergeKeys(left, right)
     )[0];
-    canonicalId = minIdentity === void 0 ? members[0].id : idOf(minIdentity);
+    canonicalId = minIdentity === void 0 ? requireDefined(members[0]).id : idOf(minIdentity);
   }
   const membersAtId = members.filter((member) => member.id === canonicalId);
   if (membersAtId.length === 0) {
-    return [...members].sort(byKey)[0];
+    return requireDefined([...members].sort(byKey)[0]);
   }
   const kinds = [...new Set(membersAtId.map((member) => member.kind))];
   const chosenKind = preferKind !== void 0 && kinds.length > 1 ? preferKind(kinds) : void 0;
-  return (chosenKind === void 0 ? void 0 : membersAtId.find((member) => member.kind === chosenKind)) ?? [...membersAtId].sort(byKey)[0];
+  return (chosenKind === void 0 ? void 0 : membersAtId.find((member) => member.kind === chosenKind)) ?? requireDefined([...membersAtId].sort(byKey)[0]);
 }
 function findPreferredMember(members, property, preferredBranchId) {
   if (preferredBranchId === void 0) {
@@ -847,7 +861,7 @@ function pickCanonicalPropertyValue(canonicalMember, members, property, values,
     return preferredValue;
   }
   const canonicalValue = memberPropertyValue(canonicalMember, property);
-  return canonicalValue === void 0 ? values[0].value : canonicalValue;
+  return canonicalValue === void 0 ? requireDefined(values[0]).value : canonicalValue;
 }
 function unionProperties(canonicalMember, members, context, baseContext, branchRank, preferredBranchId) {
   const canonicalId = canonicalMember.id;
@@ -962,11 +976,11 @@ var UnionFind = class {
     this.add(value);
     let root = value;
     while (this.parent.get(root) !== root) {
-      root = this.parent.get(root);
+      root = requireDefined(this.parent.get(root));
     }
     let cursor = value;
     while (cursor !== root) {
-      const next = this.parent.get(cursor);
+      const next = requireDefined(this.parent.get(cursor));
       this.parent.set(cursor, root);
       cursor = next;
     }
@@ -1152,8 +1166,8 @@ function cosineSimilarity(left, right) {
   let leftMagnitude = 0;
   let rightMagnitude = 0;
   for (let index = 0; index < left.length; index += 1) {
-    const leftComponent = left[index];
-    const rightComponent = right[index];
+    const leftComponent = requireDefined(left[index]);
+    const rightComponent = requireDefined(right[index]);
     dot += leftComponent * rightComponent;
     leftMagnitude += leftComponent * leftComponent;
     rightMagnitude += rightComponent * rightComponent;
@@ -1387,7 +1401,10 @@ function buildComponents(edges, nodeIds, edgesSorted = false) {
     });
   }
   clusters.sort(
-    (left, right) => compareMergeKeys(left.members[0], right.members[0])
+    (left, right) => compareMergeKeys(
+      requireDefined(left.members[0]),
+      requireDefined(right.members[0])
+    )
   );
   return clusters;
 }
@@ -1399,8 +1416,8 @@ function adjacencyOf(members, edges) {
   }
   for (const edge of edges) {
     if (memberSet.has(edge.a) && memberSet.has(edge.b)) {
-      adjacency.get(edge.a).add(edge.b);
-      adjacency.get(edge.b).add(edge.a);
+      requireDefined(adjacency.get(edge.a)).add(edge.b);
+      requireDefined(adjacency.get(edge.b)).add(edge.a);
     }
   }
   return adjacency;
@@ -1415,10 +1432,10 @@ function exceedsDiameter(members, edges, maxDiameter) {
     const queue = [source];
     let head = 0;
     while (head < queue.length) {
-      const current = queue[head];
+      const current = requireDefined(queue[head]);
       head += 1;
-      const currentDistance = distance.get(current);
-      for (const neighbor of adjacency.get(current)) {
+      const currentDistance = requireDefined(distance.get(current));
+      for (const neighbor of requireDefined(adjacency.get(current))) {
         if (!distance.has(neighbor)) {
           const neighborDistance = currentDistance + 1;
           if (neighborDistance > maxDiameter) {
@@ -1501,7 +1518,10 @@ function enforceDiameter(clusters, candidateEdges, clusterMaxDiameter) {
     }
   }
   guarded.sort(
-    (left, right) => compareMergeKeys(left.members[0], right.members[0])
+    (left, right) => compareMergeKeys(
+      requireDefined(left.members[0]),
+      requireDefined(right.members[0])
+    )
   );
   return guarded;
 }
@@ -1546,7 +1566,10 @@ function enforceBaseGuard(clusters, candidateEdges, baseIds) {
     );
   }
   result.sort(
-    (left, right) => compareMergeKeys(left.members[0], right.members[0])
+    (left, right) => compareMergeKeys(
+      requireDefined(left.members[0]),
+      requireDefined(right.members[0])
+    )
   );
   return { clusters: result, events };
 }
@@ -1554,7 +1577,7 @@ function enforceBaseGuard(clusters, candidateEdges, baseIds) {
 // src/graph-merge/delete-modify.ts
 var DELETED_NODE_DROP_REASON = "delete-modify:deleteWins";
 function pickHighestPriorityBranch(branchIds, branchRank) {
-  let chosen = branchIds[0];
+  let chosen = requireDefined(branchIds[0]);
   let chosenRank = branchRank.get(chosen) ?? Number.MAX_SAFE_INTEGER;
   for (const candidate of branchIds.slice(1)) {
     const candidateRank = branchRank.get(candidate) ?? Number.MAX_SAFE_INTEGER;
@@ -1610,8 +1633,8 @@ function resolveDeleteModifyOver(modified, deleted, modifiedEntity, deletedEntit
       }
       continue;
     }
-    const deletionsForKey = deletedByKey.get(key);
-    const { id, kind } = modifiedEntity(modifications[0]);
+    const deletionsForKey = requireDefined(deletedByKey.get(key));
+    const { id, kind } = modifiedEntity(requireDefined(modifications[0]));
     const deletedBy = pickHighestPriorityBranch(
       deletionsForKey.map((deletion) => deletion.branchId),
       branchRank
@@ -1646,7 +1669,7 @@ function resolveDeleteModifyOver(modified, deleted, modifiedEntity, deletedEntit
     if (conflictedKeys.has(key)) {
       continue;
     }
-    const { id, kind } = deletedEntity(deletionsForKey[0]);
+    const { id, kind } = deletedEntity(requireDefined(deletionsForKey[0]));
     deletions.push({ id, kind });
   }
   return {
@@ -1678,10 +1701,10 @@ function reconcileOver(survivingModifications, entityOf, rebuild, policy, branch
   const conflicts = [];
   for (const modifications of grouped.values()) {
     if (modifications.length === 1) {
-      out.push(modifications[0]);
+      out.push(requireDefined(modifications[0]));
       continue;
     }
-    const first = entityOf(modifications[0]);
+    const first = entityOf(requireDefined(modifications[0]));
     const { props, conflicts: propertyConflicts } = threeWayMergeProps(
       first.id,
       first.kind,
@@ -1700,7 +1723,7 @@ function reconcileOver(survivingModifications, entityOf, rebuild, policy, branch
     );
     const representative = modifications.find(
       (modification) => modification.branchId === chosenBranch
-    ) ?? modifications[0];
+    ) ?? requireDefined(modifications[0]);
     out.push(rebuild(representative, chosenBranch, props));
     for (const conflict of propertyConflicts) {
       conflicts.push(conflict);
@@ -1748,7 +1771,7 @@ function threeWayMergeProps(entityId, kind, baseProps, contributions, context, b
   }
   for (const property of [...propertyNames].sort(compareStrings)) {
     const baseHas = property in baseProps;
-    const baseKey = baseHas ? canonicalValueKey(baseProps[property]) : void 0;
+    const baseKey = baseHas ? canonicalValueKey(requireDefined(baseProps[property])) : void 0;
     const changed = contributions.filter((contribution) => {
       if (!(property in contribution.forkProps)) {
         return false;
@@ -1765,7 +1788,7 @@ function threeWayMergeProps(entityId, kind, baseProps, contributions, context, b
         (contribution) => !(property in contribution.forkProps)
       );
       if (baseHas && !deletedByFork) {
-        merged[property] = baseProps[property];
+        merged[property] = requireDefined(baseProps[property]);
       }
       continue;
     }
@@ -1773,13 +1796,13 @@ function threeWayMergeProps(entityId, kind, baseProps, contributions, context, b
       values.map((candidate) => canonicalValueKey(candidate.value))
     );
     if (distinctValues.size === 1) {
-      merged[property] = values[0].value;
+      merged[property] = requireDefined(values[0]).value;
       continue;
     }
     const preferredValue = values.find(
       (value2) => value2.branchId === preferredBranchId
     )?.value;
-    const canonicalValue = preferredValue ?? (baseHas ? baseProps[property] : values[0].value);
+    const canonicalValue = preferredValue ?? (baseHas ? requireDefined(baseProps[property]) : requireDefined(values[0]).value);
     const reportedValues = preferredBranchId === void 0 ? values : values.filter((value2) => value2.branchId !== preferredBranchId);
     const { value, conflict } = resolvePropertyUnion(
       { entityId, kind, property, values, reportedValues, canonicalValue },
@@ -1864,7 +1887,7 @@ function groupKey(fromKey, type, toKey) {
 function pickSurvivor(edges, preferredBranchId) {
   const preferred = preferredBranchId === void 0 ? [] : edges.filter((edge) => edge.staged.branchId === preferredBranchId);
   const candidates = preferred.length > 0 ? preferred : edges;
-  let survivor = candidates[0];
+  let survivor = requireDefined(candidates[0]);
   for (const candidate of candidates.slice(1)) {
     if (candidate.staged.id < survivor.staged.id) {
       survivor = candidate;
@@ -1889,7 +1912,7 @@ function unionEdgeProps(survivorId, kind, survivor, edges, context, branchRank,
     if (values.length === 0) {
       continue;
     }
-    const survivorValue = property in survivor.staged.props ? survivor.staged.props[property] : values[0].value;
+    const survivorValue = property in survivor.staged.props ? survivor.staged.props[property] : requireDefined(values[0]).value;
     const canonicalValue = values.find((value2) => value2.branchId === preferredBranchId)?.value ?? survivorValue;
     const reportedValues = preferredBranchId === void 0 ? values : values.filter((value2) => value2.branchId !== preferredBranchId);
     const { value, conflict } = resolvePropertyUnion(
@@ -1955,10 +1978,10 @@ function repointEdges(stagedEdges, canonicalOf, deletedNodeIds, policy, branchRa
     (left, right) => compareStrings(left, right)
   );
   for (const group of sortedGroups) {
-    const dedupeKeys = [...dedupeKeyByGroup.get(group)];
+    const dedupeKeys = [...requireDefined(dedupeKeyByGroup.get(group))];
     const groupEdges = [];
     for (const key of dedupeKeys) {
-      for (const edge of liveByDedupeKey.get(key)) {
+      for (const edge of requireDefined(liveByDedupeKey.get(key))) {
         groupEdges.push(edge);
       }
     }
@@ -2262,7 +2285,12 @@ function windowedPairs(members, config) {
   for (let index = 0; index < keyed.length; index += 1) {
     const last = Math.min(index + config.window, keyed.length - 1);
     for (let index_ = index + 1; index_ <= last; index_ += 1) {
-      pairs.push(orderEndpoints(keyed[index].node, keyed[index_].node));
+      pairs.push(
+        orderEndpoints(
+          requireDefined(keyed[index]).node,
+          requireDefined(keyed[index_]).node
+        )
+      );
     }
   }
   return pairs;
@@ -2280,7 +2308,12 @@ function pairsFromBlocks(blocks, keyless) {
     }
     for (let index = 0; index < members.length; index += 1) {
       for (let index_ = index + 1; index_ < members.length; index_ += 1) {
-        pairs.push(orderEndpoints(members[index], members[index_]));
+        pairs.push(
+          orderEndpoints(
+            requireDefined(members[index]),
+            requireDefined(members[index_])
+          )
+        );
       }
     }
   }
@@ -2295,7 +2328,10 @@ function forcedEdgesFromBlocks(blocks) {
     const members = sortMembersById(blocks.get(bucketKey) ?? []);
     for (let index = 0; index < members.length; index += 1) {
       for (let index_ = index + 1; index_ < members.length; index_ += 1) {
-        const { a, b } = orderEndpoints(members[index], members[index_]);
+        const { a, b } = orderEndpoints(
+          requireDefined(members[index]),
+          requireDefined(members[index_])
+        );
         edges.push({ a, b, score: FORCED_MATCH_SCORE });
       }
     }
@@ -2328,8 +2364,8 @@ function ontologyRetypeEdges(stagedIdentities, isRetypeCompatible) {
       }
       for (let index = 1; index < members.length; index += 1) {
         edges.push({
-          a: members[0],
-          b: members[index],
+          a: requireDefined(members[0]),
+          b: requireDefined(members[index]),
           score: FORCED_MATCH_SCORE
         });
       }
@@ -2345,10 +2381,13 @@ function unionByCompatibility(identities, isRetypeCompatible) {
   for (let index = 0; index < identities.length; index += 1) {
     for (let index_ = index + 1; index_ < identities.length; index_ += 1) {
       if (isRetypeCompatible([
-        kindOf(identities[index]),
-        kindOf(identities[index_])
+        kindOf(requireDefined(identities[index])),
+        kindOf(requireDefined(identities[index_]))
       ])) {
-        forest.union(identities[index], identities[index_]);
+        forest.union(
+          requireDefined(identities[index]),
+          requireDefined(identities[index_])
+        );
       }
     }
   }
@@ -2359,7 +2398,7 @@ function unionByCompatibility(identities, isRetypeCompatible) {
 function groupsOf(identities, representativeOf) {
   const byRoot = /* @__PURE__ */ new Map();
   for (const identity of identities) {
-    const root = representativeOf.get(identity);
+    const root = requireDefined(representativeOf.get(identity));
     const bucket = byRoot.get(root);
     if (bucket === void 0) {
       byRoot.set(root, [identity]);
@@ -2545,7 +2584,7 @@ function groupByKind(items) {
   )) {
     ordered.set(
       kind,
-      [...buckets.get(kind)].sort(
+      [...requireDefined(buckets.get(kind))].sort(
         (left, right) => compareByIdThenBranch(left, right)
       )
     );
@@ -2674,7 +2713,9 @@ function mostSpecificCommonKind(closure, kinds) {
   if (qualifiers.length === 0) {
     return void 0;
   }
-  return [...qualifiers].sort((left, right) => compareStrings(left, right))[0];
+  return requireDefined(
+    [...qualifiers].sort((left, right) => compareStrings(left, right))[0]
+  );
 }
 function reconcileTypes(clusters, closure, mode) {
   if (mode === "off") {
@@ -2779,7 +2820,7 @@ async function precomputeEmbeddings(byKind, resolve, embedder) {
     );
   }
   for (const [index, text] of orderedTexts.entries()) {
-    lookup.set(text, vectors[index]);
+    lookup.set(text, requireDefined(vectors[index]));
   }
   return lookup;
 }
@@ -2816,7 +2857,7 @@ async function embedMissingPairTexts(base, pairs, strategy, embedder) {
   }
   const augmented = new Map(existing);
   for (const [index, text] of orderedTexts.entries()) {
-    augmented.set(text, vectors[index]);
+    augmented.set(text, requireDefined(vectors[index]));
   }
   return augmented;
 }
@@ -3265,8 +3306,14 @@ function planMerge(staging, candidateEdges, candidateWarnings, baseMembers, opti
     dropped,
     baseAmbiguities: baseAmbiguities.sort(
       (left, right) => compareMergeKeys(
-        mergeKey(left.baseIds[0].kind, left.baseIds[0].id),
-        mergeKey(right.baseIds[0].kind, right.baseIds[0].id)
+        mergeKey(
+          requireDefined(left.baseIds[0]).kind,
+          requireDefined(left.baseIds[0]).id
+        ),
+        mergeKey(
+          requireDefined(right.baseIds[0]).kind,
+          requireDefined(right.baseIds[0]).id
+        )
       )
     ),
     provenanceRecords,
@@ -3373,7 +3420,7 @@ async function applyMergePlan(plan, nodesApi, edgesApi) {
   return { nodes: committedNodeIds.size, edges: committedEdges };
 }
 async function commitPlan(target, plan, expectedBaseVersion) {
-  if (!target.backend.capabilities.transactions) {
+  if (!storeBackend(target).capabilities.transactions) {
     throw new MergeError(
       "merge() requires a transaction-capable target backend. The merged plan (canonical upserts, soft-deletes, edge upserts) must commit atomically; a non-transactional fallback would leave a partially-merged graph on a mid-commit failure. (mergeIncremental() enforces the same requirement.)",
       { details: { capability: "transactions" } }
@@ -3382,7 +3429,11 @@ async function commitPlan(target, plan, expectedBaseVersion) {
   return withTxConflictRetry(
     () => target.transaction(async (tx) => {
       if (expectedBaseVersion !== void 0) {
-        await assertTargetUnchanged(tx.backend, target, expectedBaseVersion);
+        await assertTargetUnchanged(
+          transactionBackend(tx),
+          target,
+          expectedBaseVersion
+        );
       }
       return applyMergePlan(
         plan,
@@ -3543,7 +3594,7 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
       options.embedder
     );
     const ctx = {
-      backend: store.backend,
+      backend: storeBackend(store),
       ...embeddings === void 0 ? {} : { embeddings }
     };
     const candidates = await generateAllCandidates(
@@ -3586,7 +3637,7 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
     if (options.persistProvenance) {
       try {
         const provenanceStore = await openProvenanceStore(
-          target.backend,
+          storeBackend(target),
           target.graphId
         );
         const count = await persistProvenanceRecords(
@@ -3906,12 +3957,12 @@ async function validateIncrementalEdgeWrites(target, edgesApi, plan) {
         );
       }
       throw new MergeError(
-        `mergeIncremental() would overwrite committed edge "${id}" (kind "${row.kind}") with a different-kind edge "${plannedKindById.get(id)}" of the same id.`,
+        `mergeIncremental() would overwrite committed edge "${id}" (kind "${row.kind}") with a different-kind edge "${requireDefined(plannedKindById.get(id))}" of the same id.`,
         {
           details: {
             id,
             committedKind: row.kind,
-            plannedKind: plannedKindById.get(id)
+            plannedKind: requireDefined(plannedKindById.get(id))
           }
         }
       );
@@ -4031,7 +4082,7 @@ async function assertInheritedUnchanged(args) {
   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 expected = requireDefined(args.expected.get(mergeKey(kind, id)));
       const current = args.deriveValue(rows[index]);
       if (current === expected) {
         continue;
@@ -4102,7 +4153,7 @@ async function assertInheritedEdgesUnchanged(edgesApi, guard, plan) {
   });
 }
 async function commitIncrementalPlan(target, plan, guard) {
-  if (!target.backend.capabilities.transactions) {
+  if (!storeBackend(target).capabilities.transactions) {
     throw new MergeError(
       "mergeIncremental() requires a transaction-capable target backend. Incremental writes must preflight existing rows and commit atomically; non-transactional fallback would allow partial graph writes.",
       { details: { capability: "transactions" } }
@@ -4111,7 +4162,7 @@ async function commitIncrementalPlan(target, plan, guard) {
   return withTxConflictRetry(
     () => target.transaction(async (tx) => {
       if (target.revisionTrackingEnabled) {
-        await lockRecordedGraphWrite(tx.backend, target.graphId);
+        await lockRecordedGraphWrite(transactionBackend(tx), target.graphId);
       }
       const nodesApi = tx.nodes;
       const edgesApi = tx.edges;