@nicia-ai/typegraph 0.65.0 → 0.66.1

package/dist/graph-merge/index.cjs

@@ -1,24 +1,24 @@
 'use strict';
 
-var chunk3RSFLZ7A_cjs = require('../chunk-3RSFLZ7A.cjs');
-require('../chunk-DSX3P4S5.cjs');
+var chunkY4X6ODVY_cjs = require('../chunk-Y4X6ODVY.cjs');
+require('../chunk-76OB5RSH.cjs');
 var chunk3HMEGR7U_cjs = require('../chunk-3HMEGR7U.cjs');
 require('../chunk-2XQYRCPM.cjs');
-var chunkXSLQYGNR_cjs = require('../chunk-XSLQYGNR.cjs');
-require('../chunk-D2JPOFRZ.cjs');
-require('../chunk-35LDKSMM.cjs');
-require('../chunk-MKJPBSID.cjs');
-require('../chunk-ZOWRACZQ.cjs');
+var chunkT3VU3YRQ_cjs = require('../chunk-T3VU3YRQ.cjs');
+require('../chunk-WY3IFEKV.cjs');
+require('../chunk-VNJMM2QQ.cjs');
+require('../chunk-I7SBZJI2.cjs');
+require('../chunk-G7OKJDMG.cjs');
 require('../chunk-R255UE5U.cjs');
-require('../chunk-KDNRACRG.cjs');
-var chunkFXGZT3WO_cjs = require('../chunk-FXGZT3WO.cjs');
+require('../chunk-MRUOOAIQ.cjs');
+var chunkBX42F7IJ_cjs = require('../chunk-BX42F7IJ.cjs');
 require('../chunk-6YKISECL.cjs');
 var chunkICOTLZBV_cjs = require('../chunk-ICOTLZBV.cjs');
-var chunkSNDJUTMB_cjs = require('../chunk-SNDJUTMB.cjs');
-var chunkBWQA3POT_cjs = require('../chunk-BWQA3POT.cjs');
-var chunkJRWKRBI5_cjs = require('../chunk-JRWKRBI5.cjs');
-var chunkDHRLOQLQ_cjs = require('../chunk-DHRLOQLQ.cjs');
-var chunkOC5ROP7V_cjs = require('../chunk-OC5ROP7V.cjs');
+var chunkEBQX7MYL_cjs = require('../chunk-EBQX7MYL.cjs');
+var chunk6B3LQUYG_cjs = require('../chunk-6B3LQUYG.cjs');
+var chunk5JOCIMQ3_cjs = require('../chunk-5JOCIMQ3.cjs');
+var chunk7LQTDGV5_cjs = require('../chunk-7LQTDGV5.cjs');
+var chunk6JRVV2SS_cjs = require('../chunk-6JRVV2SS.cjs');
 var chunk7D2ZLF4O_cjs = require('../chunk-7D2ZLF4O.cjs');
 var chunk5ICDVLI3_cjs = require('../chunk-5ICDVLI3.cjs');
 var chunkL4L4AV6F_cjs = require('../chunk-L4L4AV6F.cjs');
@@ -49,10 +49,10 @@ var zod = require('zod');
 
 // src/graph-merge/canonical-props.ts
 function canonicalizeProps(props) {
-  return JSON.stringify(props, chunkJRWKRBI5_cjs.sortedReplacer);
+  return JSON.stringify(props, chunk5JOCIMQ3_cjs.sortedReplacer);
 }
 function canonicalValueKey(value) {
-  return JSON.stringify(value, chunkJRWKRBI5_cjs.sortedReplacer);
+  return JSON.stringify(value, chunk5JOCIMQ3_cjs.sortedReplacer);
 }
 function edgeStateSignature(edge) {
   return JSON.stringify([
@@ -759,7 +759,7 @@ function identityEndpointKey(assertion) {
   return chunk5ICDVLI3_cjs.encodeTupleKey(endpointTuple(assertion));
 }
 function identitySemanticKey(assertion) {
-  return chunkSNDJUTMB_cjs.identityAssertionSemanticKey(
+  return chunkEBQX7MYL_cjs.identityAssertionSemanticKey(
     assertion.relation,
     assertion.a,
     assertion.b
@@ -823,7 +823,7 @@ function assertNoOpposingIdentityRelations(assertions) {
     );
     for (const sameAssertion of same) {
       for (const differentAssertion of different) {
-        if (!chunkSNDJUTMB_cjs.identityValidityWindowsOverlap(sameAssertion, differentAssertion)) {
+        if (!chunkEBQX7MYL_cjs.identityValidityWindowsOverlap(sameAssertion, differentAssertion)) {
           continue;
         }
         throw new IdentityMergeConflictError(
@@ -983,7 +983,7 @@ function remapIdentityAssertionEndpoints(assertions, canonicalOf, retypeMap, sto
       );
       continue;
     }
-    const [a, b] = chunkSNDJUTMB_cjs.normalizeIdentityPair(remappedA, remappedB);
+    const [a, b] = chunkEBQX7MYL_cjs.normalizeIdentityPair(remappedA, remappedB);
     const endpointWindowA = endpointWindows.get(mergeKeyOf(a));
     const endpointWindowB = endpointWindows.get(mergeKeyOf(b));
     const validFrom = [
@@ -1138,7 +1138,7 @@ async function buildIdentityPeerProbe(target, probedIds, targetPeers, plan, prof
       (group) => group.map((member) => mergeKey(member.kind, member.id))
     )
   ]);
-  const ledger = (await relevantLedgerAssertions(target, memberKeys, chunkBWQA3POT_cjs.storeBackend(target))).filter(
+  const ledger = (await relevantLedgerAssertions(target, memberKeys, chunk6B3LQUYG_cjs.storeBackend(target))).filter(
     (assertion) => !plannedDeletions.has(mergeKey(assertion.a.kind, assertion.a.id)) && !plannedDeletions.has(mergeKey(assertion.b.kind, assertion.b.id))
   );
   return {
@@ -1159,7 +1159,7 @@ async function buildIdentityPeerProbe(target, probedIds, targetPeers, plan, prof
   };
 }
 async function snapshotIdentityClasses(target, seeds, liveKeys, plannedDeletions, txBackend) {
-  const classes = await chunkBWQA3POT_cjs.storeRuntime(target).structuralIdentityClasses(
+  const classes = await chunk6B3LQUYG_cjs.storeRuntime(target).structuralIdentityClasses(
     seeds,
     txBackend
   );
@@ -1167,7 +1167,7 @@ async function snapshotIdentityClasses(target, seeds, liveKeys, plannedDeletions
   const groups = [];
   for (const seed of seeds) {
     const key = mergeKey(seed.kind, seed.id);
-    const members = (classes.get(chunkSNDJUTMB_cjs.identityReferenceKey(seed)) ?? [seed]).filter(
+    const members = (classes.get(chunkEBQX7MYL_cjs.identityReferenceKey(seed)) ?? [seed]).filter(
       (member) => !plannedDeletions.has(mergeKey(member.kind, member.id))
     );
     groups.push(members);
@@ -1176,7 +1176,7 @@ async function snapshotIdentityClasses(target, seeds, liveKeys, plannedDeletions
   return { fingerprints, groups };
 }
 async function relevantLedgerAssertions(target, memberKeys, backend) {
-  const current = await chunkBWQA3POT_cjs.storeRuntime(target).identityAssertionsAtTarget(
+  const current = await chunk6B3LQUYG_cjs.storeRuntime(target).identityAssertionsAtTarget(
     backend,
     "state"
   );
@@ -1249,7 +1249,7 @@ async function assertPlannedIdentityIdsFresh(target, txBackend, plan) {
     ...plan.identityRetractions.map((retraction) => retraction.id)
   ];
   if (plannedIds.length === 0) return;
-  const storedById = await chunkBWQA3POT_cjs.storeRuntime(target).identityAssertionRowsByIds(
+  const storedById = await chunk6B3LQUYG_cjs.storeRuntime(target).identityAssertionRowsByIds(
     plannedIds,
     txBackend
   );
@@ -1302,7 +1302,7 @@ function affectedIdentityClassSeeds(plan, profile) {
   return [...seedsByKey.values()];
 }
 async function assertMergedIdentityClassesConsistent(target, txBackend, plan) {
-  await chunkBWQA3POT_cjs.storeRuntime(target).assertIdentityClassesConsistentAtTarget(
+  await chunk6B3LQUYG_cjs.storeRuntime(target).assertIdentityClassesConsistentAtTarget(
     txBackend,
     affectedIdentityClassSeeds(plan, target.graph.identity?.sameIdAcrossKinds)
   );
@@ -1356,7 +1356,7 @@ function translateIdentityCommitError(error) {
 }
 async function assertIdentityPeersStable(target, txBackend, probe, plan) {
   if (probe === void 0) return;
-  const live = (await chunkBWQA3POT_cjs.storeRuntime(target).liveNodesSharingIds(probe.ids, txBackend)).filter((peer) => !probe.plannedDeletions.has(mergeKey(peer.kind, peer.id)));
+  const live = (await chunk6B3LQUYG_cjs.storeRuntime(target).liveNodesSharingIds(probe.ids, txBackend)).filter((peer) => !probe.plannedDeletions.has(mergeKey(peer.kind, peer.id)));
   const seedKindsById = /* @__PURE__ */ new Map();
   for (const seed of probe.seeds) {
     const kinds = seedKindsById.get(seed.id) ?? /* @__PURE__ */ new Set();
@@ -1486,9 +1486,9 @@ function filterRowsByIds(rows, ids) {
 }
 async function fetchNodesByIds(backend, graphId, kind, ids) {
   if (ids.length === 0) return [];
-  const rowsById2 = await chunkBWQA3POT_cjs.getNodeRowsByIds(
+  const rowsById2 = await chunk6B3LQUYG_cjs.getNodeRowsByIds(
     backend,
-    chunkDHRLOQLQ_cjs.batchPointReadVerdict(backend),
+    chunk7LQTDGV5_cjs.batchPointReadVerdict(backend),
     graphId,
     kind,
     ids
@@ -1497,9 +1497,9 @@ async function fetchNodesByIds(backend, graphId, kind, ids) {
 }
 async function fetchEdgesByIds(backend, graphId, kind, ids) {
   if (ids.length === 0) return [];
-  const rowsById2 = await chunkBWQA3POT_cjs.getEdgeRowsByIds(
+  const rowsById2 = await chunk6B3LQUYG_cjs.getEdgeRowsByIds(
     backend,
-    chunkDHRLOQLQ_cjs.batchPointReadVerdict(backend),
+    chunk7LQTDGV5_cjs.batchPointReadVerdict(backend),
     graphId,
     ids
   );
@@ -1686,8 +1686,8 @@ async function diffAgainstBase(baseStore, forkStore, captureForkState = true, pr
   const nodeKinds = chunk7D2ZLF4O_cjs.getNodeKinds(graph);
   const edgeKinds = chunk7D2ZLF4O_cjs.getEdgeKinds(graph);
   const [baseIdentity, forkIdentity] = await Promise.all([
-    chunkBWQA3POT_cjs.storeRuntime(baseStore).readCurrentIdentityAssertions("archival"),
-    chunkBWQA3POT_cjs.storeRuntime(forkStore).readCurrentIdentityAssertions("archival")
+    chunk6B3LQUYG_cjs.storeRuntime(baseStore).readCurrentIdentityAssertions("archival"),
+    chunk6B3LQUYG_cjs.storeRuntime(forkStore).readCurrentIdentityAssertions("archival")
   ]);
   const baseIdentityById = new Map(
     baseIdentity.map((assertion) => [assertion.id, assertion])
@@ -1703,21 +1703,21 @@ async function diffAgainstBase(baseStore, forkStore, captureForkState = true, pr
   for (const kind of nodeKinds) {
     const nodeIds = prunedKeys === void 0 ? [] : idsForKind(prunedKeys.nodes, kind);
     const baseRows = prunedKeys === void 0 ? await enumerateAllNodes(
-      chunkBWQA3POT_cjs.storeBackend(baseStore),
+      chunk6B3LQUYG_cjs.storeBackend(baseStore),
       baseStore.graphId,
       kind
     ) : await fetchNodesByIds(
-      chunkBWQA3POT_cjs.storeBackend(baseStore),
+      chunk6B3LQUYG_cjs.storeBackend(baseStore),
       baseStore.graphId,
       kind,
       nodeIds
     );
     const forkRowsFetched = captureForkState || prunedKeys === void 0 ? await enumerateAllNodes(
-      chunkBWQA3POT_cjs.storeBackend(forkStore),
+      chunk6B3LQUYG_cjs.storeBackend(forkStore),
       forkStore.graphId,
       kind
     ) : await fetchNodesByIds(
-      chunkBWQA3POT_cjs.storeBackend(forkStore),
+      chunk6B3LQUYG_cjs.storeBackend(forkStore),
       forkStore.graphId,
       kind,
       nodeIds
@@ -1750,21 +1750,21 @@ async function diffAgainstBase(baseStore, forkStore, captureForkState = true, pr
   for (const kind of edgeKinds) {
     const edgeIds = prunedKeys === void 0 ? [] : idsForKind(prunedKeys.edges, kind);
     const baseRows = prunedKeys === void 0 ? await enumerateAllEdges(
-      chunkBWQA3POT_cjs.storeBackend(baseStore),
+      chunk6B3LQUYG_cjs.storeBackend(baseStore),
       baseStore.graphId,
       kind
     ) : await fetchEdgesByIds(
-      chunkBWQA3POT_cjs.storeBackend(baseStore),
+      chunk6B3LQUYG_cjs.storeBackend(baseStore),
       baseStore.graphId,
       kind,
       edgeIds
     );
     const forkRowsFetched = captureForkState || prunedKeys === void 0 ? await enumerateAllEdges(
-      chunkBWQA3POT_cjs.storeBackend(forkStore),
+      chunk6B3LQUYG_cjs.storeBackend(forkStore),
       forkStore.graphId,
       kind
     ) : await fetchEdgesByIds(
-      chunkBWQA3POT_cjs.storeBackend(forkStore),
+      chunk6B3LQUYG_cjs.storeBackend(forkStore),
       forkStore.graphId,
       kind,
       edgeIds
@@ -1864,10 +1864,10 @@ async function readActiveSchemaVersion(backend, graphId) {
 }
 async function computeSchemaComponent(store) {
   const version = await readActiveSchemaVersion(
-    chunkBWQA3POT_cjs.storeBackend(store),
+    chunk6B3LQUYG_cjs.storeBackend(store),
     store.graphId
   );
-  return chunkFXGZT3WO_cjs.computeSchemaHash(chunkFXGZT3WO_cjs.serializeSchema(store.graph, version));
+  return chunkBX42F7IJ_cjs.computeSchemaHash(chunkBX42F7IJ_cjs.serializeSchema(store.graph, version));
 }
 function byDigestEntry(left, right) {
   const byKind = chunkNYWU6CBZ_cjs.compareStrings(left.kind, right.kind);
@@ -1926,15 +1926,15 @@ async function computeBaseVersion(store) {
       computeSchemaComponent(store),
       store.revisionOriginNow(),
       store.revisionNow(),
-      readActiveSchemaVersion(chunkBWQA3POT_cjs.storeBackend(store), store.graphId)
+      readActiveSchemaVersion(chunk6B3LQUYG_cjs.storeBackend(store), store.graphId)
     ]);
     return asBaseVersion(
       `${schemaComponent2}${SCHEMA_VERSION_TAG}${activeVersion}${TOKEN_SEPARATOR}${revisionComponent(origin, revision)}`
     );
   }
-  const lineage = chunkBWQA3POT_cjs.resolveLineage(store);
+  const lineage = chunk6B3LQUYG_cjs.resolveLineage(store);
   if (lineage !== void 0) {
-    const backend = chunkBWQA3POT_cjs.storeBackend(store);
+    const backend = chunk6B3LQUYG_cjs.storeBackend(store);
     const [schemaComponent2, activeVersion, origin, revision] = await Promise.all([
       computeSchemaComponent(store),
       readActiveSchemaVersion(backend, store.graphId),
@@ -1944,9 +1944,9 @@ async function computeBaseVersion(store) {
       // tracking) still gets a durable per-graph namespace to distinguish
       // it from an unrelated database whose engine coincidentally reports
       // the same revision. See `engineComponent`'s own doc.
-      chunkBWQA3POT_cjs.ensureRevisionOrigin(
+      chunk6B3LQUYG_cjs.ensureRevisionOrigin(
         backend,
-        chunkDHRLOQLQ_cjs.recordedRevisionOriginsVerdict(backend),
+        chunk7LQTDGV5_cjs.recordedRevisionOriginsVerdict(backend),
         store.revisionSchema,
         store.graphId
       ),
@@ -1965,9 +1965,9 @@ async function computeBaseVersion(store) {
   );
 }
 async function computeStoreContentComponent(store) {
-  const identityAssertions = await chunkBWQA3POT_cjs.storeRuntime(store).readCurrentIdentityAssertions("state");
+  const identityAssertions = await chunk6B3LQUYG_cjs.storeRuntime(store).readCurrentIdentityAssertions("state");
   return computeContentComponent(
-    chunkBWQA3POT_cjs.storeBackend(store),
+    chunk6B3LQUYG_cjs.storeBackend(store),
     store.graphId,
     store.graph,
     identityAssertions
@@ -2021,7 +2021,7 @@ function revisionOriginOf(version) {
 }
 async function revisionOriginMatch(backend, schema, graphId, expectedVersion) {
   const expectedOrigin = revisionOriginOf(expectedVersion) ?? engineAnchorOriginOf(expectedVersion);
-  const liveOrigin = await chunkBWQA3POT_cjs.readRevisionOrigin(backend, schema, graphId);
+  const liveOrigin = await chunk6B3LQUYG_cjs.readRevisionOrigin(backend, schema, graphId);
   return { expectedOrigin, liveOrigin, matches: liveOrigin === expectedOrigin };
 }
 function revisionPartsOf(version) {
@@ -2048,9 +2048,9 @@ function schemaActiveVersionOf(version) {
 async function lineageDeltaSinceAnchor(baseStore, base) {
   const revisionAnchor = revisionAnchorOf(base);
   if (revisionAnchor !== void 0) {
-    if (!chunkBWQA3POT_cjs.storeCaptureEnabled(baseStore)) return void 0;
+    if (!chunk6B3LQUYG_cjs.storeCaptureEnabled(baseStore)) return void 0;
     const originMatch = await revisionOriginMatch(
-      chunkBWQA3POT_cjs.storeBackend(baseStore),
+      chunk6B3LQUYG_cjs.storeBackend(baseStore),
       baseStore.revisionSchema,
       baseStore.graphId,
       base
@@ -2058,25 +2058,25 @@ async function lineageDeltaSinceAnchor(baseStore, base) {
     if (!originMatch.matches || originMatch.liveOrigin === void 0) {
       return void 0;
     }
-    return chunkBWQA3POT_cjs.recordedRelationsLineage(baseStore).changesSince(
-      chunkBWQA3POT_cjs.storeBackend(baseStore),
-      chunkBWQA3POT_cjs.encodeRecordedLineageRevision(originMatch.liveOrigin, revisionAnchor),
+    return chunk6B3LQUYG_cjs.recordedRelationsLineage(baseStore).changesSince(
+      chunk6B3LQUYG_cjs.storeBackend(baseStore),
+      chunk6B3LQUYG_cjs.encodeRecordedLineageRevision(originMatch.liveOrigin, revisionAnchor),
       baseStore.graphId
     );
   }
   const engineAnchor = engineAnchorOf(base);
   if (engineAnchor === void 0) return void 0;
   const engineOriginMatch = await revisionOriginMatch(
-    chunkBWQA3POT_cjs.storeBackend(baseStore),
+    chunk6B3LQUYG_cjs.storeBackend(baseStore),
     baseStore.revisionSchema,
     baseStore.graphId,
     base
   );
   if (!engineOriginMatch.matches) return void 0;
-  const lineage = chunkBWQA3POT_cjs.resolveLineage(baseStore);
+  const lineage = chunk6B3LQUYG_cjs.resolveLineage(baseStore);
   if (lineage === void 0) return void 0;
   return lineage.changesSince(
-    chunkBWQA3POT_cjs.storeBackend(baseStore),
+    chunk6B3LQUYG_cjs.storeBackend(baseStore),
     engineAnchor,
     baseStore.graphId
   );
@@ -2101,7 +2101,7 @@ function cloneWorkingCopyWithGraphStrategy(makeBackend, graphForClone) {
     create: async (baseStore) => {
       const backend = await makeBackend();
       try {
-        const [freshStore] = await chunk3RSFLZ7A_cjs.createStoreWithSchema(
+        const [freshStore] = await chunkY4X6ODVY_cjs.createStoreWithSchema(
           graphForClone(baseStore),
           backend,
           {
@@ -2136,16 +2136,16 @@ function cloneWorkingCopyWithGraphStrategy(makeBackend, graphForClone) {
           validateReferences: true,
           batchSize: CLONE_IMPORT_BATCH_SIZE
         };
-        const result = chunkOC5ROP7V_cjs.snapshotExportContention(
-          chunkBWQA3POT_cjs.storeBackend(baseStore),
-          chunkBWQA3POT_cjs.storeBackend(freshStore)
-        ) === void 0 ? await chunkXSLQYGNR_cjs.importGraphStream(
+        const result = chunk6JRVV2SS_cjs.snapshotExportContention(
+          chunk6B3LQUYG_cjs.storeBackend(baseStore),
+          chunk6B3LQUYG_cjs.storeBackend(freshStore)
+        ) === void 0 ? await chunkT3VU3YRQ_cjs.importGraphStream(
           freshStore,
-          chunkXSLQYGNR_cjs.exportGraphStream(baseStore, exportOptions),
+          chunkT3VU3YRQ_cjs.exportGraphStream(baseStore, exportOptions),
           importOptions
-        ) : await chunkXSLQYGNR_cjs.importGraph(
+        ) : await chunkT3VU3YRQ_cjs.importGraph(
           freshStore,
-          await chunkXSLQYGNR_cjs.exportGraph(baseStore, exportOptions),
+          await chunkT3VU3YRQ_cjs.exportGraph(baseStore, exportOptions),
           importOptions
         );
         if (!result.success) {
@@ -2181,15 +2181,15 @@ function resolvedTableNamesEqual(a, b) {
   return [...keys].every((key) => a[key] === b[key]);
 }
 function forkAliasesBase(connectedBackend, baseStore) {
-  const baseBackend = chunkBWQA3POT_cjs.storeBackend(baseStore);
-  return connectedBackend === baseBackend || chunkOC5ROP7V_cjs.isBackendDerivedFrom(connectedBackend, baseBackend) || chunkOC5ROP7V_cjs.isBackendDerivedFrom(baseBackend, connectedBackend) || chunkOC5ROP7V_cjs.sharesSerializedTransactionResource(connectedBackend, baseBackend);
+  const baseBackend = chunk6B3LQUYG_cjs.storeBackend(baseStore);
+  return connectedBackend === baseBackend || chunk6JRVV2SS_cjs.isBackendDerivedFrom(connectedBackend, baseBackend) || chunk6JRVV2SS_cjs.isBackendDerivedFrom(baseBackend, connectedBackend) || chunk6JRVV2SS_cjs.sharesSerializedTransactionResource(connectedBackend, baseBackend);
 }
 function coalescedWorkingCopyClose(store) {
   let closed = false;
   let inFlight;
   return async () => {
     if (closed) return;
-    inFlight ??= chunkBWQA3POT_cjs.storeBackend(store).close().then(() => {
+    inFlight ??= chunk6B3LQUYG_cjs.storeBackend(store).close().then(() => {
       closed = true;
     }).finally(() => {
       inFlight = void 0;
@@ -2220,13 +2220,13 @@ function forkedWorkingCopyStrategy(options) {
           "Fork backend aliases its base: connect() returned the base store's own backend instead of an independent connection to the fork \u2014 directly (the same backend object), through backend derivation, or through a connection the two backends share. Writing to this working copy would mutate the base, and closing it would close the base's own backend."
         );
       }
-      const backend = chunkOC5ROP7V_cjs.wrapWithManagedClose(connectedBackend, async () => {
+      const backend = chunk6JRVV2SS_cjs.wrapWithManagedClose(connectedBackend, async () => {
         await fork.dispose?.();
       });
       try {
         const forkOptions = forkStoreOptions(baseStore);
         const inheritedTables = baseStore.revisionSchema.tables;
-        const connectedTables = chunkOC5ROP7V_cjs.createSqlSchema(
+        const connectedTables = chunk6JRVV2SS_cjs.createSqlSchema(
           connectedBackend.tableNames
         ).tables;
         if (!resolvedTableNamesEqual(inheritedTables, connectedTables)) {
@@ -2235,7 +2235,7 @@ function forkedWorkingCopyStrategy(options) {
             { details: { inheritedTables, connectedTables } }
           );
         }
-        const forkStore = chunk3RSFLZ7A_cjs.createStore(baseStore.graph, backend, forkOptions);
+        const forkStore = chunkY4X6ODVY_cjs.createStore(baseStore.graph, backend, forkOptions);
         const forkVersion = await computeBaseVersion(forkStore);
         if (forkVersion !== base) {
           throw new BranchError(
@@ -2283,7 +2283,7 @@ function graphWithoutNodeUniqueness(graph) {
 async function branch(baseStore, makeBackend, options, strategy) {
   try {
     const base = await computeBaseVersion(baseStore);
-    const id = options?.id ?? asBranchId(chunkBWQA3POT_cjs.generateId());
+    const id = options?.id ?? asBranchId(chunk6B3LQUYG_cjs.generateId());
     const workingCopyStrategy = strategy ?? cloneWorkingCopyStrategy(makeBackend);
     const store = await workingCopyStrategy.create(baseStore, base);
     const { schemaAnchor, forkRevision } = await captureBranchForkState(store);
@@ -2305,14 +2305,14 @@ async function branch(baseStore, makeBackend, options, strategy) {
 }
 async function captureBranchForkState(store) {
   try {
-    const schemaRow = await chunkBWQA3POT_cjs.storeBackend(store).getActiveSchema(store.graphId);
+    const schemaRow = await chunk6B3LQUYG_cjs.storeBackend(store).getActiveSchema(store.graphId);
     const schemaAnchor = schemaRow === void 0 ? void 0 : { version: schemaRow.version, hash: schemaRow.schema_hash };
-    const lineage = chunkBWQA3POT_cjs.resolveLineage(store);
-    const forkRevision = lineage === void 0 ? void 0 : await lineage.revision(chunkBWQA3POT_cjs.storeBackend(store));
+    const lineage = chunk6B3LQUYG_cjs.resolveLineage(store);
+    const forkRevision = lineage === void 0 ? void 0 : await lineage.revision(chunk6B3LQUYG_cjs.storeBackend(store));
     return { schemaAnchor, forkRevision };
   } catch (error) {
     try {
-      await chunkBWQA3POT_cjs.storeBackend(store).close();
+      await chunk6B3LQUYG_cjs.storeBackend(store).close();
     } catch {
     }
     throw error;
@@ -2321,7 +2321,7 @@ async function captureBranchForkState(store) {
 
 // src/graph-merge/evolution-target.ts
 function evolutionPlanningTarget(store, plan) {
-  const planningTarget = chunkBWQA3POT_cjs.storeRuntime(store).evolutionPlanningTarget;
+  const planningTarget = chunk6B3LQUYG_cjs.storeRuntime(store).evolutionPlanningTarget;
   if (planningTarget === void 0) {
     throw new MergePlanCapabilityError(
       "This Store cannot construct a resulting-schema merge planning view.",
@@ -2380,7 +2380,7 @@ async function ingestionBranch(baseStore, makeBackend, options) {
       close: coalescedWorkingCopyClose(store)
     });
     PRIVATE_BRANCHES.set(handle, privateBranch);
-    chunkXSLQYGNR_cjs.registerIngestionImportTarget(handle, store);
+    chunkT3VU3YRQ_cjs.registerIngestionImportTarget(handle, store);
     return chunkHQU2SE74_cjs.ok(handle);
   } catch (error) {
     return chunkHQU2SE74_cjs.err(
@@ -2403,21 +2403,21 @@ function unwrapMergeBranches(inputs) {
 
 // src/graph-merge/adopted-transaction.ts
 async function assertMergeTransactionPristine(target, txBackend) {
-  if (chunkBWQA3POT_cjs.hasPendingRecordedGraphWrites(txBackend, target.graphId) || chunkBWQA3POT_cjs.hasPendingWriteTransactionRevision(txBackend)) {
+  if (chunk6B3LQUYG_cjs.hasPendingRecordedGraphWrites(txBackend, target.graphId) || chunk6B3LQUYG_cjs.hasPendingWriteTransactionRevision(txBackend)) {
     throw new MergePlanCapabilityError(
       "Apply the merge plan before writing to its target graph in this transaction.",
       { details: { capability: "mergeTransactionPristine" } }
     );
   }
-  if (chunkOC5ROP7V_cjs.resolveWriteFencePlan(txBackend).kind !== "engine-serialized") return;
-  const statements = chunkDHRLOQLQ_cjs.statementExecutionVerdict(chunkBWQA3POT_cjs.storeBackend(target));
+  if (chunk6JRVV2SS_cjs.resolveWriteFencePlan(txBackend).kind !== "engine-serialized") return;
+  const statements = chunk7LQTDGV5_cjs.statementExecutionVerdict(chunk6B3LQUYG_cjs.storeBackend(target));
   if (!statements.supported) {
     throw new MergePlanCapabilityError(
       "Adopted merge application requires transaction-scoped statement execution to acquire the engine writer slot.",
       { details: { capability: "mergeTransactionWriterSlot" } }
     );
   }
-  await chunkBWQA3POT_cjs.ensureEngineSerializedWriterSlot(
+  await chunk6B3LQUYG_cjs.ensureEngineSerializedWriterSlot(
     txBackend,
     target.revisionSchema,
     statements
@@ -2426,8 +2426,8 @@ async function assertMergeTransactionPristine(target, txBackend) {
 
 // src/graph-merge/apply-callbacks.ts
 var NODE_READ_NAMES = [
-  ...chunk3RSFLZ7A_cjs.NODE_TEMPORAL_READ_NAMES,
-  ...chunk3RSFLZ7A_cjs.CURRENT_ONLY_READ_NAMES
+  ...chunkY4X6ODVY_cjs.NODE_TEMPORAL_READ_NAMES,
+  ...chunkY4X6ODVY_cjs.CURRENT_ONLY_READ_NAMES
 ];
 function pickReadMethods(source, names) {
   return Object.fromEntries(names.map((name) => [name, source[name]]));
@@ -2445,12 +2445,12 @@ function mergePlanReadContext(tx, graph) {
         kind,
         pickReadMethods(
           chunkBXHAPCQG_cjs.requireDefined(tx.edges[kind]),
-          chunk3RSFLZ7A_cjs.EDGE_TEMPORAL_READ_NAMES
+          chunkY4X6ODVY_cjs.EDGE_TEMPORAL_READ_NAMES
         )
       ])
     ),
     ..."identity" in tx ? {
-      identity: pickReadMethods(tx.identity, chunk3RSFLZ7A_cjs.IDENTITY_READ_NAMES)
+      identity: pickReadMethods(tx.identity, chunkY4X6ODVY_cjs.IDENTITY_READ_NAMES)
     } : {}
   };
 }
@@ -5148,7 +5148,7 @@ var mergePlanArtifactV1Schema = mergePlanArtifactV1BaseSchema.superRefine(
 // src/graph-merge/plan-canonical.ts
 function canonicalMergePlanJson(artifact) {
   const digestless = "digest" in artifact ? omitDigest(artifact) : artifact;
-  return JSON.stringify(digestless, chunkJRWKRBI5_cjs.sortedReplacer);
+  return JSON.stringify(digestless, chunk5JOCIMQ3_cjs.sortedReplacer);
 }
 async function computeMergePlanDigest(artifact) {
   return chunkZY4GXIVN_cjs.sha256Hex(canonicalMergePlanJson(artifact), 32);
@@ -5162,7 +5162,7 @@ async function finalizeMergePlanArtifact(artifact) {
     }
   };
   const canonical = JSON.parse(
-    JSON.stringify(finalized, chunkJRWKRBI5_cjs.sortedReplacer)
+    JSON.stringify(finalized, chunk5JOCIMQ3_cjs.sortedReplacer)
   );
   return canonical;
 }
@@ -5268,7 +5268,7 @@ function buildProvenanceGraph(targetGraphId) {
   });
 }
 async function openProvenanceStore(...args) {
-  const [backend, targetGraphId] = args.length === 1 ? [chunkBWQA3POT_cjs.storeBackend(args[0]), args[0].graphId] : args;
+  const [backend, targetGraphId] = args.length === 1 ? [chunk6B3LQUYG_cjs.storeBackend(args[0]), args[0].graphId] : args;
   const graph = buildOwnedProvenanceGraph(targetGraphId);
   const preflight = await inspectSidecarGraphId(backend, graph, targetGraphId);
   if (preflight.state === "refuse") {
@@ -5280,7 +5280,7 @@ async function openProvenanceStore(...args) {
       throw provenanceGraphIdCollision(graph.id, targetGraphId, claim.reason);
     }
   }
-  const [store] = await chunk3RSFLZ7A_cjs.createStoreWithSchema(graph, backend);
+  const [store] = await chunkY4X6ODVY_cjs.createStoreWithSchema(graph, backend);
   return store;
 }
 async function claimSidecarOwnership(backend, graph, targetGraphId) {
@@ -5306,8 +5306,8 @@ async function claimSidecarOwnership(backend, graph, targetGraphId) {
   });
 }
 async function drainUnfencedRowWriters(tx) {
-  const plan = chunkOC5ROP7V_cjs.resolveWriteFencePlan(tx);
-  const fence = chunkOC5ROP7V_cjs.requireWriteFence(
+  const plan = chunk6JRVV2SS_cjs.resolveWriteFencePlan(tx);
+  const fence = chunk6JRVV2SS_cjs.requireWriteFence(
     plan,
     "graph-merge provenance fence",
     "drain"
@@ -5318,10 +5318,10 @@ async function drainUnfencedRowWriters(tx) {
       if (fence.drain !== "table-lock") {
         return;
       }
-      const schema = chunkOC5ROP7V_cjs.createSqlSchema(tx.tableNames);
+      const schema = chunk6JRVV2SS_cjs.createSqlSchema(tx.tableNames);
       await tx.executeStatement(
         chunkXPSPDFKO_cjs.asCompiledStatementSql(
-          chunkOC5ROP7V_cjs.requireFenceLockTables(fence, "drainUnfencedRowWriters")(
+          chunk6JRVV2SS_cjs.requireFenceLockTables(fence, "drainUnfencedRowWriters")(
             [schema.tables.nodes, schema.tables.edges],
             "share-row-exclusive"
           )
@@ -5350,14 +5350,14 @@ async function inspectSidecarGraphId(port, graph, targetGraphId) {
   if (activeSchema === void 0) {
     return { state: "refuse", reason: "application-graph" };
   }
-  const ownedHash = await chunkFXGZT3WO_cjs.computeSchemaHash(
-    chunkFXGZT3WO_cjs.serializeSchema(graph, activeSchema.version)
+  const ownedHash = await chunkBX42F7IJ_cjs.computeSchemaHash(
+    chunkBX42F7IJ_cjs.serializeSchema(graph, activeSchema.version)
   );
   if (activeSchema.schema_hash === ownedHash) {
     return { state: "refuse", reason: "unowned-exact-schema-graph" };
   }
-  const legacyHash = await chunkFXGZT3WO_cjs.computeSchemaHash(
-    chunkFXGZT3WO_cjs.serializeSchema(buildProvenanceGraph(targetGraphId), activeSchema.version)
+  const legacyHash = await chunkBX42F7IJ_cjs.computeSchemaHash(
+    chunkBX42F7IJ_cjs.serializeSchema(buildProvenanceGraph(targetGraphId), activeSchema.version)
   );
   if (activeSchema.schema_hash !== legacyHash) {
     return { state: "refuse", reason: "application-graph" };
@@ -5461,7 +5461,7 @@ async function* readRowsOfKind(port, graphId, kind) {
   }
 }
 async function hasRowsUnderGraphId(port, graphId, scope) {
-  const schema = chunkOC5ROP7V_cjs.createSqlSchema(port.tableNames);
+  const schema = chunk6JRVV2SS_cjs.createSqlSchema(port.tableNames);
   const kindFilter = scope === "any" ? chunkXPSPDFKO_cjs.sql.empty() : chunkXPSPDFKO_cjs.sql` AND kind <> ${PROVENANCE_KIND}`;
   if (await hasRowsInTable(port, schema.tables.nodes, graphId, kindFilter)) {
     return true;
@@ -6056,12 +6056,12 @@ function dedupeEntityKeys(keys) {
 }
 async function branchPruneTo(baseStore, branch2) {
   if (branch2.forkRevision === void 0) return void 0;
-  const forkLineage = chunkBWQA3POT_cjs.resolveLineage(branch2.store);
+  const forkLineage = chunk6B3LQUYG_cjs.resolveLineage(branch2.store);
   if (forkLineage === void 0) return void 0;
   const forkRevision = branch2.forkRevision;
   const forkDelta = await safeLineageDelta(
     () => forkLineage.changesSince(
-      chunkBWQA3POT_cjs.storeBackend(branch2.store),
+      chunk6B3LQUYG_cjs.storeBackend(branch2.store),
       forkRevision,
       branch2.store.graphId
     )
@@ -6095,7 +6095,7 @@ async function stageBranches(baseStore, branches, captureTargetStateFor) {
   const windowedEdges = [];
   const newIdentityAssertions = [];
   const retractedIdentityAssertions = [];
-  const baseIdentityAssertions = await chunkBWQA3POT_cjs.storeRuntime(baseStore).readCurrentIdentityAssertions("state");
+  const baseIdentityAssertions = await chunk6B3LQUYG_cjs.storeRuntime(baseStore).readCurrentIdentityAssertions("state");
   let targetNodeVersions = /* @__PURE__ */ new Map();
   let targetEdgeSignatures = /* @__PURE__ */ new Map();
   for (const branch2 of branches) {
@@ -6255,7 +6255,7 @@ function reconcileTypes(clusters, closure, mode) {
 // src/graph-merge/write-fence.ts
 async function lockMergeTargetWrite(txBackend, input) {
   try {
-    await chunkBWQA3POT_cjs.lockSchemaVersionForStoreWrite(
+    await chunk6B3LQUYG_cjs.lockSchemaVersionForStoreWrite(
       { graphId: input.graphId, schemaVersion: input.schemaVersion },
       txBackend
     );
@@ -6266,9 +6266,9 @@ async function lockMergeTargetWrite(txBackend, input) {
     throw input.staleSchemaError(error);
   }
   if (input.graphLock === "required") {
-    const lock = await chunkBWQA3POT_cjs.lockRecordedGraphWrite(txBackend, input.graphId);
-    if (input.requireFreshSnapshot && chunkOC5ROP7V_cjs.resolveWriteFencePlan(txBackend).kind !== "engine-serialized") {
-      const isolation = lock.coordination === void 0 ? void 0 : chunkOC5ROP7V_cjs.graphCommandCoordinationIsolation(
+    const lock = await chunk6B3LQUYG_cjs.lockRecordedGraphWrite(txBackend, input.graphId);
+    if (input.requireFreshSnapshot && chunk6JRVV2SS_cjs.resolveWriteFencePlan(txBackend).kind !== "engine-serialized") {
+      const isolation = lock.coordination === void 0 ? void 0 : chunk6JRVV2SS_cjs.graphCommandCoordinationIsolation(
         txBackend.commands,
         input.graphId,
         lock.coordination
@@ -7229,7 +7229,7 @@ async function applyNodeRows(target, txBackend, nodesApi, deletions, upserts) {
       afterImages.set(mergeKey(kind, item.id), props);
     }
   }
-  return chunkBWQA3POT_cjs.storeRuntime(target).applyResolvedNodeUniqueness(
+  return chunk6B3LQUYG_cjs.storeRuntime(target).applyResolvedNodeUniqueness(
     txBackend,
     {
       upserts: upserts.map((upsert) => ({
@@ -7277,7 +7277,7 @@ async function applyEdgeRows(edgesApi, deletions, upserts) {
 }
 async function applyIdentityRows(target, txBackend, assertions, retractions, assertConsistent) {
   try {
-    const applied = await chunkBWQA3POT_cjs.storeRuntime(target).applyIdentityMergeAtTarget(
+    const applied = await chunk6B3LQUYG_cjs.storeRuntime(target).applyIdentityMergeAtTarget(
       txBackend,
       retractions,
       assertions
@@ -7376,30 +7376,30 @@ async function applyInternalMergePlan(plan, nodesApi, edgesApi, target, txBacken
 }
 var MERGE_COMMIT_ATTEMPTS = 3;
 async function commitPlan(target, plan, expectedBaseVersion) {
-  if (!chunkBWQA3POT_cjs.storeBackend(target).capabilities.execution.interactiveTransactions) {
+  if (!chunk6B3LQUYG_cjs.storeBackend(target).capabilities.execution.interactiveTransactions) {
     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: "execution.interactiveTransactions" } }
     );
   }
   return runMergeCommit(
-    () => chunkJRWKRBI5_cjs.runRetriedUnit(
+    () => chunk5JOCIMQ3_cjs.runRetriedUnit(
       {
         operation: "commitPlan",
         attempts: MERGE_COMMIT_ATTEMPTS,
-        target: chunkBWQA3POT_cjs.storeBackend(target)
+        target: chunk6B3LQUYG_cjs.storeBackend(target)
       },
       () => target.transaction(async (tx) => {
         if (expectedBaseVersion !== void 0) {
           await assertTargetUnchanged(
-            chunkBWQA3POT_cjs.transactionBackend(tx),
+            chunk6B3LQUYG_cjs.transactionBackend(tx),
             target,
             expectedBaseVersion
           );
         }
         await assertPlannedIdentityIdsFresh(
           target,
-          chunkBWQA3POT_cjs.transactionBackend(tx),
+          chunk6B3LQUYG_cjs.transactionBackend(tx),
           plan
         );
         return applyInternalMergePlan(
@@ -7407,7 +7407,7 @@ async function commitPlan(target, plan, expectedBaseVersion) {
           tx.nodes,
           tx.edges,
           target,
-          chunkBWQA3POT_cjs.transactionBackend(tx)
+          chunk6B3LQUYG_cjs.transactionBackend(tx)
         );
       }, mergeCommitTransactionOptions(target))
     )
@@ -7424,7 +7424,7 @@ var MERGE_COMMIT_TX_OPTIONS = {
   isolationLevel: "serializable"
 };
 function mergeCommitTransactionOptions(target) {
-  return chunkBWQA3POT_cjs.storeCaptureEnabled(target) ? void 0 : MERGE_COMMIT_TX_OPTIONS;
+  return chunk6B3LQUYG_cjs.storeCaptureEnabled(target) ? void 0 : MERGE_COMMIT_TX_OPTIONS;
 }
 async function engineAnchorMismatch(lineage, session, graphId, expectedRevision) {
   const liveRevision = await lineage.revision(session);
@@ -7473,7 +7473,7 @@ async function assertTargetUnchanged(txBackend, target, expectedBaseVersion) {
         }
       );
     }
-    const liveRevision = await chunkBWQA3POT_cjs.readRecordedClock(
+    const liveRevision = await chunk6B3LQUYG_cjs.readRecordedClock(
       txBackend,
       target.revisionSchema,
       target.graphId
@@ -7549,7 +7549,7 @@ async function assertTargetUnchanged(txBackend, target, expectedBaseVersion) {
     txBackend,
     target.graphId,
     target.graph,
-    await chunkBWQA3POT_cjs.storeRuntime(target).identityAssertionsAtTarget(txBackend, "state")
+    await chunk6B3LQUYG_cjs.storeRuntime(target).identityAssertionsAtTarget(txBackend, "state")
   );
   const expectedContent = contentComponentOf(expectedBaseVersion);
   if (liveContent !== expectedContent) {
@@ -7596,11 +7596,11 @@ async function toleratedByEngineAnchor(store, expectedVersion, liveVersion) {
     liveVersion
   );
   if (expectedRevision === void 0) return false;
-  const lineage = chunkBWQA3POT_cjs.resolveLineage(store);
+  const lineage = chunk6B3LQUYG_cjs.resolveLineage(store);
   if (lineage === void 0) return false;
   const mismatch = await engineAnchorMismatch(
     lineage,
-    chunkBWQA3POT_cjs.storeBackend(store),
+    chunk6B3LQUYG_cjs.storeBackend(store),
     store.graphId,
     expectedRevision
   );
@@ -7666,7 +7666,7 @@ async function tryOpenProvenanceStore(target) {
   }
 }
 function assertPublicPlanCapability(target) {
-  if (!chunkBWQA3POT_cjs.storeBackend(target).capabilities.execution.interactiveTransactions) {
+  if (!chunk6B3LQUYG_cjs.storeBackend(target).capabilities.execution.interactiveTransactions) {
     throw new MergePlanCapabilityError(
       "Public merge plans require a transaction-capable target backend.",
       { details: { capability: "execution.interactiveTransactions" } }
@@ -7685,7 +7685,7 @@ function assertPublicPlanCapability(target) {
 async function captureMergePlanTargetFence(target) {
   assertPublicPlanCapability(target);
   const [activeSchema, schemaHash, origin, revision] = await Promise.all([
-    chunkBWQA3POT_cjs.storeBackend(target).getActiveSchema(target.graphId),
+    chunk6B3LQUYG_cjs.storeBackend(target).getActiveSchema(target.graphId),
     computeSchemaComponent(target),
     target.revisionOriginNow(),
     target.revisionNow()
@@ -7864,7 +7864,7 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
     }
   }
   for (const branch2 of branches) {
-    const branchSchemaRow = await chunkBWQA3POT_cjs.storeBackend(branch2.store).getActiveSchema(
+    const branchSchemaRow = await chunk6B3LQUYG_cjs.storeBackend(branch2.store).getActiveSchema(
       branch2.store.graphId
     );
     let drifted;
@@ -7872,7 +7872,7 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
       const anchor = branch2.schemaAnchor;
       drifted = anchor === void 0 ? branchSchemaRow !== void 0 : branchSchemaRow?.version !== anchor.version || branchSchemaRow.schema_hash !== anchor.hash;
     } else {
-      const sourceSchemaRow = await chunkBWQA3POT_cjs.storeBackend(store).getActiveSchema(
+      const sourceSchemaRow = await chunk6B3LQUYG_cjs.storeBackend(store).getActiveSchema(
         store.graphId
       );
       drifted = branchSchemaRow?.schema_hash !== sourceSchemaRow?.schema_hash;
@@ -7917,7 +7917,7 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
       options.embedder
     );
     const ctx = {
-      backend: chunkBWQA3POT_cjs.storeBackend(store),
+      backend: chunk6B3LQUYG_cjs.storeBackend(store),
       ...embeddings === void 0 ? {} : { embeddings }
     };
     const candidates = await generateAllCandidates(
@@ -7945,7 +7945,7 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
         ])
       ])
     ];
-    const targetPeers = identityProbeIds === void 0 ? [] : await chunkBWQA3POT_cjs.storeRuntime(target).liveNodesSharingIds(identityProbeIds);
+    const targetPeers = identityProbeIds === void 0 ? [] : await chunk6B3LQUYG_cjs.storeRuntime(target).liveNodesSharingIds(identityProbeIds);
     const stagedIdentityIds = [
       .../* @__PURE__ */ new Set([
         ...staging.newIdentityAssertions.map((staged) => staged.assertion.id),
@@ -7954,7 +7954,7 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
         )
       ])
     ];
-    const storedIdentityRowsById = stagedIdentityIds.length === 0 || target.graph.identity === void 0 ? NO_STORED_ASSERTIONS : await chunkBWQA3POT_cjs.storeRuntime(target).identityAssertionRowsByIds(
+    const storedIdentityRowsById = stagedIdentityIds.length === 0 || target.graph.identity === void 0 ? NO_STORED_ASSERTIONS : await chunk6B3LQUYG_cjs.storeRuntime(target).identityAssertionRowsByIds(
       stagedIdentityIds
     );
     const identityContext = {
@@ -7979,14 +7979,14 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
     if (plan.identityAssertions.length > 0) {
       assertOneIdOneTruth(
         plan.identityAssertions,
-        await chunkBWQA3POT_cjs.storeRuntime(target).identityAssertionRowsByIds(
+        await chunk6B3LQUYG_cjs.storeRuntime(target).identityAssertionRowsByIds(
           plan.identityAssertions.map((assertion) => assertion.id)
         )
       );
     }
     let identityGuard;
     if (identityProbeIds !== void 0 && incremental !== void 0) {
-      const freshPeers = await chunkBWQA3POT_cjs.storeRuntime(target).liveNodesSharingIds(identityProbeIds);
+      const freshPeers = await chunk6B3LQUYG_cjs.storeRuntime(target).liveNodesSharingIds(identityProbeIds);
       const built = await buildIdentityPeerProbe(
         target,
         identityProbeIds,
@@ -8345,7 +8345,7 @@ async function planMergeIncremental(args) {
     computeSchemaComponent(target)
   ]);
   if (forkSchema !== targetSchema) return chunkHQU2SE74_cjs.err(incrementalSchemaError());
-  const forkActiveSchema = await chunkBWQA3POT_cjs.storeBackend(forkPoint).getActiveSchema(
+  const forkActiveSchema = await chunk6B3LQUYG_cjs.storeBackend(forkPoint).getActiveSchema(
     forkPoint.graphId
   );
   const targetBranch = {
@@ -8727,7 +8727,7 @@ async function assertMergePlanFenceInsideTransaction(target, txBackend, artifact
       { details: { expected: artifact.target.schema, live: liveSchema } }
     );
   }
-  const liveOrigin = await chunkBWQA3POT_cjs.readRevisionOrigin(
+  const liveOrigin = await chunk6B3LQUYG_cjs.readRevisionOrigin(
     txBackend,
     target.revisionSchema,
     target.graphId
@@ -8743,7 +8743,7 @@ async function assertMergePlanFenceInsideTransaction(target, txBackend, artifact
       }
     );
   }
-  const liveRevision = await chunkBWQA3POT_cjs.readRecordedClock(
+  const liveRevision = await chunk6B3LQUYG_cjs.readRecordedClock(
     txBackend,
     target.revisionSchema,
     target.graphId
@@ -8819,7 +8819,7 @@ async function applyWireMergeWrites(target, nodesApi, edgesApi, txBackend, artif
     txBackend,
     identityAssertions,
     identityRetractions,
-    () => chunkBWQA3POT_cjs.storeRuntime(target).assertIdentityClassesConsistentAtTarget(
+    () => chunk6B3LQUYG_cjs.storeRuntime(target).assertIdentityClassesConsistentAtTarget(
       txBackend,
       identityConsistencySeeds(
         artifact,
@@ -8827,8 +8827,8 @@ async function applyWireMergeWrites(target, nodesApi, edgesApi, txBackend, artif
       )
     )
   );
-  if (!chunkBWQA3POT_cjs.forceRecordedGraphRevision(txBackend, target.graphId) && !chunkBWQA3POT_cjs.forceWriteTransactionRevision(txBackend)) {
-    await chunkBWQA3POT_cjs.advanceRevisionClock(
+  if (!chunk6B3LQUYG_cjs.forceRecordedGraphRevision(txBackend, target.graphId) && !chunk6B3LQUYG_cjs.forceWriteTransactionRevision(txBackend)) {
+    await chunk6B3LQUYG_cjs.advanceRevisionClock(
       txBackend,
       target.revisionSchema,
       target.graphId,
@@ -8890,7 +8890,7 @@ async function validateMergePlanForTarget(target, input) {
 }
 async function applyValidatedMergePlanInTransaction(target, tx, artifact, options, requireFreshSnapshot) {
   const { beforeApply, afterApply } = options;
-  const txBackend = chunkBWQA3POT_cjs.transactionBackend(tx);
+  const txBackend = chunk6B3LQUYG_cjs.transactionBackend(tx);
   await assertMergePlanFenceInsideTransaction(
     target,
     txBackend,
@@ -8949,11 +8949,11 @@ async function applyMergePlan(target, input, options = {}) {
     if (provenanceStore !== void 0 && chunkHQU2SE74_cjs.isErr(provenanceStore)) {
       return chunkHQU2SE74_cjs.err(provenanceStore.error);
     }
-    const merged = await chunkJRWKRBI5_cjs.runRetriedUnit(
+    const merged = await chunk5JOCIMQ3_cjs.runRetriedUnit(
       {
         operation: "applyMergePlan",
         attempts: MERGE_COMMIT_ATTEMPTS,
-        target: chunkBWQA3POT_cjs.storeBackend(target)
+        target: chunk6B3LQUYG_cjs.storeBackend(target)
       },
       () => target.transaction(
         (tx) => applyValidatedMergePlanInTransaction(
@@ -9005,7 +9005,7 @@ async function applyMergePlanInTransaction(target, tx, input) {
   try {
     let effectiveTarget;
     try {
-      effectiveTarget = chunkBWQA3POT_cjs.resolveEvolvedTransactionStore(tx, target);
+      effectiveTarget = chunk6B3LQUYG_cjs.resolveEvolvedTransactionStore(tx, target);
     } catch (error) {
       throw new MergePlanCapabilityError(
         "The merge transaction must belong to an active callback of the target Store.",
@@ -9023,7 +9023,7 @@ async function applyMergePlanInTransaction(target, tx, input) {
         }
       );
     }
-    const txBackend = chunkBWQA3POT_cjs.transactionBackend(tx);
+    const txBackend = chunk6B3LQUYG_cjs.transactionBackend(tx);
     await assertMergeTransactionPristine(effectiveTarget, txBackend);
     const merged = await applyValidatedMergePlanInTransaction(
       effectiveTarget,
@@ -9469,11 +9469,11 @@ async function assertForkPointUnchanged(precondition) {
     liveVersion
   );
   if (expectedEngineRevision !== void 0) {
-    const lineage = chunkBWQA3POT_cjs.resolveLineage(precondition.store);
+    const lineage = chunk6B3LQUYG_cjs.resolveLineage(precondition.store);
     if (lineage !== void 0) {
       const mismatch = await engineAnchorMismatch(
         lineage,
-        chunkBWQA3POT_cjs.storeBackend(precondition.store),
+        chunk6B3LQUYG_cjs.storeBackend(precondition.store),
         precondition.store.graphId,
         expectedEngineRevision
       );
@@ -9492,21 +9492,21 @@ async function assertForkPointUnchanged(precondition) {
   );
 }
 async function commitIncrementalPlan(target, plan, guard) {
-  if (!chunkBWQA3POT_cjs.storeBackend(target).capabilities.execution.interactiveTransactions) {
+  if (!chunk6B3LQUYG_cjs.storeBackend(target).capabilities.execution.interactiveTransactions) {
     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: "execution.interactiveTransactions" } }
     );
   }
   return runMergeCommit(
-    () => chunkJRWKRBI5_cjs.runRetriedUnit(
+    () => chunk5JOCIMQ3_cjs.runRetriedUnit(
       {
         operation: "commitIncrementalPlan",
         attempts: MERGE_COMMIT_ATTEMPTS,
-        target: chunkBWQA3POT_cjs.storeBackend(target)
+        target: chunk6B3LQUYG_cjs.storeBackend(target)
       },
       () => target.transaction(async (tx) => {
-        await lockMergeTargetWrite(chunkBWQA3POT_cjs.transactionBackend(tx), {
+        await lockMergeTargetWrite(chunk6B3LQUYG_cjs.transactionBackend(tx), {
           graphId: target.graphId,
           schemaVersion: target.introspect().schemaVersion,
           graphLock: target.revisionTrackingEnabled ? "required" : "not-required",
@@ -9524,12 +9524,12 @@ async function commitIncrementalPlan(target, plan, guard) {
         );
         await assertPlannedIdentityIdsFresh(
           target,
-          chunkBWQA3POT_cjs.transactionBackend(tx),
+          chunk6B3LQUYG_cjs.transactionBackend(tx),
           plan
         );
         await assertIdentityPeersStable(
           target,
-          chunkBWQA3POT_cjs.transactionBackend(tx),
+          chunk6B3LQUYG_cjs.transactionBackend(tx),
           guard.identityPeerProbe,
           plan
         );
@@ -9541,7 +9541,7 @@ async function commitIncrementalPlan(target, plan, guard) {
           nodesApi,
           edgesApi,
           target,
-          chunkBWQA3POT_cjs.transactionBackend(tx)
+          chunk6B3LQUYG_cjs.transactionBackend(tx)
         );
       }, mergeCommitTransactionOptions(target))
     )
@@ -9635,10 +9635,10 @@ var CandidateWriteSetSchema = zod.z.object({
   target: CandidateWriteSetTargetSchema,
   nodes: zod.z.array(candidateNodeSchema),
   edges: zod.z.array(candidateEdgeSchema),
-  identity: chunkXSLQYGNR_cjs.InterchangeIdentitySchema.optional()
+  identity: chunkT3VU3YRQ_cjs.InterchangeIdentitySchema.optional()
 });
 async function captureCandidateWriteSetTarget(target) {
-  const activeSchema = await chunkBWQA3POT_cjs.storeBackend(target).getActiveSchema(
+  const activeSchema = await chunk6B3LQUYG_cjs.storeBackend(target).getActiveSchema(
     target.graphId
   );
   return {
@@ -9728,7 +9728,7 @@ async function planCandidateWriteSet(args) {
   }
   const candidate = created.data;
   try {
-    const imported = await chunkXSLQYGNR_cjs.importGraph(
+    const imported = await chunkT3VU3YRQ_cjs.importGraph(
       candidate,
       interchangeDocument(writeSet),
       {
@@ -9828,7 +9828,7 @@ async function planCandidateWriteSetForEvolution(args) {
   }
   const candidate = created.data;
   try {
-    const imported = await chunkXSLQYGNR_cjs.importGraph(
+    const imported = await chunkT3VU3YRQ_cjs.importGraph(
       candidate,
       interchangeDocument(writeSet),
       {
@@ -9871,7 +9871,7 @@ async function planCandidateWriteSetForEvolution(args) {
 // src/graph-merge/review-evidence.ts
 function reviewJson(value) {
   if (value === void 0) return "undefined";
-  return JSON.stringify(value, chunkJRWKRBI5_cjs.sortedReplacer);
+  return JSON.stringify(value, chunk5JOCIMQ3_cjs.sortedReplacer);
 }
 async function reviewDigest(value) {
   return chunkZY4GXIVN_cjs.sha256Hex(reviewJson(value), 32);
@@ -9927,7 +9927,7 @@ function reviewRowKey(row) {
   return JSON.stringify([row.role, row.kind, row.id]);
 }
 async function captureReviewBaseline(target) {
-  const backend = chunkBWQA3POT_cjs.storeBackend(target);
+  const backend = chunk6B3LQUYG_cjs.storeBackend(target);
   const rows = [];
   for (const kind of chunk7D2ZLF4O_cjs.getNodeKinds(target.graph)) {
     for (const row of await enumerateAllNodes(backend, target.graphId, kind)) {
@@ -9949,7 +9949,7 @@ async function captureReviewBaseline(target) {
       });
     }
   }
-  const identity = await chunkBWQA3POT_cjs.storeRuntime(target).readCurrentIdentityAssertions(
+  const identity = await chunk6B3LQUYG_cjs.storeRuntime(target).readCurrentIdentityAssertions(
     "archival",
     {
       includeDeleted: true