@nicia-ai/typegraph 0.45.0 → 0.46.0

package/dist/graph-merge/index.cjs

@@ -1,47 +1,45 @@
 'use strict';
 
-var chunkYOALGKRE_cjs = require('../chunk-YOALGKRE.cjs');
-require('../chunk-F4NHQHEZ.cjs');
-var chunk6RYPD3NJ_cjs = require('../chunk-6RYPD3NJ.cjs');
-require('../chunk-UCQ3BFSY.cjs');
-var chunkJ7LXTUTP_cjs = require('../chunk-J7LXTUTP.cjs');
-require('../chunk-ZDH3DX3C.cjs');
-require('../chunk-CPEL3YIR.cjs');
-require('../chunk-EKFUG4G7.cjs');
-require('../chunk-EQ7JKLZO.cjs');
-var chunkZI6VQSZA_cjs = require('../chunk-ZI6VQSZA.cjs');
-var chunkTRF4EBJT_cjs = require('../chunk-TRF4EBJT.cjs');
-var chunkBNS75YNF_cjs = require('../chunk-BNS75YNF.cjs');
-require('../chunk-KKYELPZ2.cjs');
-var chunkACSVZPK7_cjs = require('../chunk-ACSVZPK7.cjs');
-require('../chunk-JQXSZHF2.cjs');
-var chunkQB6VMOJ2_cjs = require('../chunk-QB6VMOJ2.cjs');
-require('../chunk-ZTAJL4DT.cjs');
-require('../chunk-QR24DJDF.cjs');
-require('../chunk-5GAONX5G.cjs');
-require('../chunk-IX64T5OL.cjs');
+var chunkXDF2UPEQ_cjs = require('../chunk-XDF2UPEQ.cjs');
+require('../chunk-YAAM3M2S.cjs');
+var chunkONU3HIED_cjs = require('../chunk-ONU3HIED.cjs');
+require('../chunk-7GT72YHH.cjs');
+var chunkTTAITEPJ_cjs = require('../chunk-TTAITEPJ.cjs');
+var chunkN3257XE6_cjs = require('../chunk-N3257XE6.cjs');
+var chunkNK5Q7UNE_cjs = require('../chunk-NK5Q7UNE.cjs');
+var chunkXNLIZYRZ_cjs = require('../chunk-XNLIZYRZ.cjs');
+var chunkXMQSEJCF_cjs = require('../chunk-XMQSEJCF.cjs');
+var chunkPWLJ77UV_cjs = require('../chunk-PWLJ77UV.cjs');
+require('../chunk-BSFJMMV3.cjs');
+var chunkNFCVHQ5P_cjs = require('../chunk-NFCVHQ5P.cjs');
+var chunkXBYVV3MP_cjs = require('../chunk-XBYVV3MP.cjs');
+var chunkCXBHOOIQ_cjs = require('../chunk-CXBHOOIQ.cjs');
+var chunkE4WNQBEF_cjs = require('../chunk-E4WNQBEF.cjs');
+var chunkQ7Q4WSLJ_cjs = require('../chunk-Q7Q4WSLJ.cjs');
+require('../chunk-62ZP23AW.cjs');
+require('../chunk-XCAGZAKP.cjs');
+require('../chunk-U63GDNRC.cjs');
 var chunkZY4GXIVN_cjs = require('../chunk-ZY4GXIVN.cjs');
 require('../chunk-NAUA4PW5.cjs');
-require('../chunk-JXUTCSXX.cjs');
-require('../chunk-U5W4LKZV.cjs');
-require('../chunk-FJMPR3OH.cjs');
-require('../chunk-SJDMVITW.cjs');
-var chunk764JHTLT_cjs = require('../chunk-764JHTLT.cjs');
+require('../chunk-4UGOKMI5.cjs');
+var chunkVCRRKBLN_cjs = require('../chunk-VCRRKBLN.cjs');
+require('../chunk-7EO3TCQB.cjs');
+require('../chunk-RT5ZY4XA.cjs');
 require('../chunk-HAHNRASW.cjs');
-var chunkJ2ICGNHO_cjs = require('../chunk-J2ICGNHO.cjs');
-require('../chunk-SVJ5GEXW.cjs');
-require('../chunk-D54WH24V.cjs');
-require('../chunk-DI74SMXS.cjs');
-var chunkC4F7VJ5D_cjs = require('../chunk-C4F7VJ5D.cjs');
-require('../chunk-TDXIBCGY.cjs');
+var chunk7BQXPCGN_cjs = require('../chunk-7BQXPCGN.cjs');
+var chunkXUO3KQFO_cjs = require('../chunk-XUO3KQFO.cjs');
+require('../chunk-LBJKZXDE.cjs');
+var chunkNI72YOJB_cjs = require('../chunk-NI72YOJB.cjs');
+require('../chunk-A7J2YDDI.cjs');
+var chunkN66HCGCY_cjs = require('../chunk-N66HCGCY.cjs');
 var zod = require('zod');
 
 // src/graph-merge/canonical-props.ts
 function canonicalizeProps(props) {
-  return JSON.stringify(props, chunkACSVZPK7_cjs.sortedReplacer);
+  return JSON.stringify(props, chunkPWLJ77UV_cjs.sortedReplacer);
 }
 function canonicalValueKey(value) {
-  return JSON.stringify(value, chunkACSVZPK7_cjs.sortedReplacer);
+  return JSON.stringify(value, chunkPWLJ77UV_cjs.sortedReplacer);
 }
 function edgeStateSignature(edge) {
   return JSON.stringify([
@@ -102,8 +100,834 @@ function compareMergeKeys(left, right) {
   return leftKind < rightKind ? -1 : leftKind > rightKind ? 1 : 0;
 }
 
+// src/graph-merge/errors.ts
+var MERGE_ERROR_CODES = {
+  merge: "GRAPH_MERGE_ERROR",
+  invalidOptions: "GRAPH_MERGE_INVALID_OPTIONS",
+  branch: "GRAPH_MERGE_BRANCH_ERROR",
+  similarityUnavailable: "GRAPH_MERGE_SIMILARITY_UNAVAILABLE",
+  conflict: "GRAPH_MERGE_CONFLICT",
+  identityConflict: "GRAPH_MERGE_IDENTITY_CONFLICT",
+  baseVersionMismatch: "GRAPH_MERGE_BASE_VERSION_MISMATCH"
+};
+function toTypeGraphErrorOptions(category, options) {
+  return {
+    category,
+    ...options.details === void 0 ? {} : { details: options.details },
+    ...options.suggestion === void 0 ? {} : { suggestion: options.suggestion },
+    ...options.cause === void 0 ? {} : { cause: options.cause }
+  };
+}
+var MergeError = class extends chunkNI72YOJB_cjs.TypeGraphError {
+  static errorCategory = "system";
+  constructor(message, options = {}) {
+    const errorClass = new.target;
+    super(
+      message,
+      MERGE_ERROR_CODES.merge,
+      toTypeGraphErrorOptions(errorClass.errorCategory, options)
+    );
+    this.name = "MergeError";
+  }
+};
+var InvalidMergeOptionsError = class extends MergeError {
+  static errorCategory = "user";
+  code = MERGE_ERROR_CODES.invalidOptions;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "InvalidMergeOptionsError";
+  }
+};
+var BranchError = class extends chunkNI72YOJB_cjs.TypeGraphError {
+  constructor(message, options = {}) {
+    super(
+      message,
+      MERGE_ERROR_CODES.branch,
+      toTypeGraphErrorOptions("system", options)
+    );
+    this.name = "BranchError";
+  }
+};
+var SimilarityUnavailableError = class extends MergeError {
+  code = MERGE_ERROR_CODES.similarityUnavailable;
+  constructor(message, options = {}) {
+    super(message, {
+      ...options,
+      suggestion: options.suggestion ?? "Pass MergeOptions.embedder (a local model), or use a fulltext/custom similarity strategy."
+    });
+    this.name = "SimilarityUnavailableError";
+  }
+};
+var MergeConflictError = class extends MergeError {
+  code = MERGE_ERROR_CODES.conflict;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "MergeConflictError";
+  }
+};
+var IdentityMergeConflictError = class extends MergeError {
+  code = MERGE_ERROR_CODES.identityConflict;
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "IdentityMergeConflictError";
+  }
+};
+var BaseVersionMismatchError = class extends MergeError {
+  code = MERGE_ERROR_CODES.baseVersionMismatch;
+  constructor(message, options = {}) {
+    super(message, {
+      ...options,
+      suggestion: options.suggestion ?? "Re-branch from the current target so the branch base matches before merging."
+    });
+    this.name = "BaseVersionMismatchError";
+  }
+};
+function describeCause(cause) {
+  return cause instanceof Error ? cause.message : String(cause);
+}
+
+// src/graph-merge/union-find.ts
+var UnionFind = class {
+  constructor(compare) {
+    this.compare = compare;
+  }
+  compare;
+  parent = /* @__PURE__ */ new Map();
+  /** Adds `value` as its own singleton set if it is not already present. */
+  add(value) {
+    if (!this.parent.has(value)) {
+      this.parent.set(value, value);
+    }
+  }
+  /** Returns the representative of `value`'s set, compressing the path to it. */
+  find(value) {
+    this.add(value);
+    let root = value;
+    while (this.parent.get(root) !== root) {
+      root = chunkN66HCGCY_cjs.requireDefined(this.parent.get(root));
+    }
+    let cursor = value;
+    while (cursor !== root) {
+      const next = chunkN66HCGCY_cjs.requireDefined(this.parent.get(cursor));
+      this.parent.set(cursor, root);
+      cursor = next;
+    }
+    return root;
+  }
+  /** Merges the sets of `left` and `right`; the `compare`-minimal root wins. */
+  union(left, right) {
+    const leftRoot = this.find(left);
+    const rightRoot = this.find(right);
+    if (leftRoot === rightRoot) {
+      return;
+    }
+    if (this.compare(leftRoot, rightRoot) <= 0) {
+      this.parent.set(rightRoot, leftRoot);
+    } else {
+      this.parent.set(leftRoot, rightRoot);
+    }
+  }
+  /** Every value seen by {@link add}/{@link find}/{@link union}, insertion order. */
+  members() {
+    return [...this.parent.keys()];
+  }
+};
+
+// src/graph-merge/merge-identity.ts
+function endpointTuple(assertion) {
+  return [assertion.a.kind, assertion.a.id, assertion.b.kind, assertion.b.id];
+}
+function identityEndpointKey(assertion) {
+  return chunkXNLIZYRZ_cjs.encodeTupleKey(endpointTuple(assertion));
+}
+function identitySemanticKey(assertion) {
+  return chunkXNLIZYRZ_cjs.identityAssertionSemanticKey(
+    assertion.relation,
+    assertion.a,
+    assertion.b
+  );
+}
+function compareIdentitySurvivors(left, right) {
+  const byValidity = chunkXMQSEJCF_cjs.compareCodePoints(left.validFrom, right.validFrom);
+  return byValidity === 0 ? chunkXMQSEJCF_cjs.compareCodePoints(left.id, right.id) : byValidity;
+}
+var DUPLICATE_IDENTITY_ASSERTION_DROP_REASON = "identity:duplicate-assertion";
+var REDUNDANT_IDENTITY_ASSERTION_DROP_REASON = "identity:endpoints-collapsed";
+function droppedIdentityAssertion(assertion, reason) {
+  return { kind: "identity", id: assertion.id, reason };
+}
+function dedupeIdentityAssertions(assertions, committedIds) {
+  const survivorBySemantic = /* @__PURE__ */ new Map();
+  const dropped = [];
+  for (const assertion of assertions) {
+    const key = identitySemanticKey(assertion);
+    const previous = survivorBySemantic.get(key);
+    if (previous === void 0) {
+      survivorBySemantic.set(key, assertion);
+      continue;
+    }
+    const assertionCommitted = committedIds.has(assertion.id);
+    const previousCommitted = committedIds.has(previous.id);
+    const [survivor, loser] = assertionCommitted === previousCommitted ? compareIdentitySurvivors(assertion, previous) < 0 ? [assertion, previous] : [previous, assertion] : assertionCommitted ? [assertion, previous] : [previous, assertion];
+    survivorBySemantic.set(key, survivor);
+    if (loser.id === survivor.id && loser.validFrom === survivor.validFrom && (loser.validTo ?? void 0) === (survivor.validTo ?? void 0)) {
+      continue;
+    }
+    dropped.push(
+      droppedIdentityAssertion(loser, DUPLICATE_IDENTITY_ASSERTION_DROP_REASON)
+    );
+  }
+  return {
+    survivors: [...survivorBySemantic.values()].toSorted(
+      (left, right) => chunkXMQSEJCF_cjs.compareCodePoints(identitySemanticKey(left), identitySemanticKey(right))
+    ),
+    dropped
+  };
+}
+function assertNoOpposingIdentityRelations(assertions) {
+  const byEndpoint = /* @__PURE__ */ new Map();
+  for (const assertion of assertions) {
+    const key = identityEndpointKey(assertion);
+    const group = byEndpoint.get(key) ?? [];
+    group.push(assertion);
+    byEndpoint.set(key, group);
+  }
+  for (const [endpoint, group] of byEndpoint) {
+    if (new Set(group.map((assertion) => assertion.relation)).size < 2) {
+      continue;
+    }
+    throw new IdentityMergeConflictError(
+      "Branches asserted opposing identity relations for one endpoint pair.",
+      { details: { endpoint, assertions: group } }
+    );
+  }
+}
+function assertNoRetractReassertRace(staging) {
+  const retractedBySemantic = /* @__PURE__ */ new Map();
+  for (const staged of staging.retractedIdentityAssertions) {
+    const key = identitySemanticKey(staged.assertion);
+    const retractions = retractedBySemantic.get(key) ?? [];
+    retractions.push(staged);
+    retractedBySemantic.set(key, retractions);
+  }
+  for (const staged of staging.newIdentityAssertions) {
+    const retractions = retractedBySemantic.get(identitySemanticKey(staged.assertion)) ?? [];
+    const selfRetracted = retractions.some(
+      (retraction) => retraction.branchId === staged.branchId
+    );
+    if (selfRetracted) {
+      continue;
+    }
+    const crossBranchRetraction = retractions.find(
+      (retraction) => retraction.assertion.id !== staged.assertion.id
+    );
+    if (crossBranchRetraction !== void 0) {
+      throw new IdentityMergeConflictError(
+        "Branches contain a retract/reassert race for one identity pair.",
+        {
+          details: {
+            retractedAssertion: crossBranchRetraction.assertion,
+            retractedBy: crossBranchRetraction.branchId,
+            reassertedAssertion: staged.assertion,
+            reassertedBy: staged.branchId
+          }
+        }
+      );
+    }
+  }
+}
+var RETRACTION_TARGET_MISMATCH_DROP_REASON = "identity:retraction-target-mismatch";
+var RETRACTION_DELETION_OVERRULED_DROP_REASON = "identity:deletion-overruled";
+var NO_STORED_ASSERTIONS = /* @__PURE__ */ new Map();
+function planIdentityChanges(staging, storedIdentityRowsById) {
+  assertNoOpposingIdentityRelations(
+    staging.newIdentityAssertions.map((staged) => staged.assertion)
+  );
+  assertNoRetractReassertRace(staging);
+  assertOneIdOneTruth(
+    staging.newIdentityAssertions.map((staged) => staged.assertion),
+    NO_STORED_ASSERTIONS
+  );
+  const committedIds = new Set(
+    staging.newIdentityAssertions.map((staged) => staged.assertion).filter((assertion) => {
+      const stored = storedIdentityRowsById.get(assertion.id);
+      return stored !== void 0 && assertionTruthKey(stored) === assertionTruthKey(assertion);
+    }).map((assertion) => assertion.id)
+  );
+  const deduped = dedupeIdentityAssertions(
+    staging.newIdentityAssertions.map((staged) => staged.assertion),
+    committedIds
+  );
+  const retractionById = /* @__PURE__ */ new Map();
+  for (const staged of staging.retractedIdentityAssertions) {
+    const previous = retractionById.get(staged.assertion.id);
+    if (previous !== void 0 && assertionIdentityKey(previous) !== assertionIdentityKey(staged.assertion)) {
+      throw new IdentityMergeConflictError(
+        "One assertion id was staged for retraction with two different identity truths.",
+        {
+          details: {
+            assertionId: staged.assertion.id,
+            first: previous,
+            second: staged.assertion
+          }
+        }
+      );
+    }
+    retractionById.set(staged.assertion.id, staged.assertion);
+  }
+  const retractions = [];
+  const retractionDropped = [];
+  for (const [assertionId, retraction] of retractionById) {
+    const stored = storedIdentityRowsById.get(assertionId);
+    if (stored !== void 0 && stored.validTo === void 0 && assertionIdentityKey(stored) !== assertionIdentityKey(retraction)) {
+      retractionDropped.push({
+        kind: "identity",
+        id: assertionId,
+        reason: RETRACTION_TARGET_MISMATCH_DROP_REASON
+      });
+      continue;
+    }
+    retractions.push(retraction);
+  }
+  const survivingIds = new Set(
+    deduped.survivors.map((survivor) => survivor.id)
+  );
+  for (const retraction of retractions) {
+    if (survivingIds.has(retraction.id)) {
+      throw new IdentityMergeConflictError(
+        "One assertion id was staged as both a new assertion and a retraction.",
+        { details: { assertionId: retraction.id } }
+      );
+    }
+  }
+  return {
+    assertions: deduped.survivors,
+    retractions: retractions.toSorted(
+      (left, right) => chunkXMQSEJCF_cjs.compareCodePoints(left.id, right.id)
+    ),
+    dropped: [...deduped.dropped, ...retractionDropped]
+  };
+}
+function resolveIdentityEndpoint(endpoint, canonicalOf, retypeMap) {
+  const key = mergeKeyOf(endpoint);
+  const canonical = canonicalOf.get(key) ?? key;
+  return {
+    kind: retypeMap.get(canonical) ?? kindOf(canonical),
+    id: idOf(canonical)
+  };
+}
+function remapIdentityAssertionEndpoints(assertions, canonicalOf, retypeMap, storedRowsById) {
+  const remapped = [];
+  const dropped = [];
+  for (const assertion of assertions) {
+    const remappedA = resolveIdentityEndpoint(
+      assertion.a,
+      canonicalOf,
+      retypeMap
+    );
+    const remappedB = resolveIdentityEndpoint(
+      assertion.b,
+      canonicalOf,
+      retypeMap
+    );
+    if (mergeKeyOf(remappedA) === mergeKeyOf(remappedB)) {
+      if (assertion.relation === "different") {
+        throw new IdentityMergeConflictError(
+          "Node reconciliation collapsed a different-identity assertion onto one survivor.",
+          { details: { assertion, survivor: remappedA } }
+        );
+      }
+      dropped.push(
+        droppedIdentityAssertion(
+          assertion,
+          REDUNDANT_IDENTITY_ASSERTION_DROP_REASON
+        )
+      );
+      continue;
+    }
+    const [a, b] = chunkXNLIZYRZ_cjs.normalizeIdentityPair(remappedA, remappedB);
+    const result = { ...assertion, a, b };
+    const stored = storedRowsById.get(assertion.id);
+    if (stored !== void 0 && assertionTruthKey(stored) === assertionTruthKey(assertion) && assertionTruthKey(result) !== assertionTruthKey(assertion)) {
+      throw new IdentityMergeConflictError(
+        "Node reconciliation moved the endpoints of an assertion already committed on the target; committed identity rows cannot be rewritten by a merge.",
+        {
+          details: { assertionId: assertion.id, stored, remapped: result },
+          suggestion: "Exclude the colliding nodes from entity resolution, or manually retract the committed assertion and re-assert the canonical pair under a new id before merging."
+        }
+      );
+    }
+    remapped.push(result);
+  }
+  const committedIds = new Set(
+    remapped.filter((assertion) => {
+      const stored = storedRowsById.get(assertion.id);
+      return stored !== void 0 && assertionTruthKey(stored) === assertionTruthKey(assertion);
+    }).map((assertion) => assertion.id)
+  );
+  const deduped = dedupeIdentityAssertions(remapped, committedIds);
+  assertNoOpposingIdentityRelations(deduped.survivors);
+  return {
+    assertions: deduped.survivors,
+    dropped: [...dropped, ...deduped.dropped]
+  };
+}
+function assertIdentityEndpointsNotDeleted(assertions, nodeDeletions, retypeMap) {
+  const deletedIdentities = /* @__PURE__ */ new Set();
+  for (const key of nodeDeletions.keys()) {
+    deletedIdentities.add(key);
+    const retyped = retypeMap.get(key);
+    if (retyped !== void 0) {
+      deletedIdentities.add(mergeKey(retyped, idOf(key)));
+    }
+  }
+  for (const assertion of assertions) {
+    for (const endpoint of [assertion.a, assertion.b]) {
+      if (!deletedIdentities.has(mergeKeyOf(endpoint))) {
+        continue;
+      }
+      throw new IdentityMergeConflictError(
+        "A branch asserted an identity relation over a node another branch deleted.",
+        { details: { assertion, deletedEndpoint: endpoint } }
+      );
+    }
+  }
+}
+function assertNoContradictoryIdentityClosure(plannedAssertions, retractions, baseAssertions, deletedNodes, canonicalOf, retypeMap, identityContext, nodeUniverse) {
+  const retracted = new Set(retractions);
+  const survivesDeletion = (assertion) => !deletedNodes.has(mergeKey(assertion.a.kind, assertion.a.id)) && !deletedNodes.has(mergeKey(assertion.b.kind, assertion.b.id));
+  const mergedLedger = [
+    ...plannedAssertions,
+    ...baseAssertions.filter(
+      (assertion) => !retracted.has(assertion.id) && survivesDeletion(assertion)
+    ).map((assertion) => ({
+      ...assertion,
+      a: resolveIdentityEndpoint(assertion.a, canonicalOf, retypeMap),
+      b: resolveIdentityEndpoint(assertion.b, canonicalOf, retypeMap)
+    }))
+  ];
+  const sameClasses = new UnionFind(
+    (left, right) => compareMergeKeys(left, right)
+  );
+  for (const node of nodeUniverse) {
+    sameClasses.add(mergeKey(node.kind, node.id));
+  }
+  for (const assertion of mergedLedger) {
+    if (assertion.relation === "same") {
+      sameClasses.union(mergeKeyOf(assertion.a), mergeKeyOf(assertion.b));
+    }
+  }
+  const membersOfClass = (root) => sameClasses.members().filter((member) => sameClasses.find(member) === root).map((member) => ({ kind: kindOf(member), id: idOf(member) })).toSorted(
+    (left, right) => compareMergeKeys(mergeKeyOf(left), mergeKeyOf(right))
+  );
+  const firstDisjointPair = (kinds) => {
+    for (const [index, left] of kinds.entries()) {
+      for (const right of kinds.slice(index + 1)) {
+        if (identityContext.areDisjoint(left, right)) return [left, right];
+      }
+    }
+    return void 0;
+  };
+  const refsById = /* @__PURE__ */ new Map();
+  const addRef = (kind, id) => {
+    const keys = refsById.get(id) ?? [];
+    keys.push(mergeKey(kind, id));
+    refsById.set(id, keys);
+  };
+  for (const node of nodeUniverse) addRef(node.kind, node.id);
+  for (const assertion of mergedLedger) {
+    addRef(assertion.a.kind, assertion.a.id);
+    addRef(assertion.b.kind, assertion.b.id);
+  }
+  for (const keys of refsById.values()) {
+    const disjointKinds = firstDisjointPair([
+      ...new Set(keys.map((key) => kindOf(key)))
+    ]);
+    if (disjointKinds === void 0) continue;
+    throw new IdentityMergeConflictError(
+      "The merged graph would give one id to two ontology-disjoint kinds.",
+      {
+        details: {
+          disjointKinds,
+          sharedId: idOf(chunkN66HCGCY_cjs.requireDefined(keys[0]))
+        }
+      }
+    );
+  }
+  if (identityContext.sameIdAcrossKinds === "fold") {
+    for (const keys of refsById.values()) {
+      const [first, ...rest] = keys;
+      if (first === void 0) continue;
+      for (const other of rest) sameClasses.union(first, other);
+    }
+  }
+  for (const assertion of mergedLedger) {
+    if (assertion.relation !== "different") {
+      continue;
+    }
+    const root = sameClasses.find(mergeKeyOf(assertion.a));
+    if (root !== sameClasses.find(mergeKeyOf(assertion.b))) {
+      continue;
+    }
+    throw new IdentityMergeConflictError(
+      "The merged identity ledger would assert one pair of nodes is both the same and different.",
+      { details: { assertion, sameClass: membersOfClass(root) } }
+    );
+  }
+  const kindsByRoot = /* @__PURE__ */ new Map();
+  for (const member of sameClasses.members()) {
+    const root = sameClasses.find(member);
+    const kinds = kindsByRoot.get(root) ?? /* @__PURE__ */ new Set();
+    kinds.add(kindOf(member));
+    kindsByRoot.set(root, kinds);
+  }
+  for (const [root, kinds] of kindsByRoot) {
+    const disjointKinds = firstDisjointPair([...kinds]);
+    if (disjointKinds === void 0) continue;
+    throw new IdentityMergeConflictError(
+      "The merged identity ledger would join two ontology-disjoint kinds into one class.",
+      { details: { disjointKinds, sameClass: membersOfClass(root) } }
+    );
+  }
+}
+async function buildIdentityPeerProbe(target, probedIds, targetPeers, plan, profile) {
+  const finalIds = /* @__PURE__ */ new Set([
+    ...plan.canonicalEntities.filter(
+      (entity) => !plan.nodeDeletions.has(mergeKey(entity.kind, entity.canonicalId))
+    ).map((entity) => entity.canonicalId),
+    ...plan.identityAssertions.flatMap((assertion) => [
+      assertion.a.id,
+      assertion.b.id
+    ])
+  ]);
+  const plannedDeletions = new Set(plan.nodeDeletions.keys());
+  const relevantPeers = targetPeers.filter(
+    (peer) => finalIds.has(peer.id) && !plannedDeletions.has(mergeKey(peer.kind, peer.id))
+  );
+  const seedsByKey = /* @__PURE__ */ new Map();
+  const addSeed = (kind, id) => {
+    seedsByKey.set(mergeKey(kind, id), { kind, id });
+  };
+  for (const entity of plan.canonicalEntities) {
+    const sourceKey = mergeKey(entity.kind, entity.canonicalId);
+    if (plan.nodeDeletions.has(sourceKey)) continue;
+    addSeed(plan.retypeMap.get(sourceKey) ?? entity.kind, entity.canonicalId);
+  }
+  for (const assertion of plan.identityAssertions) {
+    addSeed(assertion.a.kind, assertion.a.id);
+    addSeed(assertion.b.kind, assertion.b.id);
+  }
+  for (const peer of relevantPeers) addSeed(peer.kind, peer.id);
+  const seeds = [...seedsByKey.values()];
+  const liveKeys = new Set(
+    targetPeers.map((peer) => mergeKey(peer.kind, peer.id)).filter((key) => !plannedDeletions.has(key))
+  );
+  const snapshot = await snapshotIdentityClasses(
+    target,
+    seeds,
+    liveKeys,
+    plannedDeletions
+  );
+  const memberKeys = /* @__PURE__ */ new Set([
+    ...seeds.map((seed) => mergeKey(seed.kind, seed.id)),
+    ...snapshot.groups.flatMap(
+      (group) => group.map((member) => mergeKey(member.kind, member.id))
+    )
+  ]);
+  const ledger = (await relevantLedgerAssertions(target, memberKeys, chunkTTAITEPJ_cjs.storeBackend(target))).filter(
+    (assertion) => !plannedDeletions.has(mergeKey(assertion.a.kind, assertion.a.id)) && !plannedDeletions.has(mergeKey(assertion.b.kind, assertion.b.id))
+  );
+  return {
+    probe: {
+      profile,
+      plannedDeletions,
+      ids: probedIds.filter((id) => finalIds.has(id)),
+      observed: new Set(
+        relevantPeers.map((peer) => mergeKey(peer.kind, peer.id))
+      ),
+      memberKeys,
+      differentFingerprint: differentLedgerFingerprint(ledger),
+      classFingerprints: snapshot.fingerprints,
+      seeds
+    },
+    snapshot,
+    ledger
+  };
+}
+async function snapshotIdentityClasses(target, seeds, liveKeys, plannedDeletions, txBackend) {
+  const classes = await chunkTTAITEPJ_cjs.storeRuntime(target).structuralIdentityClasses(
+    seeds,
+    txBackend
+  );
+  const fingerprints = /* @__PURE__ */ new Map();
+  const groups = [];
+  for (const seed of seeds) {
+    const key = mergeKey(seed.kind, seed.id);
+    const members = (classes.get(chunkXNLIZYRZ_cjs.identityReferenceKey(seed)) ?? [seed]).filter(
+      (member) => !plannedDeletions.has(mergeKey(member.kind, member.id))
+    );
+    groups.push(members);
+    fingerprints.set(key, encodeClassFingerprint(liveKeys.has(key), members));
+  }
+  return { fingerprints, groups };
+}
+async function relevantLedgerAssertions(target, memberKeys, backend) {
+  const current = await chunkTTAITEPJ_cjs.storeRuntime(target).identityAssertionsAtTarget(
+    backend,
+    "state"
+  );
+  return current.filter(
+    (assertion) => memberKeys.has(mergeKey(assertion.a.kind, assertion.a.id)) || memberKeys.has(mergeKey(assertion.b.kind, assertion.b.id))
+  );
+}
+function differentLedgerFingerprint(assertions) {
+  return JSON.stringify(
+    assertions.filter((assertion) => assertion.relation === "different").map((assertion) => [assertion.id, ...endpointTuple(assertion)]).toSorted(
+      (left, right) => chunkXMQSEJCF_cjs.compareStrings(chunkXNLIZYRZ_cjs.encodeTupleKey(left), chunkXNLIZYRZ_cjs.encodeTupleKey(right))
+    )
+  );
+}
+function encodeClassFingerprint(live, members) {
+  return JSON.stringify([
+    live,
+    members.map((member) => [member.kind, member.id]).toSorted(
+      ([leftKind, leftId], [rightKind, rightId]) => compareMergeKeys(
+        mergeKey(leftKind, leftId),
+        mergeKey(rightKind, rightId)
+      )
+    )
+  ]);
+}
+function assertionTruthKey(assertion) {
+  return JSON.stringify([
+    assertion.relation,
+    ...endpointTuple(assertion),
+    assertion.validFrom,
+    assertion.validTo ?? null
+  ]);
+}
+function assertionIdentityKey(assertion) {
+  return JSON.stringify([
+    assertion.relation,
+    ...endpointTuple(assertion),
+    assertion.validFrom
+  ]);
+}
+function assertOneIdOneTruth(planned, storedById) {
+  const plannedById = /* @__PURE__ */ new Map();
+  for (const assertion of planned) {
+    const previous = plannedById.get(assertion.id);
+    if (previous !== void 0 && assertionTruthKey(previous) !== assertionTruthKey(assertion)) {
+      throw new IdentityMergeConflictError(
+        "One assertion id was staged for two different identity truths.",
+        {
+          details: {
+            assertionId: assertion.id,
+            first: previous,
+            second: assertion
+          }
+        }
+      );
+    }
+    plannedById.set(assertion.id, assertion);
+    const stored = storedById.get(assertion.id);
+    if (stored !== void 0 && assertionTruthKey(stored) !== assertionTruthKey(assertion)) {
+      throw new IdentityMergeConflictError(
+        "A staged assertion id already identifies different truth in the target ledger.",
+        { details: { assertionId: assertion.id, staged: assertion, stored } }
+      );
+    }
+  }
+}
+async function assertPlannedIdentityIdsFresh(target, txBackend, plan) {
+  const plannedIds = [
+    ...plan.identityAssertions.map((assertion) => assertion.id),
+    ...plan.identityRetractions.map((retraction) => retraction.id)
+  ];
+  if (plannedIds.length === 0) return;
+  const storedById = await chunkTTAITEPJ_cjs.storeRuntime(target).identityAssertionRowsByIds(
+    plannedIds,
+    txBackend
+  );
+  for (const assertion of plan.identityAssertions) {
+    const stored = storedById.get(assertion.id);
+    if (stored !== void 0 && assertionTruthKey(stored) !== assertionTruthKey(assertion)) {
+      throw new BaseVersionMismatchError(
+        "The merge validated its assertion ids as of planning, but a row identifying different truth under a planned id was committed before the commit transaction.",
+        {
+          details: { assertionId: assertion.id },
+          suggestion: "Retry the merge \u2014 the plan is recomputed from current state. A persistent refusal means the branch's assertion id conflicts with target truth and needs manual resolution."
+        }
+      );
+    }
+  }
+  for (const retraction of plan.identityRetractions) {
+    const stored = storedById.get(retraction.id);
+    if (stored !== void 0 && stored.validTo === void 0 && assertionIdentityKey(stored) !== assertionIdentityKey(retraction)) {
+      throw new BaseVersionMismatchError(
+        "The merge validated each planned retraction against the target row its id identified at planning, but that row's truth changed before the commit transaction.",
+        {
+          details: { assertionId: retraction.id },
+          suggestion: "Retry the merge \u2014 the plan is recomputed from current state."
+        }
+      );
+    }
+  }
+}
+function affectedIdentityClassSeeds(plan, profile) {
+  const seedsByKey = /* @__PURE__ */ new Map();
+  const addSeed = (kind, id) => {
+    const key = mergeKey(kind, id);
+    if (plan.nodeDeletions.has(key)) return;
+    seedsByKey.set(key, { kind, id });
+  };
+  for (const assertion of [
+    ...plan.identityAssertions,
+    ...plan.identityRetractions
+  ]) {
+    addSeed(assertion.a.kind, assertion.a.id);
+    addSeed(assertion.b.kind, assertion.b.id);
+  }
+  if (profile === "fold") {
+    for (const entity of plan.canonicalEntities) {
+      const sourceKey = mergeKey(entity.kind, entity.canonicalId);
+      if (plan.nodeDeletions.has(sourceKey)) continue;
+      addSeed(plan.retypeMap.get(sourceKey) ?? entity.kind, entity.canonicalId);
+    }
+  }
+  return [...seedsByKey.values()];
+}
+async function assertMergedIdentityClassesConsistent(target, txBackend, plan) {
+  await chunkTTAITEPJ_cjs.storeRuntime(target).assertIdentityClassesConsistentAtTarget(
+    txBackend,
+    affectedIdentityClassSeeds(plan, target.graph.identity?.sameIdAcrossKinds)
+  );
+}
+var IDENTITY_ENVIRONMENT_CODES = /* @__PURE__ */ new Set([
+  "IDENTITY_MERGE_REQUIRES_PROFILE",
+  "IDENTITY_REQUIRES_ATOMIC_BACKEND",
+  "IDENTITY_REQUIRES_STATEMENT_EXECUTION",
+  "IDENTITY_BIND_BUDGET_TOO_SMALL",
+  // Environment/corruption statements — translating one into "re-plan against
+  // the current target" would be advice that can never succeed. The applier
+  // reaches the last two through the current different-ness probe (see
+  // `identity/separation`), which refuses rather than guessing when the derived
+  // separation relation is missing or disagrees with the ledger.
+  "IDENTITY_NOT_ENABLED",
+  "IDENTITY_STORAGE_MISSING",
+  "IDENTITY_SCHEMA_CONTRADICTION",
+  "IDENTITY_IMPORT_REQUIRES_PROFILE"
+]);
+function identityRefusalCode(error) {
+  const detailCode = error.details["code"];
+  if (typeof detailCode === "string" && detailCode.startsWith("IDENTITY_")) {
+    return detailCode;
+  }
+  if (error.code.startsWith("IDENTITY_")) return error.code;
+  const issues = error.details["issues"];
+  if (Array.isArray(issues)) {
+    for (const issue of issues) {
+      const code = issue["code"];
+      if (typeof code === "string" && code.startsWith("IDENTITY_")) {
+        return code;
+      }
+    }
+  }
+  return void 0;
+}
+function translateIdentityCommitError(error) {
+  if (error instanceof MergeError) return error;
+  if (!(error instanceof chunkNI72YOJB_cjs.TypeGraphError)) return error;
+  const identityCode = identityRefusalCode(error);
+  const identityRefusal = error instanceof chunkNI72YOJB_cjs.IdentityContradictionError || error instanceof chunkNI72YOJB_cjs.NodeNotFoundError || identityCode !== void 0 && !IDENTITY_ENVIRONMENT_CODES.has(identityCode);
+  if (!identityRefusal) return error;
+  return new IdentityMergeConflictError(
+    `The identity applier refused the resolved plan inside the commit transaction \u2014 identity truth on the target is incompatible with the plan. Cause: ${describeCause(error)}`,
+    {
+      cause: error,
+      details: { ...identityCode === void 0 ? {} : { identityCode } },
+      suggestion: "Retry once \u2014 the plan is recomputed from current state. If the refusal persists, the branches' identity truth conflicts with the target and needs manual resolution (change the branch's assertion, or resolve the target's truth first)."
+    }
+  );
+}
+async function assertIdentityPeersStable(target, txBackend, probe, plan) {
+  if (probe === void 0) return;
+  const live = (await chunkTTAITEPJ_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();
+    kinds.add(seed.kind);
+    seedKindsById.set(seed.id, kinds);
+  }
+  const appeared = live.filter(
+    (peer) => probe.profile === "fold" || [...seedKindsById.get(peer.id) ?? []].some(
+      (kind) => target.registry.areDisjoint(peer.kind, kind)
+    )
+  ).map((peer) => mergeKey(peer.kind, peer.id)).filter((key) => !probe.observed.has(key)).sort((left, right) => compareMergeKeys(left, right));
+  if (appeared.length > 0) {
+    throw new BaseVersionMismatchError(
+      `mergeIncremental() simulated identity folding against the target's live same-id peers as of planning, but ${appeared.length} committed row(s) sharing a planned node's id appeared before the commit transaction. Committing the plan could fold nodes into classes the plan never validated.`,
+      { details: { appeared } }
+    );
+  }
+  const { fingerprints: liveFingerprints, groups: liveGroups } = await snapshotIdentityClasses(
+    target,
+    probe.seeds,
+    new Set(live.map((peer) => mergeKey(peer.kind, peer.id))),
+    probe.plannedDeletions,
+    txBackend
+  );
+  const drifted = [...probe.classFingerprints].filter(([key, fingerprint]) => liveFingerprints.get(key) !== fingerprint).map(([key]) => key).sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right));
+  if (drifted.length > 0) {
+    throw new BaseVersionMismatchError(
+      `mergeIncremental() validated identity against the classes visible at planning, but the identity class of ${drifted.length} node(s) the plan folds on changed before the commit transaction. Committing the plan could contradict identity truth it never validated.`,
+      { details: { drifted } }
+    );
+  }
+  const ledger = (await relevantLedgerAssertions(target, probe.memberKeys, txBackend)).filter(
+    (assertion) => !probe.plannedDeletions.has(mergeKey(assertion.a.kind, assertion.a.id)) && !probe.plannedDeletions.has(mergeKey(assertion.b.kind, assertion.b.id))
+  );
+  if (differentLedgerFingerprint(ledger) !== probe.differentFingerprint) {
+    throw new BaseVersionMismatchError(
+      "mergeIncremental() validated identity against the `different` assertions visible at planning, but that ledger changed before the commit transaction. Committing the plan could contradict identity truth it never validated.",
+      { details: {} }
+    );
+  }
+  try {
+    assertNoContradictoryIdentityClosure(
+      plan.identityAssertions,
+      plan.identityRetractions.map((retraction) => retraction.id),
+      ledger,
+      probe.plannedDeletions,
+      plan.canonicalOf,
+      plan.retypeMap,
+      {
+        sameIdAcrossKinds: probe.profile,
+        areDisjoint: (left, right) => target.registry.areDisjoint(left, right)
+      },
+      [...probe.seeds, ...liveGroups.flat()]
+    );
+  } catch (error) {
+    if (!(error instanceof IdentityMergeConflictError)) throw error;
+    throw new BaseVersionMismatchError(
+      "mergeIncremental() validated identity as of planning, but identity truth committed before the commit transaction invalidates the plan. Re-plan against the current target.",
+      { details: { conflict: error.message } }
+    );
+  }
+}
+
 // src/graph-merge/state-diff.ts
 var ENUMERATION_PAGE_SIZE = 1e3;
+var EXPLICIT_RETRACTION = { kind: "explicit" };
+function validWindowOf(row) {
+  return {
+    validFrom: chunkQ7Q4WSLJ_cjs.canonicalizeDatabaseTimestamp(row.valid_from),
+    validTo: chunkQ7Q4WSLJ_cjs.canonicalizeDatabaseTimestamp(row.valid_to)
+  };
+}
+function windowsDiffer(left, right) {
+  return left.validFrom !== right.validFrom || left.validTo !== right.validTo;
+}
 async function enumerateAllNodes(backend, graphId, kind) {
   const collected = [];
   let after;
@@ -122,7 +946,7 @@ async function enumerateAllNodes(backend, graphId, kind) {
     if (page.length < ENUMERATION_PAGE_SIZE) {
       break;
     }
-    after = chunk764JHTLT_cjs.requireDefined(page.at(-1)).id;
+    after = chunkN66HCGCY_cjs.requireDefined(page.at(-1)).id;
   }
   return collected;
 }
@@ -144,7 +968,7 @@ async function enumerateAllEdges(backend, graphId, kind) {
     if (page.length < ENUMERATION_PAGE_SIZE) {
       break;
     }
-    after = chunk764JHTLT_cjs.requireDefined(page.at(-1)).id;
+    after = chunkN66HCGCY_cjs.requireDefined(page.at(-1)).id;
   }
   return collected;
 }
@@ -164,6 +988,7 @@ function diffNodeKind(kind, baseRows, forkRows) {
   const created = [];
   const modified = [];
   const deleted = [];
+  const windowed = [];
   for (const forkRow of forkRows) {
     if (!isLive(forkRow)) {
       continue;
@@ -189,6 +1014,16 @@ function diffNodeKind(kind, baseRows, forkRows) {
         row: forkRow
       });
     }
+    const baseWindow = validWindowOf(baseRow);
+    const forkWindow = validWindowOf(forkRow);
+    if (windowsDiffer(baseWindow, forkWindow)) {
+      windowed.push({
+        id: forkRow.id,
+        kind,
+        base: baseWindow,
+        fork: forkWindow
+      });
+    }
   }
   for (const baseRow of baseRows) {
     if (!isLive(baseRow)) {
@@ -196,10 +1031,14 @@ function diffNodeKind(kind, baseRows, forkRows) {
     }
     const forkRow = forkIndex.get(baseRow.id);
     if (forkRow === void 0 || !isLive(forkRow)) {
-      deleted.push({ id: baseRow.id, kind });
+      deleted.push({
+        id: baseRow.id,
+        kind,
+        deletedAt: forkRow === void 0 ? void 0 : chunkQ7Q4WSLJ_cjs.canonicalizeDatabaseTimestamp(forkRow.deleted_at)
+      });
     }
   }
-  return { new: created, modified, deleted };
+  return { new: created, modified, deleted, windowed };
 }
 function diffEdgeKind(kind, baseRows, forkRows) {
   const baseIndex = indexById(baseRows);
@@ -207,6 +1046,7 @@ function diffEdgeKind(kind, baseRows, forkRows) {
   const created = [];
   const modified = [];
   const deleted = [];
+  const windowed = [];
   for (const forkRow of forkRows) {
     if (!isLive(forkRow)) {
       continue;
@@ -240,6 +1080,22 @@ function diffEdgeKind(kind, baseRows, forkRows) {
         row: forkRow
       });
     }
+    const baseWindow = validWindowOf(baseRow);
+    const forkWindow = validWindowOf(forkRow);
+    if (windowsDiffer(baseWindow, forkWindow)) {
+      windowed.push({
+        id: forkRow.id,
+        kind,
+        fromId: forkRow.from_id,
+        toId: forkRow.to_id,
+        fromKind: forkRow.from_kind,
+        toKind: forkRow.to_kind,
+        props: forkProps,
+        baseProps,
+        base: baseWindow,
+        fork: forkWindow
+      });
+    }
   }
   for (const baseRow of baseRows) {
     if (!isLive(baseRow)) {
@@ -250,27 +1106,82 @@ function diffEdgeKind(kind, baseRows, forkRows) {
       deleted.push({ id: baseRow.id, kind });
     }
   }
-  return { new: created, modified, deleted };
+  return { new: created, modified, deleted, windowed };
+}
+function classifyRetraction(assertion, deletedByKey, forkAssertion) {
+  if (forkAssertion !== void 0) {
+    const stamp = forkAssertion.endedBy;
+    if (stamp !== void 0 && deletedByKey.has(mergeKey(stamp.kind, stamp.id))) {
+      return { kind: "cascade", deletedNode: { ...stamp } };
+    }
+    return EXPLICIT_RETRACTION;
+  }
+  for (const endpoint of [assertion.a, assertion.b]) {
+    const deletion = deletedByKey.get(mergeKey(endpoint.kind, endpoint.id));
+    if (deletion !== void 0 && deletion.deletedAt === void 0) {
+      return {
+        kind: "cascade",
+        deletedNode: { kind: deletion.kind, id: deletion.id }
+      };
+    }
+  }
+  return EXPLICIT_RETRACTION;
+}
+async function classifyRetractions(forkStore, retracted, deletedNodes) {
+  if (retracted.length === 0 || deletedNodes.length === 0) {
+    return retracted.map((assertion) => ({
+      assertion,
+      cause: EXPLICIT_RETRACTION
+    }));
+  }
+  const deletedByKey = new Map(
+    deletedNodes.map((deletion) => [
+      mergeKey(deletion.kind, deletion.id),
+      deletion
+    ])
+  );
+  const forkRowsById = await chunkTTAITEPJ_cjs.storeRuntime(forkStore).identityAssertionRowsByIds(
+    retracted.map((assertion) => assertion.id)
+  );
+  return retracted.map((assertion) => ({
+    assertion,
+    cause: classifyRetraction(
+      assertion,
+      deletedByKey,
+      forkRowsById.get(assertion.id)
+    )
+  }));
 }
 function byId(left, right) {
-  return chunkTRF4EBJT_cjs.compareStrings(left.id, right.id);
+  return chunkXMQSEJCF_cjs.compareStrings(left.id, right.id);
 }
 async function diffAgainstBase(baseStore, forkStore, captureForkState = true) {
   const graph = baseStore.graph;
-  const nodeKinds = chunkQB6VMOJ2_cjs.getNodeKinds(graph);
-  const edgeKinds = chunkQB6VMOJ2_cjs.getEdgeKinds(graph);
+  const nodeKinds = chunkCXBHOOIQ_cjs.getNodeKinds(graph);
+  const edgeKinds = chunkCXBHOOIQ_cjs.getEdgeKinds(graph);
+  const [baseIdentity, forkIdentity] = await Promise.all([
+    chunkTTAITEPJ_cjs.storeRuntime(baseStore).readCurrentIdentityAssertions("state"),
+    chunkTTAITEPJ_cjs.storeRuntime(forkStore).readCurrentIdentityAssertions("state")
+  ]);
+  const baseIdentityById = new Map(
+    baseIdentity.map((assertion) => [assertion.id, assertion])
+  );
+  const forkIdentityById = new Map(
+    forkIdentity.map((assertion) => [assertion.id, assertion])
+  );
   const newNodes = [];
   const modifiedNodes = [];
   const deletedNodes = [];
+  const windowedNodes = [];
   const forkNodeVersions = /* @__PURE__ */ new Map();
   for (const kind of nodeKinds) {
     const baseRows = await enumerateAllNodes(
-      chunkJ7LXTUTP_cjs.storeBackend(baseStore),
+      chunkTTAITEPJ_cjs.storeBackend(baseStore),
       baseStore.graphId,
       kind
     );
     const forkRows = await enumerateAllNodes(
-      chunkJ7LXTUTP_cjs.storeBackend(forkStore),
+      chunkTTAITEPJ_cjs.storeBackend(forkStore),
       forkStore.graphId,
       kind
     );
@@ -289,19 +1200,23 @@ async function diffAgainstBase(baseStore, forkStore, captureForkState = true) {
     for (const entry of delta.deleted) {
       deletedNodes.push(entry);
     }
+    for (const entry of delta.windowed) {
+      windowedNodes.push(entry);
+    }
   }
   const newEdges = [];
   const modifiedEdges = [];
   const deletedEdges = [];
+  const windowedEdges = [];
   const forkEdgeSignatures = /* @__PURE__ */ new Map();
   for (const kind of edgeKinds) {
     const baseRows = await enumerateAllEdges(
-      chunkJ7LXTUTP_cjs.storeBackend(baseStore),
+      chunkTTAITEPJ_cjs.storeBackend(baseStore),
       baseStore.graphId,
       kind
     );
     const forkRows = await enumerateAllEdges(
-      chunkJ7LXTUTP_cjs.storeBackend(forkStore),
+      chunkTTAITEPJ_cjs.storeBackend(forkStore),
       forkStore.graphId,
       kind
     );
@@ -330,17 +1245,46 @@ async function diffAgainstBase(baseStore, forkStore, captureForkState = true) {
     for (const entry of delta.deleted) {
       deletedEdges.push(entry);
     }
+    for (const entry of delta.windowed) {
+      windowedEdges.push(entry);
+    }
   }
+  const retractedAssertions = baseIdentity.filter((assertion) => {
+    const fork = forkIdentityById.get(assertion.id);
+    return fork === void 0 || assertionTruthKey(fork) !== assertionTruthKey(assertion);
+  }).toSorted((left, right) => chunkXMQSEJCF_cjs.compareStrings(left.id, right.id));
+  const classifiedRetractions = await classifyRetractions(
+    forkStore,
+    retractedAssertions,
+    deletedNodes
+  );
   return {
     nodes: {
       new: newNodes.sort((left, right) => byId(left, right)),
       modified: modifiedNodes.sort((left, right) => byId(left, right)),
-      deleted: deletedNodes.sort((left, right) => byId(left, right))
+      deleted: deletedNodes.sort((left, right) => byId(left, right)),
+      windowed: windowedNodes.sort((left, right) => byId(left, right))
     },
     edges: {
       new: newEdges.sort((left, right) => byId(left, right)),
       modified: modifiedEdges.sort((left, right) => byId(left, right)),
-      deleted: deletedEdges.sort((left, right) => byId(left, right))
+      deleted: deletedEdges.sort((left, right) => byId(left, right)),
+      windowed: windowedEdges.sort((left, right) => byId(left, right))
+    },
+    identity: {
+      // Ids present on BOTH sides are compared by COMPLETE truth, not
+      // presence: a fork can hard-delete an assertion's endpoint (physically
+      // removing the row), recreate it, and legally import the same id for
+      // different truth. Presence-only comparison would diff that replacement
+      // as empty and the merge would silently keep the base truth. A shared
+      // id with changed truth surfaces as BOTH retracted (the base row) and
+      // new (the fork row), so planning sees the replacement and can refuse
+      // unsupported id reuse as a typed conflict.
+      new: forkIdentity.filter((assertion) => {
+        const base = baseIdentityById.get(assertion.id);
+        return base === void 0 || assertionTruthKey(base) !== assertionTruthKey(assertion);
+      }).toSorted((left, right) => chunkXMQSEJCF_cjs.compareStrings(left.id, right.id)),
+      retracted: classifiedRetractions
     },
     forkNodeVersions,
     forkEdgeSignatures
@@ -354,9 +1298,11 @@ function asBranchId(value) {
 function asBaseVersion(value) {
   return value;
 }
+var VALIDITY_END_TARGET_PRECEDENCE = "target";
 
 // src/graph-merge/base-version.ts
 var TOKEN_SEPARATOR = "\0";
+var SCHEMA_VERSION_TAG = "#s";
 var REVISION_COMPONENT_PREFIX = "revision:";
 var REVISION_COMPONENT_SEPARATOR = ":";
 var INITIAL_REVISION = "initial";
@@ -367,19 +1313,19 @@ async function readActiveSchemaVersion(backend, graphId) {
 }
 async function computeSchemaComponent(store) {
   const version = await readActiveSchemaVersion(
-    chunkJ7LXTUTP_cjs.storeBackend(store),
+    chunkTTAITEPJ_cjs.storeBackend(store),
     store.graphId
   );
-  return chunkZI6VQSZA_cjs.computeSchemaHash(chunkZI6VQSZA_cjs.serializeSchema(store.graph, version));
+  return chunkN3257XE6_cjs.computeSchemaHash(chunkN3257XE6_cjs.serializeSchema(store.graph, version));
 }
 function byDigestEntry(left, right) {
-  const byKind = chunkTRF4EBJT_cjs.compareStrings(left.kind, right.kind);
-  return byKind === 0 ? chunkTRF4EBJT_cjs.compareStrings(left.id, right.id) : byKind;
+  const byKind = chunkXMQSEJCF_cjs.compareStrings(left.kind, right.kind);
+  return byKind === 0 ? chunkXMQSEJCF_cjs.compareStrings(left.id, right.id) : byKind;
 }
 var CONTENT_FINGERPRINT_BYTES = 16;
-async function computeContentComponent(backend, graphId, graph) {
-  const nodeKinds = chunkQB6VMOJ2_cjs.getNodeKinds(graph);
-  const edgeKinds = chunkQB6VMOJ2_cjs.getEdgeKinds(graph);
+async function computeContentComponent(backend, graphId, graph, identityAssertions) {
+  const nodeKinds = chunkCXBHOOIQ_cjs.getNodeKinds(graph);
+  const edgeKinds = chunkCXBHOOIQ_cjs.getEdgeKinds(graph);
   const nodeDigest = [];
   for (const kind of nodeKinds) {
     const rows = await enumerateAllNodes(backend, graphId, kind);
@@ -417,30 +1363,41 @@ async function computeContentComponent(backend, graphId, graph) {
   return chunkZY4GXIVN_cjs.sha256Hex(
     canonicalizeProps({
       nodes: nodeDigest.sort((left, right) => byDigestEntry(left, right)),
-      edges: edgeDigest.sort((left, right) => byDigestEntry(left, right))
+      edges: edgeDigest.sort((left, right) => byDigestEntry(left, right)),
+      ...identityAssertions.length === 0 ? {} : { identity: identityAssertions }
     }),
     CONTENT_FINGERPRINT_BYTES
   );
 }
 async function computeBaseVersion(store) {
   if (store.revisionTrackingEnabled) {
-    const [schemaComponent2, origin, revision] = await Promise.all([
+    const [schemaComponent2, origin, revision, activeVersion] = await Promise.all([
       computeSchemaComponent(store),
       store.revisionOriginNow(),
-      store.revisionNow()
+      store.revisionNow(),
+      readActiveSchemaVersion(chunkTTAITEPJ_cjs.storeBackend(store), store.graphId)
     ]);
     return asBaseVersion(
-      `${schemaComponent2}${TOKEN_SEPARATOR}${revisionComponent(origin, revision)}`
+      `${schemaComponent2}${SCHEMA_VERSION_TAG}${activeVersion}${TOKEN_SEPARATOR}${revisionComponent(origin, revision)}`
     );
   }
   const [schemaComponent, contentComponent] = await Promise.all([
     computeSchemaComponent(store),
-    computeContentComponent(chunkJ7LXTUTP_cjs.storeBackend(store), store.graphId, store.graph)
+    computeStoreContentComponent(store)
   ]);
   return asBaseVersion(
     `${schemaComponent}${TOKEN_SEPARATOR}${contentComponent}`
   );
 }
+async function computeStoreContentComponent(store) {
+  const identityAssertions = await chunkTTAITEPJ_cjs.storeRuntime(store).readCurrentIdentityAssertions("state");
+  return computeContentComponent(
+    chunkTTAITEPJ_cjs.storeBackend(store),
+    store.graphId,
+    store.graph,
+    identityAssertions
+  );
+}
 function revisionComponent(origin, revision) {
   return `${REVISION_COMPONENT_PREFIX}${origin}${REVISION_COMPONENT_SEPARATOR}${revision ?? INITIAL_REVISION}`;
 }
@@ -470,70 +1427,6 @@ function contentComponentOf(version) {
   return separatorIndex === -1 ? version : version.slice(separatorIndex + 1);
 }
 
-// src/graph-merge/errors.ts
-var MERGE_ERROR_CODES = {
-  merge: "GRAPH_MERGE_ERROR",
-  branch: "GRAPH_MERGE_BRANCH_ERROR",
-  similarityUnavailable: "GRAPH_MERGE_SIMILARITY_UNAVAILABLE",
-  conflict: "GRAPH_MERGE_CONFLICT",
-  baseVersionMismatch: "GRAPH_MERGE_BASE_VERSION_MISMATCH"
-};
-function toTypeGraphErrorOptions(category, options) {
-  return {
-    category,
-    ...options.details === void 0 ? {} : { details: options.details },
-    ...options.suggestion === void 0 ? {} : { suggestion: options.suggestion },
-    ...options.cause === void 0 ? {} : { cause: options.cause }
-  };
-}
-var MergeError = class extends chunkC4F7VJ5D_cjs.TypeGraphError {
-  constructor(message, options = {}) {
-    super(
-      message,
-      MERGE_ERROR_CODES.merge,
-      toTypeGraphErrorOptions("system", options)
-    );
-    this.name = "MergeError";
-  }
-};
-var BranchError = class extends chunkC4F7VJ5D_cjs.TypeGraphError {
-  constructor(message, options = {}) {
-    super(
-      message,
-      MERGE_ERROR_CODES.branch,
-      toTypeGraphErrorOptions("system", options)
-    );
-    this.name = "BranchError";
-  }
-};
-var SimilarityUnavailableError = class extends MergeError {
-  code = MERGE_ERROR_CODES.similarityUnavailable;
-  constructor(message, options = {}) {
-    super(message, {
-      ...options,
-      suggestion: options.suggestion ?? "Pass MergeOptions.embedder (a local model), or use a fulltext/custom similarity strategy."
-    });
-    this.name = "SimilarityUnavailableError";
-  }
-};
-var MergeConflictError = class extends MergeError {
-  code = MERGE_ERROR_CODES.conflict;
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "MergeConflictError";
-  }
-};
-var BaseVersionMismatchError = class extends MergeError {
-  code = MERGE_ERROR_CODES.baseVersionMismatch;
-  constructor(message, options = {}) {
-    super(message, {
-      ...options,
-      suggestion: options.suggestion ?? "Re-branch from the current target so the branch base matches before merging."
-    });
-    this.name = "BaseVersionMismatchError";
-  }
-};
-
 // src/graph-merge/working-copy.ts
 var CLONE_IMPORT_BATCH_SIZE = 1e3;
 function cloneWorkingCopyStrategy(makeBackend) {
@@ -541,7 +1434,7 @@ function cloneWorkingCopyStrategy(makeBackend) {
     create: async (baseStore) => {
       const backend = await makeBackend();
       try {
-        const [freshStore] = await chunkYOALGKRE_cjs.createStoreWithSchema(
+        const [freshStore] = await chunkXDF2UPEQ_cjs.createStoreWithSchema(
           baseStore.graph,
           backend,
           {
@@ -550,20 +1443,29 @@ function cloneWorkingCopyStrategy(makeBackend) {
             revisionTracking: baseStore.revisionTrackingEnabled
           }
         );
-        const result = await chunk6RYPD3NJ_cjs.importGraphStream(
+        const exportOptions = {
+          includeMeta: true,
+          includeTemporal: true,
+          includeDeleted: false,
+          batchSize: CLONE_IMPORT_BATCH_SIZE
+        };
+        const importOptions = {
+          onConflict: "error",
+          onUnknownProperty: "error",
+          validateReferences: true,
+          batchSize: CLONE_IMPORT_BATCH_SIZE
+        };
+        const result = chunkXBYVV3MP_cjs.snapshotExportContention(
+          chunkTTAITEPJ_cjs.storeBackend(baseStore),
+          chunkTTAITEPJ_cjs.storeBackend(freshStore)
+        ) === void 0 ? await chunkONU3HIED_cjs.importGraphStream(
           freshStore,
-          chunk6RYPD3NJ_cjs.exportGraphStream(baseStore, {
-            includeMeta: true,
-            includeTemporal: true,
-            includeDeleted: false,
-            batchSize: CLONE_IMPORT_BATCH_SIZE
-          }),
-          {
-            onConflict: "error",
-            onUnknownProperty: "error",
-            validateReferences: true,
-            batchSize: CLONE_IMPORT_BATCH_SIZE
-          }
+          chunkONU3HIED_cjs.exportGraphStream(baseStore, exportOptions),
+          importOptions
+        ) : await chunkONU3HIED_cjs.importGraph(
+          freshStore,
+          await chunkONU3HIED_cjs.exportGraph(baseStore, exportOptions),
+          importOptions
         );
         if (!result.success) {
           throw new BranchError(
@@ -587,18 +1489,36 @@ function cloneWorkingCopyStrategy(makeBackend) {
 async function branch(baseStore, makeBackend, options, strategy) {
   try {
     const base = await computeBaseVersion(baseStore);
-    const id = options?.id ?? asBranchId(chunkJ7LXTUTP_cjs.generateId());
+    const id = options?.id ?? asBranchId(chunkXMQSEJCF_cjs.generateId());
     const workingCopyStrategy = strategy ?? cloneWorkingCopyStrategy(makeBackend);
     const store = await workingCopyStrategy.create(baseStore);
-    return chunkJ2ICGNHO_cjs.ok({ id, base, store });
+    const schemaAnchor = await readSchemaAnchor(store);
+    return chunk7BQXPCGN_cjs.ok({
+      id,
+      base,
+      store,
+      ...schemaAnchor === void 0 ? { schemaAnchor: void 0 } : { schemaAnchor }
+    });
   } catch (error) {
-    return chunkJ2ICGNHO_cjs.err(
+    return chunk7BQXPCGN_cjs.err(
       new BranchError("Failed to create working-copy branch of base store", {
         cause: error
       })
     );
   }
 }
+async function readSchemaAnchor(store) {
+  try {
+    const schemaRow = await chunkTTAITEPJ_cjs.storeBackend(store).getActiveSchema(store.graphId);
+    return schemaRow === void 0 ? void 0 : { version: schemaRow.version, hash: schemaRow.schema_hash };
+  } catch (error) {
+    try {
+      await chunkTTAITEPJ_cjs.storeBackend(store).close();
+    } catch {
+    }
+    throw error;
+  }
+}
 
 // src/graph-merge/blocking.ts
 var UNBLOCKED_BUCKET_KEY = "unblocked";
@@ -611,12 +1531,12 @@ function isUniqueBucketKey(key) {
 function constraintSignature(node, constraint) {
   const props = node;
   for (const field of constraint.fields) {
-    const value = props[field];
+    const value = chunkN66HCGCY_cjs.readOwnProperty(props, field);
     if (value === void 0 || value === null) {
       return void 0;
     }
   }
-  return `${constraint.name}${KEY_PART_SEPARATOR}${chunkJ7LXTUTP_cjs.computeUniqueKey(
+  return `${constraint.name}${KEY_PART_SEPARATOR}${chunkE4WNQBEF_cjs.computeUniqueKey(
     props,
     constraint.fields,
     constraint.collation
@@ -653,12 +1573,12 @@ function blockNodes(newNodes, resolveConfig, uniqueConstraints = []) {
     }
   }
   const sortedKeys = [...buckets.keys()].sort(
-    (left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right)
+    (left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right)
   );
   const ordered = /* @__PURE__ */ new Map();
   for (const key of sortedKeys) {
-    const members = [...chunk764JHTLT_cjs.requireDefined(buckets.get(key))].sort(
-      (left, right) => chunkTRF4EBJT_cjs.compareStrings(left.id, right.id)
+    const members = [...chunkN66HCGCY_cjs.requireDefined(buckets.get(key))].sort(
+      (left, right) => chunkXMQSEJCF_cjs.compareStrings(left.id, right.id)
     );
     ordered.set(key, members);
   }
@@ -675,7 +1595,7 @@ function buildBranchRank(branchOrder, allBranchIds) {
       next += 1;
     }
   }
-  const remaining = allBranchIds.filter((branchId) => !rank.has(branchId)).sort((left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right));
+  const remaining = allBranchIds.filter((branchId) => !rank.has(branchId)).sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right));
   for (const branchId of remaining) {
     if (!rank.has(branchId)) {
       rank.set(branchId, next);
@@ -685,7 +1605,7 @@ function buildBranchRank(branchOrder, allBranchIds) {
   return rank;
 }
 function pickByPriority(values, branchRank) {
-  let chosen = chunk764JHTLT_cjs.requireDefined(values[0]);
+  let chosen = chunkN66HCGCY_cjs.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;
@@ -699,7 +1619,7 @@ function pickByPriority(values, branchRank) {
   return chosen.value;
 }
 function pickByWeight(values, weights, branchRank) {
-  let chosen = chunk764JHTLT_cjs.requireDefined(values[0]);
+  let chosen = chunkN66HCGCY_cjs.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)) {
@@ -726,7 +1646,7 @@ function allValuesEqual(values) {
   if (values.length <= 1) {
     return true;
   }
-  const first = canonicalValueKey(chunk764JHTLT_cjs.requireDefined(values[0]).value);
+  const first = canonicalValueKey(chunkN66HCGCY_cjs.requireDefined(values[0]).value);
   return values.every(
     (candidate) => canonicalValueKey(candidate.value) === first
   );
@@ -735,7 +1655,7 @@ function collectConflictingValues(property, contributions) {
   const seen = /* @__PURE__ */ new Set();
   const values = [];
   for (const { branchId, props } of contributions) {
-    if (!(property in props)) {
+    if (!chunkN66HCGCY_cjs.hasOwnKey(props, property)) {
       continue;
     }
     const value = props[property];
@@ -747,8 +1667,8 @@ function collectConflictingValues(property, contributions) {
     values.push({ branchId, value });
   }
   return [...values].sort((left, right) => {
-    const byBranch = chunkTRF4EBJT_cjs.compareStrings(left.branchId, right.branchId);
-    return byBranch === 0 ? chunkTRF4EBJT_cjs.compareStrings(
+    const byBranch = chunkXMQSEJCF_cjs.compareStrings(left.branchId, right.branchId);
+    return byBranch === 0 ? chunkXMQSEJCF_cjs.compareStrings(
       canonicalValueKey(left.value),
       canonicalValueKey(right.value)
     ) : byBranch;
@@ -808,11 +1728,14 @@ function resolvePropertyUnion(input, context, branchRank) {
 
 // src/graph-merge/canonicalize.ts
 var BASE_PROVENANCE_BRANCH = asBranchId("__committed_base__");
+var COMMITTED_TARGET_BRANCH = asBranchId(
+  "__committed_target__"
+);
 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 chunk764JHTLT_cjs.requireDefined(baseMembers[0]);
+    return chunkN66HCGCY_cjs.requireDefined(baseMembers[0]);
   }
   let canonicalId;
   if (canonicalOverride !== void 0) {
@@ -825,26 +1748,26 @@ function pickClusterSurvivor(members, cluster, canonicalOverride, preferKind) {
     const minIdentity = [...cluster.members].sort(
       (left, right) => compareMergeKeys(left, right)
     )[0];
-    canonicalId = minIdentity === void 0 ? chunk764JHTLT_cjs.requireDefined(members[0]).id : idOf(minIdentity);
+    canonicalId = minIdentity === void 0 ? chunkN66HCGCY_cjs.requireDefined(members[0]).id : idOf(minIdentity);
   }
   const membersAtId = members.filter((member) => member.id === canonicalId);
   if (membersAtId.length === 0) {
-    return chunk764JHTLT_cjs.requireDefined([...members].sort(byKey)[0]);
+    return chunkN66HCGCY_cjs.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)) ?? chunk764JHTLT_cjs.requireDefined([...membersAtId].sort(byKey)[0]);
+  return (chosenKind === void 0 ? void 0 : membersAtId.find((member) => member.kind === chosenKind)) ?? chunkN66HCGCY_cjs.requireDefined([...membersAtId].sort(byKey)[0]);
 }
 function findPreferredMember(members, property, preferredBranchId) {
   if (preferredBranchId === void 0) {
     return void 0;
   }
   return members.find(
-    (member) => member.branchId === preferredBranchId && property in member.props
+    (member) => member.branchId === preferredBranchId && chunkN66HCGCY_cjs.hasOwnKey(member.props, property)
   );
 }
 function memberPropertyValue(member, property) {
-  if (!(property in member.props)) {
+  if (!chunkN66HCGCY_cjs.hasOwnKey(member.props, property)) {
     return void 0;
   }
   return member.props[property];
@@ -860,7 +1783,7 @@ function pickCanonicalPropertyValue(canonicalMember, members, property, values,
     return preferredValue;
   }
   const canonicalValue = memberPropertyValue(canonicalMember, property);
-  return canonicalValue === void 0 ? chunk764JHTLT_cjs.requireDefined(values[0]).value : canonicalValue;
+  return canonicalValue === void 0 ? chunkN66HCGCY_cjs.requireDefined(values[0]).value : canonicalValue;
 }
 function unionProperties(canonicalMember, members, context, baseContext, branchRank, preferredBranchId) {
   const canonicalId = canonicalMember.id;
@@ -872,10 +1795,10 @@ function unionProperties(canonicalMember, members, context, baseContext, branchR
       propertyNames.add(name);
     }
   }
-  const props = {};
+  const props = chunkN66HCGCY_cjs.createDataKeyedBag();
   const conflicts = [];
   for (const property of [...propertyNames].sort(
-    (left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right)
+    (left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right)
   )) {
     const values = collectConflictingValues(property, members);
     if (values.length === 0) {
@@ -889,7 +1812,7 @@ function unionProperties(canonicalMember, members, context, baseContext, branchR
       preferredBranchId
     );
     const baseInvolved = hasBaseMember && members.some(
-      (member) => member.origin === "base" && property in member.props
+      (member) => member.origin === "base" && chunkN66HCGCY_cjs.hasOwnKey(member.props, property)
     );
     const reportedValues = values.filter(
       (value2) => value2.branchId !== BASE_PROVENANCE_BRANCH && value2.branchId !== preferredBranchId
@@ -930,89 +1853,56 @@ function canonicalizeCluster(cluster, members, policy, branchRank, weights, cano
     policy: basePolicy,
     ...weights === void 0 ? {} : { weights }
   };
-  const { props, conflicts } = unionProperties(
-    survivor,
-    members,
-    context,
-    baseContext,
-    branchRank,
-    preferredBranchId
-  );
-  const memberIds = [
-    ...new Set(cluster.members.map((member) => idOf(member)))
-  ].sort((left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right));
-  const branchOrigins = [
-    ...new Set(
-      members.map((member) => member.branchId).filter(
-        (branchId) => branchId !== BASE_PROVENANCE_BRANCH && branchId !== preferredBranchId
-      )
-    )
-  ].sort((left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right));
-  const resolution = {
-    canonicalId,
-    memberIds,
-    kind,
-    branchOrigins
-  };
-  return { canonicalId, kind, props, resolution, conflicts };
-}
-
-// src/graph-merge/union-find.ts
-var UnionFind = class {
-  constructor(compare) {
-    this.compare = compare;
-  }
-  compare;
-  parent = /* @__PURE__ */ new Map();
-  /** Adds `value` as its own singleton set if it is not already present. */
-  add(value) {
-    if (!this.parent.has(value)) {
-      this.parent.set(value, value);
-    }
-  }
-  /** Returns the representative of `value`'s set, compressing the path to it. */
-  find(value) {
-    this.add(value);
-    let root = value;
-    while (this.parent.get(root) !== root) {
-      root = chunk764JHTLT_cjs.requireDefined(this.parent.get(root));
-    }
-    let cursor = value;
-    while (cursor !== root) {
-      const next = chunk764JHTLT_cjs.requireDefined(this.parent.get(cursor));
-      this.parent.set(cursor, root);
-      cursor = next;
-    }
-    return root;
-  }
-  /** Merges the sets of `left` and `right`; the `compare`-minimal root wins. */
-  union(left, right) {
-    const leftRoot = this.find(left);
-    const rightRoot = this.find(right);
-    if (leftRoot === rightRoot) {
-      return;
-    }
-    if (this.compare(leftRoot, rightRoot) <= 0) {
-      this.parent.set(rightRoot, leftRoot);
-    } else {
-      this.parent.set(leftRoot, rightRoot);
-    }
-  }
-  /** Every value seen by {@link add}/{@link find}/{@link union}, insertion order. */
-  members() {
-    return [...this.parent.keys()];
-  }
-};
+  const { props, conflicts } = unionProperties(
+    survivor,
+    members,
+    context,
+    baseContext,
+    branchRank,
+    preferredBranchId
+  );
+  const memberIds = [
+    ...new Set(cluster.members.map((member) => idOf(member)))
+  ].sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right));
+  const branchOrigins = [
+    ...new Set(
+      members.map((member) => member.branchId).filter(
+        (branchId) => branchId !== BASE_PROVENANCE_BRANCH && branchId !== preferredBranchId
+      )
+    )
+  ].sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right));
+  const resolution = {
+    canonicalId,
+    memberIds,
+    kind,
+    branchOrigins
+  };
+  const windowSource = members.find(
+    (member) => member.branchId === COMMITTED_TARGET_BRANCH && member.kind === kind && member.id === canonicalId
+  ) ?? survivor;
+  return {
+    canonicalId,
+    kind,
+    props,
+    resolution,
+    conflicts,
+    ...windowSource.validFrom === void 0 ? {} : { validFrom: windowSource.validFrom },
+    ...windowSource.validTo === void 0 ? {} : { validTo: windowSource.validTo }
+  };
+}
 
 // src/graph-merge/closures.ts
 var SUB_CLASS_OF_META_EDGE = "subClassOf";
-var EQUIVALENT_TO_META_EDGE = "equivalentTo";
+var EQUIVALENCE_META_EDGES = /* @__PURE__ */ new Set([
+  chunkXUO3KQFO_cjs.META_EDGE_EQUIVALENT_TO,
+  chunkXUO3KQFO_cjs.META_EDGE_SAME_AS
+]);
 function buildSubClassClosure(ontology) {
-  const unionFind = new UnionFind(chunkTRF4EBJT_cjs.compareStrings);
+  const unionFind = new UnionFind(chunkXMQSEJCF_cjs.compareStrings);
   for (const relation of ontology) {
     unionFind.add(relation.from);
     unionFind.add(relation.to);
-    if (relation.metaEdge === EQUIVALENT_TO_META_EDGE) {
+    if (EQUIVALENCE_META_EDGES.has(relation.metaEdge)) {
       unionFind.union(relation.from, relation.to);
     }
   }
@@ -1039,7 +1929,7 @@ function buildSubClassClosure(ontology) {
     relations.push([child, parent]);
   }
   return {
-    closure: chunkJ2ICGNHO_cjs.computeTransitiveClosure(relations),
+    closure: chunk7BQXPCGN_cjs.computeTransitiveClosure(relations),
     canonicalOf
   };
 }
@@ -1052,7 +1942,7 @@ function isReachable2(closure, from, to) {
   if (fromRep === toRep) {
     return from !== to;
   }
-  return chunkJ2ICGNHO_cjs.isReachable(closure.closure, fromRep, toRep);
+  return chunk7BQXPCGN_cjs.isReachable(closure.closure, fromRep, toRep);
 }
 
 // src/graph-merge/similarity.ts
@@ -1074,7 +1964,7 @@ function clampScore(value) {
   return value;
 }
 function readField(node, field) {
-  return node[field];
+  return chunkN66HCGCY_cjs.readOwnProperty(node, field);
 }
 function fieldText(node, fields) {
   const parts = [];
@@ -1165,8 +2055,8 @@ function cosineSimilarity(left, right) {
   let leftMagnitude = 0;
   let rightMagnitude = 0;
   for (let index = 0; index < left.length; index += 1) {
-    const leftComponent = chunk764JHTLT_cjs.requireDefined(left[index]);
-    const rightComponent = chunk764JHTLT_cjs.requireDefined(right[index]);
+    const leftComponent = chunkN66HCGCY_cjs.requireDefined(left[index]);
+    const rightComponent = chunkN66HCGCY_cjs.requireDefined(right[index]);
     dot += leftComponent * rightComponent;
     leftMagnitude += leftComponent * leftComponent;
     rightMagnitude += rightComponent * rightComponent;
@@ -1235,37 +2125,37 @@ function scorePrepared(left, right, strategy, ctx) {
   switch (strategy.kind) {
     case "custom": {
       const raw = strategy.score(left.node, right.node);
-      return chunkJ2ICGNHO_cjs.ok(clampScore(raw));
+      return chunk7BQXPCGN_cjs.ok(clampScore(raw));
     }
     case "fulltext": {
       if (left.text.length === 0 || right.text.length === 0) {
-        return chunkJ2ICGNHO_cjs.ok(NO_EVIDENCE_SCORE);
+        return chunk7BQXPCGN_cjs.ok(NO_EVIDENCE_SCORE);
       }
-      return chunkJ2ICGNHO_cjs.ok(clampScore(diceFromMultisets(left.grams, right.grams)));
+      return chunk7BQXPCGN_cjs.ok(clampScore(diceFromMultisets(left.grams, right.grams)));
     }
     case "vector": {
       if (ctx.embeddings === void 0) {
-        return chunkJ2ICGNHO_cjs.err(embedderUnavailable("vector", ctx));
+        return chunk7BQXPCGN_cjs.err(embedderUnavailable("vector", ctx));
       }
       if (left.text.length === 0 || right.text.length === 0) {
-        return chunkJ2ICGNHO_cjs.ok(NO_EVIDENCE_SCORE);
+        return chunk7BQXPCGN_cjs.ok(NO_EVIDENCE_SCORE);
       }
       const cosine = cosineFromLookup(ctx.embeddings, left.text, right.text);
-      return chunkJ2ICGNHO_cjs.ok(clampScore(cosine));
+      return chunk7BQXPCGN_cjs.ok(clampScore(cosine));
     }
     case "hybrid": {
       if (ctx.embeddings === void 0) {
-        return chunkJ2ICGNHO_cjs.err(embedderUnavailable("hybrid", ctx));
+        return chunk7BQXPCGN_cjs.err(embedderUnavailable("hybrid", ctx));
       }
       if (left.text.length === 0 || right.text.length === 0) {
-        return chunkJ2ICGNHO_cjs.ok(NO_EVIDENCE_SCORE);
+        return chunk7BQXPCGN_cjs.ok(NO_EVIDENCE_SCORE);
       }
       const vectorScore = clampScore(
         cosineFromLookup(ctx.embeddings, left.text, right.text)
       );
       const fulltextScore = diceFromMultisets(left.grams, right.grams);
       const weights = normalizeHybridWeights(strategy.weights);
-      return chunkJ2ICGNHO_cjs.ok(
+      return chunk7BQXPCGN_cjs.ok(
         clampScore(
           weights.vector * vectorScore + weights.fulltext * fulltextScore
         )
@@ -1323,7 +2213,7 @@ function scoreCandidates(input, resolveConfig, ctx, ceilingPolicy, maxComparison
   }
   if (maxComparisonsPerKind !== void 0 && fuzzy.length > maxComparisonsPerKind) {
     if (ceilingPolicy === "error") {
-      return chunkJ2ICGNHO_cjs.err(
+      return chunk7BQXPCGN_cjs.err(
         new MergeError(
           `Comparison ceiling exceeded: ${fuzzy.length} candidate pairs > maxComparisonsPerKind ${maxComparisonsPerKind}.`,
           {
@@ -1336,7 +2226,7 @@ function scoreCandidates(input, resolveConfig, ctx, ceilingPolicy, maxComparison
         )
       );
     }
-    return chunkJ2ICGNHO_cjs.ok({
+    return chunk7BQXPCGN_cjs.ok({
       edges: [...forced].sort(
         (left, right) => compareCandidateEdges(left, right)
       ),
@@ -1354,14 +2244,14 @@ function scoreCandidates(input, resolveConfig, ctx, ceilingPolicy, maxComparison
   const edges = [...forced];
   for (const { left, right, a, b } of fuzzy) {
     const scored = scorer(a, left, b, right);
-    if (chunkJ2ICGNHO_cjs.isErr(scored)) {
-      return chunkJ2ICGNHO_cjs.err(scored.error);
+    if (chunk7BQXPCGN_cjs.isErr(scored)) {
+      return chunk7BQXPCGN_cjs.err(scored.error);
     }
     if (scored.data >= threshold) {
       edges.push({ a, b, score: scored.data });
     }
   }
-  return chunkJ2ICGNHO_cjs.ok({
+  return chunk7BQXPCGN_cjs.ok({
     edges: edges.sort((left, right) => compareCandidateEdges(left, right)),
     warnings: []
   });
@@ -1401,8 +2291,8 @@ function buildComponents(edges, nodeIds, edgesSorted = false) {
   }
   clusters.sort(
     (left, right) => compareMergeKeys(
-      chunk764JHTLT_cjs.requireDefined(left.members[0]),
-      chunk764JHTLT_cjs.requireDefined(right.members[0])
+      chunkN66HCGCY_cjs.requireDefined(left.members[0]),
+      chunkN66HCGCY_cjs.requireDefined(right.members[0])
     )
   );
   return clusters;
@@ -1415,8 +2305,8 @@ function adjacencyOf(members, edges) {
   }
   for (const edge of edges) {
     if (memberSet.has(edge.a) && memberSet.has(edge.b)) {
-      chunk764JHTLT_cjs.requireDefined(adjacency.get(edge.a)).add(edge.b);
-      chunk764JHTLT_cjs.requireDefined(adjacency.get(edge.b)).add(edge.a);
+      chunkN66HCGCY_cjs.requireDefined(adjacency.get(edge.a)).add(edge.b);
+      chunkN66HCGCY_cjs.requireDefined(adjacency.get(edge.b)).add(edge.a);
     }
   }
   return adjacency;
@@ -1431,10 +2321,10 @@ function exceedsDiameter(members, edges, maxDiameter) {
     const queue = [source];
     let head = 0;
     while (head < queue.length) {
-      const current = chunk764JHTLT_cjs.requireDefined(queue[head]);
+      const current = chunkN66HCGCY_cjs.requireDefined(queue[head]);
       head += 1;
-      const currentDistance = chunk764JHTLT_cjs.requireDefined(distance.get(current));
-      for (const neighbor of chunk764JHTLT_cjs.requireDefined(adjacency.get(current))) {
+      const currentDistance = chunkN66HCGCY_cjs.requireDefined(distance.get(current));
+      for (const neighbor of chunkN66HCGCY_cjs.requireDefined(adjacency.get(current))) {
         if (!distance.has(neighbor)) {
           const neighborDistance = currentDistance + 1;
           if (neighborDistance > maxDiameter) {
@@ -1518,8 +2408,8 @@ function enforceDiameter(clusters, candidateEdges, clusterMaxDiameter) {
   }
   guarded.sort(
     (left, right) => compareMergeKeys(
-      chunk764JHTLT_cjs.requireDefined(left.members[0]),
-      chunk764JHTLT_cjs.requireDefined(right.members[0])
+      chunkN66HCGCY_cjs.requireDefined(left.members[0]),
+      chunkN66HCGCY_cjs.requireDefined(right.members[0])
     )
   );
   return guarded;
@@ -1566,8 +2456,8 @@ function enforceBaseGuard(clusters, candidateEdges, baseIds) {
   }
   result.sort(
     (left, right) => compareMergeKeys(
-      chunk764JHTLT_cjs.requireDefined(left.members[0]),
-      chunk764JHTLT_cjs.requireDefined(right.members[0])
+      chunkN66HCGCY_cjs.requireDefined(left.members[0]),
+      chunkN66HCGCY_cjs.requireDefined(right.members[0])
     )
   );
   return { clusters: result, events };
@@ -1576,11 +2466,11 @@ 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 = chunk764JHTLT_cjs.requireDefined(branchIds[0]);
+  let chosen = chunkN66HCGCY_cjs.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;
-    if (candidateRank < chosenRank || candidateRank === chosenRank && chunkTRF4EBJT_cjs.compareStrings(candidate, chosen) < 0) {
+    if (candidateRank < chosenRank || candidateRank === chosenRank && chunkXMQSEJCF_cjs.compareStrings(candidate, chosen) < 0) {
       chosen = candidate;
       chosenRank = candidateRank;
     }
@@ -1612,7 +2502,7 @@ function groupByEntity(items, entityOf) {
   }
   return grouped;
 }
-function resolveDeleteModifyOver(modified, deleted, modifiedEntity, deletedEntity, droppedKind, policy, branchRank, preferredBranchId) {
+function resolveDeleteModifyOver(modified, deleted, modifiedEntity, deletedEntity, dropDeleted, policy, branchRank, preferredBranchId) {
   const modifiedByKey = groupByEntity(modified, modifiedEntity);
   const deletedByKey = groupByEntity(deleted, deletedEntity);
   const survivingModifications = [];
@@ -1632,8 +2522,8 @@ function resolveDeleteModifyOver(modified, deleted, modifiedEntity, deletedEntit
       }
       continue;
     }
-    const deletionsForKey = chunk764JHTLT_cjs.requireDefined(deletedByKey.get(key));
-    const { id, kind } = modifiedEntity(chunk764JHTLT_cjs.requireDefined(modifications[0]));
+    const deletionsForKey = chunkN66HCGCY_cjs.requireDefined(deletedByKey.get(key));
+    const { id, kind } = modifiedEntity(chunkN66HCGCY_cjs.requireDefined(modifications[0]));
     const deletedBy = pickHighestPriorityBranch(
       deletionsForKey.map((deletion) => deletion.branchId),
       branchRank
@@ -1657,7 +2547,7 @@ function resolveDeleteModifyOver(modified, deleted, modifiedEntity, deletedEntit
     });
     if (effectivePolicy === "deleteWins") {
       deletions.push({ id, kind });
-      dropped.push({ kind: droppedKind, id, reason: DELETED_NODE_DROP_REASON });
+      dropped.push(dropDeleted(id));
       continue;
     }
     for (const modification of modifications) {
@@ -1668,25 +2558,25 @@ function resolveDeleteModifyOver(modified, deleted, modifiedEntity, deletedEntit
     if (conflictedKeys.has(key)) {
       continue;
     }
-    const { id, kind } = deletedEntity(chunk764JHTLT_cjs.requireDefined(deletionsForKey[0]));
+    const { id, kind } = deletedEntity(chunkN66HCGCY_cjs.requireDefined(deletionsForKey[0]));
     deletions.push({ id, kind });
   }
   return {
     survivingModifications: [...survivingModifications].sort((left, right) => {
-      const byId2 = chunkTRF4EBJT_cjs.compareStrings(
+      const byId2 = chunkXMQSEJCF_cjs.compareStrings(
         modifiedEntity(left).id,
         modifiedEntity(right).id
       );
-      return byId2 === 0 ? chunkTRF4EBJT_cjs.compareStrings(left.branchId, right.branchId) : byId2;
+      return byId2 === 0 ? chunkXMQSEJCF_cjs.compareStrings(left.branchId, right.branchId) : byId2;
     }),
     deletions: [...deletions].sort(
-      (left, right) => chunkTRF4EBJT_cjs.compareStrings(left.id, right.id)
+      (left, right) => chunkXMQSEJCF_cjs.compareStrings(left.id, right.id)
     ),
     conflicts: [...conflicts].sort(
-      (left, right) => chunkTRF4EBJT_cjs.compareStrings(left.entityId, right.entityId)
+      (left, right) => chunkXMQSEJCF_cjs.compareStrings(left.entityId, right.entityId)
     ),
     dropped: [...dropped].sort(
-      (left, right) => chunkTRF4EBJT_cjs.compareStrings(left.id, right.id)
+      (left, right) => chunkXMQSEJCF_cjs.compareStrings(left.id, right.id)
     )
   };
 }
@@ -1700,10 +2590,10 @@ function reconcileOver(survivingModifications, entityOf, rebuild, policy, branch
   const conflicts = [];
   for (const modifications of grouped.values()) {
     if (modifications.length === 1) {
-      out.push(chunk764JHTLT_cjs.requireDefined(modifications[0]));
+      out.push(chunkN66HCGCY_cjs.requireDefined(modifications[0]));
       continue;
     }
-    const first = entityOf(chunk764JHTLT_cjs.requireDefined(modifications[0]));
+    const first = entityOf(chunkN66HCGCY_cjs.requireDefined(modifications[0]));
     const { props, conflicts: propertyConflicts } = threeWayMergeProps(
       first.id,
       first.kind,
@@ -1722,7 +2612,7 @@ function reconcileOver(survivingModifications, entityOf, rebuild, policy, branch
     );
     const representative = modifications.find(
       (modification) => modification.branchId === chosenBranch
-    ) ?? chunk764JHTLT_cjs.requireDefined(modifications[0]);
+    ) ?? chunkN66HCGCY_cjs.requireDefined(modifications[0]);
     out.push(rebuild(representative, chosenBranch, props));
     for (const conflict of propertyConflicts) {
       conflicts.push(conflict);
@@ -1730,11 +2620,11 @@ function reconcileOver(survivingModifications, entityOf, rebuild, policy, branch
   }
   return {
     survivingModifications: [...out].sort((left, right) => {
-      const byId2 = chunkTRF4EBJT_cjs.compareStrings(entityOf(left).id, entityOf(right).id);
-      return byId2 === 0 ? chunkTRF4EBJT_cjs.compareStrings(left.branchId, right.branchId) : byId2;
+      const byId2 = chunkXMQSEJCF_cjs.compareStrings(entityOf(left).id, entityOf(right).id);
+      return byId2 === 0 ? chunkXMQSEJCF_cjs.compareStrings(left.branchId, right.branchId) : byId2;
     }),
     conflicts: conflicts.sort(
-      (left, right) => chunkTRF4EBJT_cjs.compareStrings(
+      (left, right) => chunkXMQSEJCF_cjs.compareStrings(
         `${left.entityId}|${left.property}`,
         `${right.entityId}|${right.property}`
       )
@@ -1747,7 +2637,7 @@ function resolveDeleteModify(staging, policy, branchRank, preferredBranchId) {
     staging.deletedNodes,
     (item) => item.node,
     (item) => item.node,
-    "node",
+    (id) => ({ kind: "node", id, reason: DELETED_NODE_DROP_REASON }),
     policy,
     branchRank,
     preferredBranchId
@@ -1760,7 +2650,7 @@ function resolveDeleteModify(staging, policy, branchRank, preferredBranchId) {
   };
 }
 function threeWayMergeProps(entityId, kind, baseProps, contributions, context, branchRank, preferredBranchId) {
-  const merged = {};
+  const merged = chunkN66HCGCY_cjs.createDataKeyedBag();
   const conflicts = [];
   const propertyNames = new Set(Object.keys(baseProps));
   for (const contribution of contributions) {
@@ -1768,11 +2658,11 @@ function threeWayMergeProps(entityId, kind, baseProps, contributions, context, b
       propertyNames.add(name);
     }
   }
-  for (const property of [...propertyNames].sort(chunkTRF4EBJT_cjs.compareStrings)) {
-    const baseHas = property in baseProps;
-    const baseKey = baseHas ? canonicalValueKey(chunk764JHTLT_cjs.requireDefined(baseProps[property])) : void 0;
+  for (const property of [...propertyNames].sort(chunkXMQSEJCF_cjs.compareStrings)) {
+    const baseHas = chunkN66HCGCY_cjs.hasOwnKey(baseProps, property);
+    const baseKey = baseHas ? canonicalValueKey(chunkN66HCGCY_cjs.requireDefined(baseProps[property])) : void 0;
     const changed = contributions.filter((contribution) => {
-      if (!(property in contribution.forkProps)) {
+      if (!chunkN66HCGCY_cjs.hasOwnKey(contribution.forkProps, property)) {
         return false;
       }
       const value2 = contribution.forkProps[property];
@@ -1784,10 +2674,10 @@ function threeWayMergeProps(entityId, kind, baseProps, contributions, context, b
     const values = collectConflictingValues(property, changed);
     if (values.length === 0) {
       const deletedByFork = baseHas && contributions.some(
-        (contribution) => !(property in contribution.forkProps)
+        (contribution) => !chunkN66HCGCY_cjs.hasOwnKey(contribution.forkProps, property)
       );
       if (baseHas && !deletedByFork) {
-        merged[property] = chunk764JHTLT_cjs.requireDefined(baseProps[property]);
+        merged[property] = chunkN66HCGCY_cjs.requireDefined(baseProps[property]);
       }
       continue;
     }
@@ -1795,13 +2685,13 @@ function threeWayMergeProps(entityId, kind, baseProps, contributions, context, b
       values.map((candidate) => canonicalValueKey(candidate.value))
     );
     if (distinctValues.size === 1) {
-      merged[property] = chunk764JHTLT_cjs.requireDefined(values[0]).value;
+      merged[property] = chunkN66HCGCY_cjs.requireDefined(values[0]).value;
       continue;
     }
     const preferredValue = values.find(
       (value2) => value2.branchId === preferredBranchId
     )?.value;
-    const canonicalValue = preferredValue ?? (baseHas ? chunk764JHTLT_cjs.requireDefined(baseProps[property]) : chunk764JHTLT_cjs.requireDefined(values[0]).value);
+    const canonicalValue = preferredValue ?? (baseHas ? chunkN66HCGCY_cjs.requireDefined(baseProps[property]) : chunkN66HCGCY_cjs.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 },
@@ -1835,7 +2725,7 @@ function resolveEdgeDeleteModify(staging, policy, branchRank, preferredBranchId)
     staging.deletedEdges,
     (item) => item.edge,
     (item) => item.edge,
-    "edge",
+    (id) => ({ kind: "edge", id, reason: DELETED_NODE_DROP_REASON }),
     policy,
     branchRank,
     preferredBranchId
@@ -1862,8 +2752,166 @@ function reconcileEdgeModifications(survivingModifications, policy, branchRank,
   );
 }
 
+// src/graph-merge/valid-window.ts
+var WINDOW_NOT_APPLICABLE_DROP_REASON = "window-not-applicable";
+function earliestEnd(claims) {
+  let earliest;
+  for (const claim of claims) {
+    if (earliest === void 0 || chunkXMQSEJCF_cjs.compareStrings(claim.validTo, earliest) < 0) {
+      earliest = claim.validTo;
+    }
+  }
+  return earliest;
+}
+function resolveEndClaims(claims, preferredBranchId) {
+  const preferred = claims.filter(
+    (claim) => claim.branchId === preferredBranchId
+  );
+  return earliestEnd(preferred.length > 0 ? preferred : claims);
+}
+function claimingBranches(claims) {
+  return [...new Set(claims.map((claim) => claim.branchId))].sort(
+    (left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right)
+  );
+}
+function classifyDelta(base, fork) {
+  const endCleared = fork.validTo === void 0 && base.validTo !== void 0;
+  return {
+    applicableEnd: fork.validTo !== void 0 && fork.validTo !== base.validTo ? fork.validTo : void 0,
+    unapplicable: endCleared || fork.validFrom !== base.validFrom
+  };
+}
+function resolvePopulation(entity, deltas, deletions, preferredBranchId, dropItem) {
+  const byIdentity = /* @__PURE__ */ new Map();
+  for (const delta of deltas) {
+    const identity = mergeKey(delta.kind, delta.id);
+    if (deletions.has(identity)) {
+      continue;
+    }
+    const bucket = byIdentity.get(identity);
+    if (bucket === void 0) {
+      byIdentity.set(identity, [delta]);
+    } else {
+      bucket.push(delta);
+    }
+  }
+  const ends = /* @__PURE__ */ new Map();
+  const credits = /* @__PURE__ */ new Map();
+  const resolutions = [];
+  const dropped = [];
+  for (const [identity, group] of byIdentity) {
+    const claims = [];
+    let reportedUnapplicable = false;
+    let targetEnd;
+    for (const delta of group) {
+      const { applicableEnd, unapplicable } = classifyDelta(
+        delta.base,
+        delta.fork
+      );
+      if (delta.branchId === preferredBranchId) {
+        targetEnd ??= applicableEnd;
+        continue;
+      }
+      if (applicableEnd !== void 0) {
+        claims.push({ branchId: delta.branchId, validTo: applicableEnd });
+      }
+      if (unapplicable && !reportedUnapplicable) {
+        reportedUnapplicable = true;
+        dropped.push(dropItem(delta.id));
+      }
+    }
+    const first = chunkN66HCGCY_cjs.requireDefined(group[0]);
+    if (targetEnd !== void 0) {
+      if (claims.length > 0) {
+        resolutions.push({
+          entity,
+          kind: first.kind,
+          id: first.id,
+          validTo: targetEnd,
+          claimedBy: claimingBranches(claims),
+          precedence: VALIDITY_END_TARGET_PRECEDENCE
+        });
+      }
+      continue;
+    }
+    const resolved = earliestEnd(claims);
+    if (resolved === void 0) {
+      continue;
+    }
+    ends.set(identity, resolved);
+    credits.set(
+      identity,
+      claimingBranches(claims.filter((claim) => claim.validTo === resolved))
+    );
+    resolutions.push({
+      entity,
+      kind: first.kind,
+      id: first.id,
+      validTo: resolved,
+      claimedBy: claimingBranches(claims)
+    });
+  }
+  return {
+    ends,
+    credits,
+    resolutions: resolutions.sort(
+      (left, right) => compareMergeKeys(
+        mergeKey(left.kind, left.id),
+        mergeKey(right.kind, right.id)
+      )
+    ),
+    dropped: dropped.sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left.id, right.id))
+  };
+}
+function resolveValidWindows(staging, nodeDeletions, edgeDeletions, preferredBranchId) {
+  const nodes = resolvePopulation(
+    "node",
+    staging.windowedNodes.map((staged) => ({
+      branchId: staged.branchId,
+      kind: staged.node.kind,
+      id: staged.node.id,
+      base: staged.node.base,
+      fork: staged.node.fork
+    })),
+    nodeDeletions,
+    preferredBranchId,
+    (id) => ({
+      kind: "node",
+      id,
+      reason: WINDOW_NOT_APPLICABLE_DROP_REASON
+    })
+  );
+  const edges = resolvePopulation(
+    "edge",
+    staging.windowedEdges.map((staged) => ({
+      branchId: staged.branchId,
+      kind: staged.edge.kind,
+      id: staged.edge.id,
+      base: staged.edge.base,
+      fork: staged.edge.fork
+    })),
+    edgeDeletions,
+    preferredBranchId,
+    (id) => ({
+      kind: "edge",
+      id,
+      reason: WINDOW_NOT_APPLICABLE_DROP_REASON
+    })
+  );
+  return {
+    nodeEnds: nodes.ends,
+    edgeEnds: edges.ends,
+    nodeCredits: nodes.credits,
+    edgeCredits: edges.credits,
+    resolutions: [...nodes.resolutions, ...edges.resolutions],
+    dropped: [...nodes.dropped, ...edges.dropped]
+  };
+}
+
 // src/graph-merge/edge-repoint.ts
 var ENDPOINT_DELETED_DROP_REASON = "edge:endpoint-deleted";
+var INHERITED_EDGE_ORIGIN = "inherited";
+var BRANCH_CREATED_EDGE_ORIGIN = "branch-created";
 function buildCanonicalMap(clusters, canonicalOf) {
   const map = /* @__PURE__ */ new Map();
   for (const cluster of clusters) {
@@ -1883,16 +2931,97 @@ function dedupeKey(fromKey, type, toKey, props) {
 function groupKey(fromKey, type, toKey) {
   return JSON.stringify([fromKey, type, toKey]);
 }
+function sourcePairKey(fromKey, toKey) {
+  return JSON.stringify([fromKey, toKey]);
+}
+function rowsById(groupEdges) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const edge of groupEdges) {
+    const row = rows.get(edge.staged.id);
+    if (row === void 0) {
+      rows.set(edge.staged.id, [edge]);
+    } else {
+      row.push(edge);
+    }
+  }
+  return rows;
+}
+function sourcePairByRow(rows) {
+  const pairs = /* @__PURE__ */ new Map();
+  for (const [id, members] of rows) {
+    const sorted = members.map((member) => member.sourcePair).sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right));
+    pairs.set(id, chunkN66HCGCY_cjs.requireDefined(sorted[0]));
+  }
+  return pairs;
+}
+function foldSets(groupEdges) {
+  const rows = rowsById(groupEdges);
+  const sourcePairs = sourcePairByRow(rows);
+  const representatives = /* @__PURE__ */ new Map();
+  for (const [id, pair] of sourcePairs) {
+    const representative = representatives.get(pair);
+    if (representative === void 0 || chunkXMQSEJCF_cjs.compareStrings(id, representative) < 0) {
+      representatives.set(pair, id);
+    }
+  }
+  const collapsed = [];
+  const parallel = [];
+  for (const id of [...rows.keys()].sort(
+    (left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right)
+  )) {
+    const members = chunkN66HCGCY_cjs.requireDefined(rows.get(id));
+    const pair = chunkN66HCGCY_cjs.requireDefined(sourcePairs.get(id));
+    if (representatives.get(pair) === id) {
+      collapsed.push(...members);
+    } else {
+      parallel.push(members);
+    }
+  }
+  return [collapsed, ...parallel];
+}
+function compareMembers(left, right, preferredBranchId) {
+  const byId2 = chunkXMQSEJCF_cjs.compareStrings(left.staged.id, right.staged.id);
+  if (byId2 !== 0) {
+    return byId2;
+  }
+  const leftPreferred = left.staged.branchId === preferredBranchId;
+  const rightPreferred = right.staged.branchId === preferredBranchId;
+  if (leftPreferred !== rightPreferred) {
+    return leftPreferred ? -1 : 1;
+  }
+  return chunkXMQSEJCF_cjs.compareStrings(left.staged.branchId, right.staged.branchId);
+}
 function pickSurvivor(edges, preferredBranchId) {
+  const inherited = edges.filter(
+    (edge) => edge.staged.origin === INHERITED_EDGE_ORIGIN
+  );
   const preferred = preferredBranchId === void 0 ? [] : edges.filter((edge) => edge.staged.branchId === preferredBranchId);
-  const candidates = preferred.length > 0 ? preferred : edges;
-  let survivor = chunk764JHTLT_cjs.requireDefined(candidates[0]);
-  for (const candidate of candidates.slice(1)) {
-    if (candidate.staged.id < survivor.staged.id) {
-      survivor = candidate;
-    }
+  const candidates = inherited.length > 0 ? inherited : preferred.length > 0 ? preferred : edges;
+  return chunkN66HCGCY_cjs.requireDefined(
+    [...candidates].sort(
+      (left, right) => compareMembers(left, right, preferredBranchId)
+    )[0]
+  );
+}
+function authoredProperty(edge, property) {
+  const { props, baseProps } = edge.staged;
+  if (!chunkN66HCGCY_cjs.hasOwnKey(props, property)) {
+    return false;
+  }
+  if (baseProps === void 0 || !chunkN66HCGCY_cjs.hasOwnKey(baseProps, property)) {
+    return true;
   }
-  return survivor;
+  return canonicalValueKey(props[property]) !== canonicalValueKey(baseProps[property]);
+}
+function unauthoredValue(property, edges) {
+  const carriers = edges.filter((edge) => chunkN66HCGCY_cjs.hasOwnKey(edge.staged.props, property)).sort((left, right) => {
+    const byId2 = chunkXMQSEJCF_cjs.compareStrings(left.staged.id, right.staged.id);
+    return byId2 === 0 ? chunkXMQSEJCF_cjs.compareStrings(
+      canonicalValueKey(left.staged.props[property]),
+      canonicalValueKey(right.staged.props[property])
+    ) : byId2;
+  });
+  return chunkN66HCGCY_cjs.requireDefined(carriers[0]).staged.props[property];
 }
 function unionEdgeProps(survivorId, kind, survivor, edges, context, branchRank, preferredBranchId) {
   const propertyNames = /* @__PURE__ */ new Set();
@@ -1901,17 +3030,18 @@ function unionEdgeProps(survivorId, kind, survivor, edges, context, branchRank,
       propertyNames.add(name);
     }
   }
-  const props = {};
+  const props = chunkN66HCGCY_cjs.createDataKeyedBag();
   const conflicts = [];
-  const contributions = edges.map((edge) => edge.staged);
   for (const property of [...propertyNames].sort(
-    (left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right)
+    (left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right)
   )) {
-    const values = collectConflictingValues(property, contributions);
+    const claimants = edges.filter((edge) => authoredProperty(edge, property)).map((edge) => edge.staged);
+    const values = collectConflictingValues(property, claimants);
     if (values.length === 0) {
+      props[property] = chunkN66HCGCY_cjs.hasOwnKey(survivor.staged.props, property) ? survivor.staged.props[property] : unauthoredValue(property, edges);
       continue;
     }
-    const survivorValue = property in survivor.staged.props ? survivor.staged.props[property] : chunk764JHTLT_cjs.requireDefined(values[0]).value;
+    const survivorValue = chunkN66HCGCY_cjs.hasOwnKey(survivor.staged.props, property) ? survivor.staged.props[property] : chunkN66HCGCY_cjs.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(
@@ -1933,16 +3063,75 @@ function unionEdgeProps(survivorId, kind, survivor, edges, context, branchRank,
   }
   return { props, conflicts };
 }
+function foldEdgeSet(foldSet, context, branchRank, preferredBranchId) {
+  const survivor = pickSurvivor(foldSet, preferredBranchId);
+  const survivorId = survivor.staged.id;
+  const mergedIds = foldSet.map((edge) => edge.staged.id).sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right));
+  const fromId = idOf(survivor.fromKey);
+  const fromKind = kindOf(survivor.fromKey);
+  const toId = idOf(survivor.toKey);
+  const toKind = kindOf(survivor.toKey);
+  const preferredSurvivorEnd = survivor.staged.branchId === preferredBranchId ? survivor.staged.validTo : void 0;
+  const foldedEnd = preferredSurvivorEnd ?? resolveEndClaims(
+    foldSet.filter((edge) => edge.staged.validTo !== void 0).map((edge) => ({
+      branchId: edge.staged.branchId,
+      validTo: chunkN66HCGCY_cjs.requireDefined(edge.staged.validTo)
+    })),
+    preferredBranchId
+  );
+  const window = {
+    ...survivor.staged.validFrom === void 0 ? {} : { validFrom: survivor.staged.validFrom },
+    ...foldedEnd === void 0 ? {} : { validTo: foldedEnd }
+  };
+  const contentKeys = new Set(foldSet.map((edge) => edge.dedupeKey));
+  if (contentKeys.size === 1) {
+    return {
+      edge: {
+        id: survivorId,
+        kind: survivor.staged.kind,
+        fromId,
+        toId,
+        fromKind,
+        toKind,
+        props: survivor.staged.props,
+        mergedIds,
+        ...window
+      },
+      conflicts: []
+    };
+  }
+  const { props, conflicts } = unionEdgeProps(
+    survivorId,
+    survivor.staged.kind,
+    survivor,
+    foldSet,
+    context,
+    branchRank,
+    preferredBranchId
+  );
+  return {
+    edge: {
+      id: survivorId,
+      kind: survivor.staged.kind,
+      fromId,
+      toId,
+      fromKind,
+      toKind,
+      props,
+      mergedIds,
+      ...window
+    },
+    conflicts
+  };
+}
 function repointEdges(stagedEdges, canonicalOf, deletedNodeIds, policy, branchRank, weights, preferredBranchId) {
   const dropped = [];
-  const liveByDedupeKey = /* @__PURE__ */ new Map();
-  const dedupeKeyByGroup = /* @__PURE__ */ new Map();
+  const liveByGroup = /* @__PURE__ */ new Map();
   for (const staged of stagedEdges) {
-    const fromKey = repoint(
-      mergeKey(staged.fromKind, staged.fromId),
-      canonicalOf
-    );
-    const toKey = repoint(mergeKey(staged.toKind, staged.toId), canonicalOf);
+    const sourceFromKey = mergeKey(staged.fromKind, staged.fromId);
+    const sourceToKey = mergeKey(staged.toKind, staged.toId);
+    const fromKey = repoint(sourceFromKey, canonicalOf);
+    const toKey = repoint(sourceToKey, canonicalOf);
     if (deletedNodeIds.has(fromKey) || deletedNodeIds.has(toKey)) {
       dropped.push({
         kind: "edge",
@@ -1951,21 +3140,20 @@ function repointEdges(stagedEdges, canonicalOf, deletedNodeIds, policy, branchRa
       });
       continue;
     }
-    const repointed = { staged, fromKey, toKey };
-    const key = dedupeKey(fromKey, staged.kind, toKey, staged.props);
-    const bucket = liveByDedupeKey.get(key);
+    const repointed = {
+      staged,
+      fromKey,
+      toKey,
+      sourcePair: sourcePairKey(sourceFromKey, sourceToKey),
+      dedupeKey: dedupeKey(fromKey, staged.kind, toKey, staged.props)
+    };
+    const group = groupKey(fromKey, staged.kind, toKey);
+    const bucket = liveByGroup.get(group);
     if (bucket === void 0) {
-      liveByDedupeKey.set(key, [repointed]);
+      liveByGroup.set(group, [repointed]);
     } else {
       bucket.push(repointed);
     }
-    const group = groupKey(fromKey, staged.kind, toKey);
-    const keysForGroup = dedupeKeyByGroup.get(group);
-    if (keysForGroup === void 0) {
-      dedupeKeyByGroup.set(group, /* @__PURE__ */ new Set([key]));
-    } else {
-      keysForGroup.add(key);
-    }
   }
   const context = {
     policy,
@@ -1973,74 +3161,41 @@ function repointEdges(stagedEdges, canonicalOf, deletedNodeIds, policy, branchRa
   };
   const merged = [];
   const conflicts = [];
-  const sortedGroups = [...dedupeKeyByGroup.keys()].sort(
-    (left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right)
+  const sortedGroups = [...liveByGroup.keys()].sort(
+    (left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right)
   );
   for (const group of sortedGroups) {
-    const dedupeKeys = [...chunk764JHTLT_cjs.requireDefined(dedupeKeyByGroup.get(group))];
-    const groupEdges = [];
-    for (const key of dedupeKeys) {
-      for (const edge of chunk764JHTLT_cjs.requireDefined(liveByDedupeKey.get(key))) {
-        groupEdges.push(edge);
+    const groupEdges = chunkN66HCGCY_cjs.requireDefined(liveByGroup.get(group));
+    for (const foldSet of foldSets(groupEdges)) {
+      const folded = foldEdgeSet(
+        foldSet,
+        context,
+        branchRank,
+        preferredBranchId
+      );
+      merged.push(folded.edge);
+      for (const conflict of folded.conflicts) {
+        conflicts.push(conflict);
       }
     }
-    const survivor = pickSurvivor(groupEdges, preferredBranchId);
-    const survivorId = survivor.staged.id;
-    const mergedIds = [...groupEdges].map((edge) => edge.staged.id).sort((left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right));
-    const fromId = idOf(survivor.fromKey);
-    const fromKind = kindOf(survivor.fromKey);
-    const toId = idOf(survivor.toKey);
-    const toKind = kindOf(survivor.toKey);
-    if (dedupeKeys.length === 1) {
-      merged.push({
-        id: survivorId,
-        kind: survivor.staged.kind,
-        fromId,
-        toId,
-        fromKind,
-        toKind,
-        props: survivor.staged.props,
-        mergedIds
-      });
-      continue;
-    }
-    const { props, conflicts: groupConflicts } = unionEdgeProps(
-      survivorId,
-      survivor.staged.kind,
-      survivor,
-      groupEdges,
-      context,
-      branchRank,
-      preferredBranchId
-    );
-    for (const conflict of groupConflicts) {
-      conflicts.push(conflict);
-    }
-    merged.push({
-      id: survivorId,
-      kind: survivor.staged.kind,
-      fromId,
-      toId,
-      fromKind,
-      toKind,
-      props,
-      mergedIds
-    });
   }
   const sortedEdges = merged.map((edge) => ({
     edge,
-    sortKey: dedupeKey(
-      mergeKey(edge.fromKind, edge.fromId),
-      edge.kind,
-      mergeKey(edge.toKind, edge.toId),
-      edge.props
-    )
-  })).sort((left, right) => chunkTRF4EBJT_cjs.compareStrings(left.sortKey, right.sortKey)).map(({ edge }) => edge);
+    sortKey: JSON.stringify([
+      dedupeKey(
+        mergeKey(edge.fromKind, edge.fromId),
+        edge.kind,
+        mergeKey(edge.toKind, edge.toId),
+        edge.props
+      ),
+      edge.id
+    ])
+  })).sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left.sortKey, right.sortKey)).map(({ edge }) => edge);
   return {
     edges: sortedEdges,
-    dropped: dropped.sort((left, right) => chunkTRF4EBJT_cjs.compareStrings(left.id, right.id)),
+    dropped: dropped.sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left.id, right.id)),
     conflicts: conflicts.sort(
-      (left, right) => chunkTRF4EBJT_cjs.compareStrings(
+      (left, right) => chunkXMQSEJCF_cjs.compareStrings(
         `${left.entityId}|${left.property}`,
         `${right.entityId}|${right.property}`
       )
@@ -2086,7 +3241,7 @@ function validateResolveMap(resolve) {
     return {};
   }
   const configs = resolve;
-  const validated = {};
+  const validated = chunkN66HCGCY_cjs.createDataKeyedBag();
   for (const [kind, config] of Object.entries(configs)) {
     const parsed = resolveConfigScalarSchema.safeParse({
       threshold: config.threshold
@@ -2114,7 +3269,7 @@ function validateResolveMap(resolve) {
     }
     validated[kind] = config;
   }
-  return validated;
+  return { ...validated };
 }
 function validateProvenanceWeights(weights) {
   for (const [branchId, weight] of weights) {
@@ -2169,7 +3324,9 @@ function normalizeMergeOptions(options = {}) {
     ...provenanceWeights === void 0 ? {} : { provenanceWeights }
   };
 }
-var Provenance = chunkBNS75YNF_cjs.defineNode("Provenance", {
+var PROVENANCE_KIND = "Provenance";
+var PROVENANCE_OWNER_KIND = "ProvenanceOwner";
+var Provenance = chunkNK5Q7UNE_cjs.defineNode(PROVENANCE_KIND, {
   schema: zod.z.object({
     targetGraphId: zod.z.string(),
     role: zod.z.enum(["node", "edge"]),
@@ -2179,38 +3336,308 @@ var Provenance = chunkBNS75YNF_cjs.defineNode("Provenance", {
     sourceId: zod.z.string()
   })
 });
+var PROVENANCE_OWNER = "@nicia-ai/typegraph/merge-provenance";
+var PROVENANCE_OWNER_VERSION = 1;
+var PROVENANCE_OWNER_ID = "merge-provenance-owner";
+var ProvenanceOwner = chunkNK5Q7UNE_cjs.defineNode(PROVENANCE_OWNER_KIND, {
+  schema: zod.z.object({
+    owner: zod.z.literal(PROVENANCE_OWNER),
+    version: zod.z.literal(PROVENANCE_OWNER_VERSION),
+    targetGraphId: zod.z.string()
+  })
+});
 function provenanceGraphId(targetGraphId) {
   return `${targetGraphId}::merge-provenance`;
 }
-function buildProvenanceGraph(targetGraphId) {
-  return chunkQB6VMOJ2_cjs.defineGraph({
-    id: provenanceGraphId(targetGraphId),
-    nodes: { Provenance: { type: Provenance } },
-    edges: {}
+function buildOwnedProvenanceGraph(targetGraphId) {
+  return chunkCXBHOOIQ_cjs.defineInternalGraph({
+    id: provenanceGraphId(targetGraphId),
+    nodes: {
+      Provenance: { type: Provenance },
+      ProvenanceOwner: { type: ProvenanceOwner }
+    },
+    edges: {}
+  });
+}
+function buildProvenanceGraph(targetGraphId) {
+  return chunkCXBHOOIQ_cjs.defineInternalGraph({
+    id: provenanceGraphId(targetGraphId),
+    nodes: { Provenance: { type: Provenance } },
+    edges: {}
+  });
+}
+async function openProvenanceStore(...args) {
+  const [backend, targetGraphId] = args.length === 1 ? [chunkTTAITEPJ_cjs.storeBackend(args[0]), args[0].graphId] : args;
+  const graph = buildOwnedProvenanceGraph(targetGraphId);
+  const preflight = await inspectSidecarGraphId(backend, graph, targetGraphId);
+  if (preflight.state === "refuse") {
+    throw provenanceGraphIdCollision(graph.id, targetGraphId, preflight.reason);
+  }
+  if (preflight.state !== "owned") {
+    const claim = await claimSidecarOwnership(backend, graph, targetGraphId);
+    if (claim.state === "refuse") {
+      throw provenanceGraphIdCollision(graph.id, targetGraphId, claim.reason);
+    }
+  }
+  const [store] = await chunkXDF2UPEQ_cjs.createStoreWithSchema(graph, backend);
+  return store;
+}
+async function claimSidecarOwnership(backend, graph, targetGraphId) {
+  const fence = backend.schemaWriteTransaction;
+  if (fence === void 0) {
+    throw provenanceClaimUnfenced(graph.id, targetGraphId);
+  }
+  return fence(graph.id, async (tx) => {
+    await drainUnfencedRowWriters(tx);
+    const verdict = await inspectSidecarGraphId(tx, graph, targetGraphId);
+    if (verdict.state === "refuse" || verdict.state === "owned") return verdict;
+    await tx.insertNode({
+      graphId: graph.id,
+      kind: PROVENANCE_OWNER_KIND,
+      id: PROVENANCE_OWNER_ID,
+      props: {
+        owner: PROVENANCE_OWNER,
+        version: PROVENANCE_OWNER_VERSION,
+        targetGraphId
+      }
+    });
+    return verdict;
+  });
+}
+async function drainUnfencedRowWriters(tx) {
+  if (tx.dialect !== "postgres") return;
+  const schema = chunkNFCVHQ5P_cjs.createSqlSchema(tx.tableNames);
+  await tx.executeStatement(
+    chunkVCRRKBLN_cjs.asCompiledStatementSql(
+      chunkVCRRKBLN_cjs.sql`LOCK TABLE ${schema.nodesTable}, ${schema.edgesTable} IN SHARE ROW EXCLUSIVE MODE`
+    )
+  );
+}
+async function inspectSidecarGraphId(port, graph, targetGraphId) {
+  const activeSchema = await port.getActiveSchema(graph.id);
+  if (activeSchema === void 0 && !await hasRowsUnderGraphId(port, graph.id, "any")) {
+    return { state: "create" };
+  }
+  const marker = await inspectOwnerMarker(port, graph.id, targetGraphId);
+  if (marker === "foreign") {
+    return { state: "refuse", reason: "corrupt-ownership-marker" };
+  }
+  if (marker === "ours") {
+    return { state: "owned" };
+  }
+  if (activeSchema === void 0) {
+    return { state: "refuse", reason: "application-graph" };
+  }
+  const ownedHash = await chunkN3257XE6_cjs.computeSchemaHash(
+    chunkN3257XE6_cjs.serializeSchema(graph, activeSchema.version)
+  );
+  if (activeSchema.schema_hash === ownedHash) {
+    return { state: "refuse", reason: "unowned-exact-schema-graph" };
+  }
+  const legacyHash = await chunkN3257XE6_cjs.computeSchemaHash(
+    chunkN3257XE6_cjs.serializeSchema(buildProvenanceGraph(targetGraphId), activeSchema.version)
+  );
+  if (activeSchema.schema_hash !== legacyHash) {
+    return { state: "refuse", reason: "application-graph" };
+  }
+  return LEGACY_SCHEMA_DISPOSITION[await inspectSidecarContents(port, graph.id, targetGraphId)];
+}
+var LEGACY_SCHEMA_DISPOSITION = {
+  provenance: { state: "upgrade" },
+  empty: { state: "refuse", reason: "empty-legacy-sidecar" },
+  "unrecognized-provenance": {
+    state: "refuse",
+    reason: "unupgradeable-legacy-sidecar"
+  },
+  "foreign-rows": { state: "refuse", reason: "application-graph" }
+};
+var SIDECAR_REFUSALS = {
+  "application-graph": {
+    describe: (graphId) => `Graph id "${graphId}" is already used by an application graph and cannot host merge provenance.`,
+    suggestion: () => "Rename the colliding application graph before enabling persisted merge provenance for this target."
+  },
+  "corrupt-ownership-marker": {
+    describe: (graphId, targetGraphId) => `Graph id "${graphId}" holds a "${PROVENANCE_OWNER_KIND}" row that is not a valid ownership claim for target "${targetGraphId}" \u2014 it is soft-deleted, does not validate against the marker schema, names a different target, or sits under a different row id.`,
+    suggestion: (graphId) => `Do not re-run: an unverifiable marker is never overwritten or resurrected, because it may be an application's row. Inspect the "${PROVENANCE_OWNER_KIND}" rows under graph id "${graphId}" and hard-delete the invalid one, or drop that graph id entirely \u2014 persisted provenance is derived, so re-running the merge rebuilds it.`
+  },
+  "empty-legacy-sidecar": {
+    describe: (graphId) => `Graph id "${graphId}" holds an EMPTY provenance sidecar from a release that wrote no ownership marker, which cannot be told apart from an application graph of the same shape.`,
+    suggestion: (graphId) => `Drop graph id "${graphId}" \u2014 it holds no provenance records, so nothing is lost \u2014 and re-run the merge to create an owned sidecar.`
+  },
+  "unupgradeable-legacy-sidecar": {
+    describe: (graphId, targetGraphId) => `Graph id "${graphId}" holds a pre-marker provenance sidecar whose rows do not verify as provenance for target "${targetGraphId}", so it cannot be upgraded to an owned sidecar.`,
+    suggestion: (graphId) => `Export anything you still need from graph id "${graphId}", then drop it: provenance is derived, and re-running the merge rebuilds an owned sidecar.`
+  },
+  "unowned-exact-schema-graph": {
+    describe: (graphId) => `Graph id "${graphId}" carries the merge-provenance schema but no ownership marker, so this library did not create it.`,
+    suggestion: (graphId) => `Drop graph id "${graphId}" (or rename the graph that occupies it) and re-run the merge: a sidecar this library owns writes its "${PROVENANCE_OWNER}" marker row BEFORE the schema, so a marker-less one carrying this schema was written either by an application \u2014 which is never adopted \u2014 or by a crash of an unreleased build between those two writes. Persisted provenance is derived, so re-running the merge rebuilds it.`
+  }
+};
+function provenanceGraphIdCollision(graphId, targetGraphId, reason) {
+  const refusal = SIDECAR_REFUSALS[reason];
+  return new chunkNI72YOJB_cjs.ConfigurationError(
+    refusal.describe(graphId, targetGraphId),
+    {
+      code: "GRAPH_MERGE_PROVENANCE_ID_COLLISION",
+      reason,
+      graphId,
+      targetGraphId
+    },
+    { suggestion: refusal.suggestion(graphId) }
+  );
+}
+function provenanceClaimUnfenced(graphId, targetGraphId) {
+  return new chunkNI72YOJB_cjs.ConfigurationError(
+    `Claiming graph id "${graphId}" for merge provenance requires a transactional schema fence, which this backend does not provide.`,
+    {
+      code: "GRAPH_MERGE_PROVENANCE_CLAIM_UNFENCED",
+      graphId,
+      targetGraphId
+    },
+    {
+      suggestion: "Use a backend that implements schemaWriteTransaction (both bundled Drizzle backends do when transactions are enabled); without it the sidecar's emptiness check and its ownership write cannot be committed as one unit. An ALREADY-owned sidecar opens without a claim."
+    }
+  );
+}
+function isOwnedMarkerRow(row, targetGraphId) {
+  if (row.id !== PROVENANCE_OWNER_ID) return false;
+  if (row.deleted_at !== void 0) return false;
+  const parsed = ProvenanceOwner.schema.safeParse(parseRowProps(row.props));
+  return parsed.success && parsed.data.targetGraphId === targetGraphId;
+}
+async function inspectOwnerMarker(port, graphId, targetGraphId) {
+  let ours = false;
+  for await (const row of readRowsOfKind(
+    port,
+    graphId,
+    PROVENANCE_OWNER_KIND
+  )) {
+    if (!isOwnedMarkerRow(row, targetGraphId)) return "foreign";
+    ours = true;
+  }
+  return ours ? "ours" : "absent";
+}
+var SIDECAR_PAGE_SIZE = 500;
+async function* readRowsOfKind(port, graphId, kind) {
+  let after;
+  for (; ; ) {
+    const rows = await port.findNodesByKind({
+      graphId,
+      kind,
+      temporalMode: "includeTombstones",
+      excludeDeleted: false,
+      orderBy: "id",
+      ...after === void 0 ? {} : { after },
+      limit: SIDECAR_PAGE_SIZE
+    });
+    for (const row of rows) {
+      yield row;
+    }
+    if (rows.length < SIDECAR_PAGE_SIZE) return;
+    after = rows.at(-1)?.id;
+    if (after === void 0) return;
+  }
+}
+async function hasRowsUnderGraphId(port, graphId, scope) {
+  const schema = chunkNFCVHQ5P_cjs.createSqlSchema(port.tableNames);
+  const kindFilter = scope === "any" ? chunkVCRRKBLN_cjs.sql.empty() : chunkVCRRKBLN_cjs.sql` AND kind <> ${PROVENANCE_KIND}`;
+  if (await hasRowsInTable(port, schema.tables.nodes, graphId, kindFilter)) {
+    return true;
+  }
+  if (await hasRowsInTable(port, schema.tables.edges, graphId, chunkVCRRKBLN_cjs.sql.empty())) {
+    return true;
+  }
+  for (const tableName of secondaryRowTableNames(schema.tables)) {
+    if (await hasRowsInSecondaryTable(port, tableName, graphId)) return true;
+  }
+  return false;
+}
+function secondaryRowTableNames(tables) {
+  return [
+    .../* @__PURE__ */ new Set([
+      tables.recordedNodes,
+      tables.recordedEdges,
+      tables.recordedClock,
+      tables.revisionOrigins,
+      tables.identityAssertions,
+      tables.recordedIdentityAssertions,
+      tables.identityClosure,
+      tables.identitySeparation,
+      tables.fulltext,
+      tables.uniques
+    ])
+  ];
+}
+async function hasRowsInTable(port, tableName, graphId, filter) {
+  const rows = await port.execute(
+    chunkVCRRKBLN_cjs.asCompiledRowsSql(
+      chunkVCRRKBLN_cjs.sql`SELECT 1 AS present FROM ${chunkVCRRKBLN_cjs.sql.identifier(tableName)} WHERE graph_id = ${graphId}${filter} LIMIT 1`
+    )
+  );
+  return rows.length > 0;
+}
+async function hasRowsInSecondaryTable(port, tableName, graphId) {
+  const tableExists = port.tableExists;
+  if (tableExists !== void 0) {
+    return await tableExists(tableName) && await hasRowsInTable(port, tableName, graphId, chunkVCRRKBLN_cjs.sql.empty());
+  }
+  try {
+    return await hasRowsInTable(port, tableName, graphId, chunkVCRRKBLN_cjs.sql.empty());
+  } catch {
+    return false;
+  }
+}
+async function inspectSidecarContents(port, graphId, targetGraphId) {
+  if (await hasRowsUnderGraphId(port, graphId, "foreign")) {
+    return "foreign-rows";
+  }
+  let rowCount = 0;
+  for await (const row of readRowsOfKind(port, graphId, PROVENANCE_KIND)) {
+    if (!await isOwnedProvenanceRow(row, targetGraphId)) {
+      return "unrecognized-provenance";
+    }
+    rowCount += 1;
+  }
+  return rowCount > 0 ? "provenance" : "empty";
+}
+async function isOwnedProvenanceRow(row, targetGraphId) {
+  if (row.deleted_at !== void 0) return false;
+  const parsed = Provenance.schema.safeParse(parseRowProps(row.props));
+  if (!parsed.success || parsed.data.targetGraphId !== targetGraphId) {
+    return false;
+  }
+  const expectedId = await provenanceNodeId(targetGraphId, {
+    role: parsed.data.role,
+    canonicalId: parsed.data.canonicalId,
+    canonicalKind: parsed.data.canonicalKind,
+    branchId: asBranchId(parsed.data.branchId),
+    sourceId: parsed.data.sourceId
   });
-}
-async function openProvenanceStore(...args) {
-  const [backend, targetGraphId] = args.length === 1 ? [chunkJ7LXTUTP_cjs.storeBackend(args[0]), args[0].graphId] : args;
-  const [store] = await chunkYOALGKRE_cjs.createStoreWithSchema(
-    buildProvenanceGraph(targetGraphId),
-    backend
-  );
-  return store;
+  return row.id === expectedId;
 }
 var ID_SEPARATOR = "\0";
 var ID_DIGEST_BYTES = 16;
+function contributionKey(record) {
+  return encodeProvenanceTuple([
+    record.role,
+    record.canonicalKind,
+    record.canonicalId,
+    record.branchId,
+    record.sourceId
+  ]);
+}
+function encodeProvenanceTuple(values) {
+  return values.some((value) => value.includes(ID_SEPARATOR)) ? chunkXNLIZYRZ_cjs.encodeTupleKey(values) : values.join(ID_SEPARATOR);
+}
 async function provenanceNodeId(targetGraphId, record) {
-  const tuple = [
+  const tuple = encodeProvenanceTuple([
     targetGraphId,
     record.role,
-    // canonicalKind is part of node identity: two contributions to different-kind
-    // canonicals that share a bare id (e.g. base Patient:x and Encounter:x) must NOT
-    // hash to the same sidecar row and clobber each other (the (kind,id) identity model).
     record.canonicalKind,
     record.canonicalId,
     record.branchId,
     record.sourceId
-  ].join(ID_SEPARATOR);
+  ]);
   const digest = await chunkZY4GXIVN_cjs.sha256Hex(tuple, ID_DIGEST_BYTES);
   return `prov_${digest}`;
 }
@@ -2218,7 +3645,7 @@ async function persistProvenanceRecords(store, targetGraphId, records) {
   if (records.length === 0) {
     return 0;
   }
-  const items = await Promise.all(
+  const identified = await Promise.all(
     records.map(async (record) => ({
       id: await provenanceNodeId(targetGraphId, record),
       props: {
@@ -2231,6 +3658,11 @@ async function persistProvenanceRecords(store, targetGraphId, records) {
       }
     }))
   );
+  const itemsById = /* @__PURE__ */ new Map();
+  for (const item of identified) {
+    itemsById.set(item.id, item);
+  }
+  const items = [...itemsById.values()];
   await store.nodes.Provenance.bulkUpsertById(items);
   return items.length;
 }
@@ -2238,7 +3670,7 @@ async function readProvenance(store, query = {}) {
   const all = await store.nodes.Provenance.find();
   return all.filter(
     (node) => (query.branchId === void 0 || node.branchId === query.branchId) && (query.canonicalId === void 0 || node.canonicalId === query.canonicalId) && (query.role === void 0 || node.role === query.role)
-  ).sort((left, right) => chunkTRF4EBJT_cjs.compareStrings(left.id, right.id));
+  ).sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left.id, right.id));
 }
 
 // src/graph-merge/sources.ts
@@ -2248,14 +3680,14 @@ function orderEndpoints(left, right) {
   return compareMergeKeys(leftKey, rightKey) <= 0 ? { a: leftKey, b: rightKey, left, right } : { a: rightKey, b: leftKey, left: right, right: left };
 }
 function sortMembersById(members) {
-  return [...members].sort((left, right) => chunkTRF4EBJT_cjs.compareStrings(left.id, right.id));
+  return [...members].sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left.id, right.id));
 }
 function sortedBucketKeys(blocks) {
-  return [...blocks.keys()].sort((left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right));
+  return [...blocks.keys()].sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right));
 }
 var NODE_SYSTEM_FIELDS = /* @__PURE__ */ new Set(["id", "kind", "meta"]);
 function nodeProps(node) {
-  const props = {};
+  const props = chunkN66HCGCY_cjs.createDataKeyedBag();
   for (const [key, value] of Object.entries(
     node
   )) {
@@ -2279,7 +3711,7 @@ function windowedPairs(members, config) {
     key: fieldText(node, config.sortFields)
   }));
   keyed.sort(
-    (left, right) => left.key === right.key ? chunkTRF4EBJT_cjs.compareStrings(left.node.id, right.node.id) : chunkTRF4EBJT_cjs.compareStrings(left.key, right.key)
+    (left, right) => left.key === right.key ? chunkXMQSEJCF_cjs.compareStrings(left.node.id, right.node.id) : chunkXMQSEJCF_cjs.compareStrings(left.key, right.key)
   );
   const pairs = [];
   for (let index = 0; index < keyed.length; index += 1) {
@@ -2287,8 +3719,8 @@ function windowedPairs(members, config) {
     for (let index_ = index + 1; index_ <= last; index_ += 1) {
       pairs.push(
         orderEndpoints(
-          chunk764JHTLT_cjs.requireDefined(keyed[index]).node,
-          chunk764JHTLT_cjs.requireDefined(keyed[index_]).node
+          chunkN66HCGCY_cjs.requireDefined(keyed[index]).node,
+          chunkN66HCGCY_cjs.requireDefined(keyed[index_]).node
         )
       );
     }
@@ -2310,8 +3742,8 @@ function pairsFromBlocks(blocks, keyless) {
       for (let index_ = index + 1; index_ < members.length; index_ += 1) {
         pairs.push(
           orderEndpoints(
-            chunk764JHTLT_cjs.requireDefined(members[index]),
-            chunk764JHTLT_cjs.requireDefined(members[index_])
+            chunkN66HCGCY_cjs.requireDefined(members[index]),
+            chunkN66HCGCY_cjs.requireDefined(members[index_])
           )
         );
       }
@@ -2329,8 +3761,8 @@ function forcedEdgesFromBlocks(blocks) {
     for (let index = 0; index < members.length; index += 1) {
       for (let index_ = index + 1; index_ < members.length; index_ += 1) {
         const { a, b } = orderEndpoints(
-          chunk764JHTLT_cjs.requireDefined(members[index]),
-          chunk764JHTLT_cjs.requireDefined(members[index_])
+          chunkN66HCGCY_cjs.requireDefined(members[index]),
+          chunkN66HCGCY_cjs.requireDefined(members[index_])
         );
         edges.push({ a, b, score: FORCED_MATCH_SCORE });
       }
@@ -2350,7 +3782,7 @@ function ontologyRetypeEdges(stagedIdentities, isRetypeCompatible) {
     }
   }
   const edges = [];
-  for (const id of [...identitiesById.keys()].sort(chunkTRF4EBJT_cjs.compareStrings)) {
+  for (const id of [...identitiesById.keys()].sort(chunkXMQSEJCF_cjs.compareStrings)) {
     const identities = [...new Set(identitiesById.get(id))].sort(
       compareMergeKeys
     );
@@ -2364,8 +3796,8 @@ function ontologyRetypeEdges(stagedIdentities, isRetypeCompatible) {
       }
       for (let index = 1; index < members.length; index += 1) {
         edges.push({
-          a: chunk764JHTLT_cjs.requireDefined(members[0]),
-          b: chunk764JHTLT_cjs.requireDefined(members[index]),
+          a: chunkN66HCGCY_cjs.requireDefined(members[0]),
+          b: chunkN66HCGCY_cjs.requireDefined(members[index]),
           score: FORCED_MATCH_SCORE
         });
       }
@@ -2381,12 +3813,12 @@ 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(chunk764JHTLT_cjs.requireDefined(identities[index])),
-        kindOf(chunk764JHTLT_cjs.requireDefined(identities[index_]))
+        kindOf(chunkN66HCGCY_cjs.requireDefined(identities[index])),
+        kindOf(chunkN66HCGCY_cjs.requireDefined(identities[index_]))
       ])) {
         forest.union(
-          chunk764JHTLT_cjs.requireDefined(identities[index]),
-          chunk764JHTLT_cjs.requireDefined(identities[index_])
+          chunkN66HCGCY_cjs.requireDefined(identities[index]),
+          chunkN66HCGCY_cjs.requireDefined(identities[index_])
         );
       }
     }
@@ -2398,7 +3830,7 @@ function unionByCompatibility(identities, isRetypeCompatible) {
 function groupsOf(identities, representativeOf) {
   const byRoot = /* @__PURE__ */ new Map();
   for (const identity of identities) {
-    const root = chunk764JHTLT_cjs.requireDefined(representativeOf.get(identity));
+    const root = chunkN66HCGCY_cjs.requireDefined(representativeOf.get(identity));
     const bucket = byRoot.get(root);
     if (bucket === void 0) {
       byRoot.set(root, [identity]);
@@ -2445,7 +3877,7 @@ var baseUniqueSource = {
     const forcedEdges = [];
     const baseMembers = /* @__PURE__ */ new Map();
     const constraints = [...uniqueConstraints].sort(
-      (left, right) => chunkTRF4EBJT_cjs.compareStrings(left.name, right.name)
+      (left, right) => chunkXMQSEJCF_cjs.compareStrings(left.name, right.name)
     );
     const items = nodes.map((node) => ({ props: nodeProps(node) }));
     const matchesByConstraint = await Promise.all(
@@ -2488,7 +3920,7 @@ var baseUniqueSource = {
       pairs: [],
       forcedEdges,
       baseMembers: [...baseMembers.values()].sort(
-        (left, right) => chunkTRF4EBJT_cjs.compareStrings(left.id, right.id)
+        (left, right) => chunkXMQSEJCF_cjs.compareStrings(left.id, right.id)
       )
     };
   }
@@ -2545,7 +3977,7 @@ var baseKeySource = {
       pairs,
       forcedEdges: [],
       baseMembers: [...baseMembers.values()].sort(
-        (left, right) => chunkTRF4EBJT_cjs.compareStrings(left.id, right.id)
+        (left, right) => chunkXMQSEJCF_cjs.compareStrings(left.id, right.id)
       )
     };
   }
@@ -2557,16 +3989,16 @@ var CANDIDATE_SOURCES = [
 
 // src/graph-merge/staging.ts
 function compareByIdThenBranch(left, right) {
-  const byId2 = chunkTRF4EBJT_cjs.compareStrings(left.id, right.id);
-  return byId2 === 0 ? chunkTRF4EBJT_cjs.compareStrings(left.branchId, right.branchId) : byId2;
+  const byId2 = chunkXMQSEJCF_cjs.compareStrings(left.id, right.id);
+  return byId2 === 0 ? chunkXMQSEJCF_cjs.compareStrings(left.branchId, right.branchId) : byId2;
 }
 function compareByKindIdBranch(left, right) {
-  const byKind = chunkTRF4EBJT_cjs.compareStrings(left.kind, right.kind);
+  const byKind = chunkXMQSEJCF_cjs.compareStrings(left.kind, right.kind);
   if (byKind !== 0) {
     return byKind;
   }
-  const byId2 = chunkTRF4EBJT_cjs.compareStrings(left.id, right.id);
-  return byId2 === 0 ? chunkTRF4EBJT_cjs.compareStrings(left.branchId, right.branchId) : byId2;
+  const byId2 = chunkXMQSEJCF_cjs.compareStrings(left.id, right.id);
+  return byId2 === 0 ? chunkXMQSEJCF_cjs.compareStrings(left.branchId, right.branchId) : byId2;
 }
 function groupByKind(items) {
   const buckets = /* @__PURE__ */ new Map();
@@ -2580,11 +4012,11 @@ function groupByKind(items) {
   }
   const ordered = /* @__PURE__ */ new Map();
   for (const kind of [...buckets.keys()].sort(
-    (left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right)
+    (left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right)
   )) {
     ordered.set(
       kind,
-      [...chunk764JHTLT_cjs.requireDefined(buckets.get(kind))].sort(
+      [...chunkN66HCGCY_cjs.requireDefined(buckets.get(kind))].sort(
         (left, right) => compareByIdThenBranch(left, right)
       )
     );
@@ -2598,6 +4030,11 @@ async function stageBranches(baseStore, branches, captureTargetStateFor) {
   const newEdges = [];
   const modifiedEdges = [];
   const deletedEdges = [];
+  const windowedNodes = [];
+  const windowedEdges = [];
+  const newIdentityAssertions = [];
+  const retractedIdentityAssertions = [];
+  const baseIdentityAssertions = await chunkTTAITEPJ_cjs.storeRuntime(baseStore).readCurrentIdentityAssertions("state");
   let targetNodeVersions = /* @__PURE__ */ new Map();
   let targetEdgeSignatures = /* @__PURE__ */ new Map();
   for (const branch2 of branches) {
@@ -2629,6 +4066,22 @@ async function stageBranches(baseStore, branches, captureTargetStateFor) {
     for (const edge of diff.edges.deleted) {
       deletedEdges.push({ branchId, edge, kind: edge.kind, id: edge.id });
     }
+    for (const node of diff.nodes.windowed) {
+      windowedNodes.push({ branchId, node, kind: node.kind, id: node.id });
+    }
+    for (const edge of diff.edges.windowed) {
+      windowedEdges.push({ branchId, edge, kind: edge.kind, id: edge.id });
+    }
+    for (const assertion of diff.identity.new) {
+      newIdentityAssertions.push({ branchId, assertion });
+    }
+    for (const retraction of diff.identity.retracted) {
+      retractedIdentityAssertions.push({
+        branchId,
+        assertion: retraction.assertion,
+        cause: retraction.cause
+      });
+    }
   }
   return {
     newNodesByKind: groupByKind(newNodes),
@@ -2645,6 +4098,25 @@ async function stageBranches(baseStore, branches, captureTargetStateFor) {
     deletedEdges: [...deletedEdges].sort(
       (left, right) => compareByKindIdBranch(left, right)
     ),
+    windowedNodes: [...windowedNodes].sort(
+      (left, right) => compareByKindIdBranch(left, right)
+    ),
+    windowedEdges: [...windowedEdges].sort(
+      (left, right) => compareByKindIdBranch(left, right)
+    ),
+    newIdentityAssertions: newIdentityAssertions.toSorted((left, right) => {
+      const byId2 = chunkXMQSEJCF_cjs.compareStrings(left.assertion.id, right.assertion.id);
+      return byId2 === 0 ? chunkXMQSEJCF_cjs.compareStrings(left.branchId, right.branchId) : byId2;
+    }),
+    retractedIdentityAssertions: retractedIdentityAssertions.toSorted(
+      (left, right) => {
+        const byId2 = chunkXMQSEJCF_cjs.compareStrings(left.assertion.id, right.assertion.id);
+        return byId2 === 0 ? chunkXMQSEJCF_cjs.compareStrings(left.branchId, right.branchId) : byId2;
+      }
+    ),
+    baseIdentityAssertions: baseIdentityAssertions.toSorted(
+      (left, right) => chunkXMQSEJCF_cjs.compareStrings(left.id, right.id)
+    ),
     targetNodeVersions,
     targetEdgeSignatures
   };
@@ -2695,7 +4167,7 @@ async function withTxConflictRetry(commit) {
 // src/graph-merge/type-reconcile.ts
 var INCOMPATIBLE_TYPES_FLAG_REASON = "type-reconcile:incompatible-kinds";
 function distinctKinds(kinds) {
-  return [...new Set(kinds)].sort((left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right));
+  return [...new Set(kinds)].sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right));
 }
 function areEquivalent(closure, left, right) {
   return left !== right && isReachable2(closure, left, right) && isReachable2(closure, right, left);
@@ -2713,8 +4185,8 @@ function mostSpecificCommonKind(closure, kinds) {
   if (qualifiers.length === 0) {
     return void 0;
   }
-  return chunk764JHTLT_cjs.requireDefined(
-    [...qualifiers].sort((left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right))[0]
+  return chunkN66HCGCY_cjs.requireDefined(
+    [...qualifiers].sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right))[0]
   );
 }
 function reconcileTypes(clusters, closure, mode) {
@@ -2752,15 +4224,14 @@ function reconcileTypes(clusters, closure, mode) {
   }
   return {
     reconciliations: reconciliations.sort(
-      (left, right) => chunkTRF4EBJT_cjs.compareStrings(left.entityId, right.entityId)
+      (left, right) => chunkXMQSEJCF_cjs.compareStrings(left.entityId, right.entityId)
     ),
     retypeMap,
-    dropped: dropped.sort((left, right) => chunkTRF4EBJT_cjs.compareStrings(left.id, right.id))
+    dropped: dropped.sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left.id, right.id))
   };
 }
 
 // src/graph-merge/merge.ts
-var COMMITTED_TARGET_BRANCH = asBranchId("__committed_target__");
 function asNode(staged) {
   return {
     kind: staged.node.kind,
@@ -2774,8 +4245,8 @@ function newNodesByKind(staging) {
     ordered.set(
       kind,
       [...items].sort((left, right) => {
-        const byId2 = chunkTRF4EBJT_cjs.compareStrings(left.node.id, right.node.id);
-        return byId2 === 0 ? chunkTRF4EBJT_cjs.compareStrings(left.branchId, right.branchId) : byId2;
+        const byId2 = chunkXMQSEJCF_cjs.compareStrings(left.node.id, right.node.id);
+        return byId2 === 0 ? chunkXMQSEJCF_cjs.compareStrings(left.branchId, right.branchId) : byId2;
       })
     );
   }
@@ -2802,12 +4273,14 @@ async function precomputeEmbeddings(byKind, resolve, embedder) {
       }
     }
   }
-  const lookup = /* @__PURE__ */ new Map();
   if (texts.size === 0) {
-    return lookup;
+    return /* @__PURE__ */ new Map();
   }
+  return embedSortedTexts(texts, embedder);
+}
+async function embedSortedTexts(texts, embedder) {
   const orderedTexts = [...texts].sort(
-    (left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right)
+    (left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right)
   );
   const vectors = await embedder(orderedTexts);
   if (vectors.length !== orderedTexts.length) {
@@ -2819,8 +4292,9 @@ async function precomputeEmbeddings(byKind, resolve, embedder) {
       }
     );
   }
+  const lookup = /* @__PURE__ */ new Map();
   for (const [index, text] of orderedTexts.entries()) {
-    lookup.set(text, chunk764JHTLT_cjs.requireDefined(vectors[index]));
+    lookup.set(text, chunkN66HCGCY_cjs.requireDefined(vectors[index]));
   }
   return lookup;
 }
@@ -2842,24 +4316,7 @@ async function embedMissingPairTexts(base, pairs, strategy, embedder) {
   if (missing.size === 0) {
     return existing;
   }
-  const orderedTexts = [...missing].sort(
-    (left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right)
-  );
-  const vectors = await embedder(orderedTexts);
-  if (vectors.length !== orderedTexts.length) {
-    throw new MergeError(
-      `Embedder returned ${vectors.length} vectors for ${orderedTexts.length} texts; expected exactly one per text.`,
-      {
-        details: { texts: orderedTexts.length, vectors: vectors.length },
-        suggestion: "Ensure MergeOptions.embedder returns one vector per input text, in order."
-      }
-    );
-  }
-  const augmented = new Map(existing);
-  for (const [index, text] of orderedTexts.entries()) {
-    augmented.set(text, chunk764JHTLT_cjs.requireDefined(vectors[index]));
-  }
-  return augmented;
+  return new Map([...existing, ...await embedSortedTexts(missing, embedder)]);
 }
 async function generateAllCandidates(target, staging, options, introspectionKinds, ctx, useBaseSources, embedder) {
   const allEdges = [];
@@ -2873,7 +4330,7 @@ async function generateAllCandidates(target, staging, options, introspectionKind
       async ([kind, items]) => {
         const resolveConfig = options.resolve[kind];
         if (resolveConfig === void 0) {
-          return chunkJ2ICGNHO_cjs.ok({ edges: [], warnings: [], baseMembers: [] });
+          return chunk7BQXPCGN_cjs.ok({ edges: [], warnings: [], baseMembers: [] });
         }
         const nodes = items.map((staged) => asNode(staged));
         const uniqueConstraints = uniqueConstraintsFor(
@@ -2916,10 +4373,10 @@ async function generateAllCandidates(target, staging, options, introspectionKind
           options.onComparisonCeiling,
           options.maxComparisonsPerKind
         );
-        if (chunkJ2ICGNHO_cjs.isErr(scored)) {
-          return chunkJ2ICGNHO_cjs.err(scored.error);
+        if (chunk7BQXPCGN_cjs.isErr(scored)) {
+          return chunk7BQXPCGN_cjs.err(scored.error);
         }
-        return chunkJ2ICGNHO_cjs.ok({
+        return chunk7BQXPCGN_cjs.ok({
           edges: scored.data.edges,
           warnings: scored.data.warnings.map(
             (warning) => `[${kind}] ${warning.message}`
@@ -2930,14 +4387,14 @@ async function generateAllCandidates(target, staging, options, introspectionKind
     )
   );
   for (const result of perKind) {
-    if (chunkJ2ICGNHO_cjs.isErr(result)) {
-      return chunkJ2ICGNHO_cjs.err(result.error);
+    if (chunk7BQXPCGN_cjs.isErr(result)) {
+      return chunk7BQXPCGN_cjs.err(result.error);
     }
     allEdges.push(...result.data.edges);
     warnings.push(...result.data.warnings);
     baseMembers.push(...result.data.baseMembers);
   }
-  return chunkJ2ICGNHO_cjs.ok({
+  return chunk7BQXPCGN_cjs.ok({
     // The ONE shared `(a, b)` edge comparator (id-first `(kind, id)` order), so this
     // stage emits edges in exactly the order clustering consumes them.
     edges: allEdges.sort((left, right) => compareCandidateEdges(left, right)),
@@ -2958,7 +4415,9 @@ function clusterMembersFor(cluster, newNodesById, baseMembersById) {
         id: staged.node.id,
         kind: staged.node.kind,
         branchId: staged.branchId,
-        props: staged.node.props
+        props: staged.node.props,
+        ...staged.node.row.valid_from === void 0 ? {} : { validFrom: staged.node.row.valid_from },
+        ...staged.node.row.valid_to === void 0 ? {} : { validTo: staged.node.row.valid_to }
       });
     }
     const base = baseMembersById.get(key);
@@ -2989,37 +4448,70 @@ function indexNewNodesById(staging) {
   }
   return index;
 }
-function buildStagedEdges(staging, modifiedEdges) {
+function buildStagedEdges(staging, modifiedEdges, edgeValidityEnds, edgeDeletions) {
   const staged = [];
+  const stagedIdentities = /* @__PURE__ */ new Set();
+  const windowOnlyCarried = /* @__PURE__ */ new Set();
   for (const items of staging.newEdgesByKind.values()) {
     for (const item of items) {
       staged.push(toStagedEdge(item.branchId, item));
     }
   }
   for (const item of modifiedEdges) {
+    const identity = mergeKeyOf(item.edge);
+    stagedIdentities.add(identity);
+    const validTo = edgeValidityEnds.get(identity);
     staged.push({
       id: item.edge.id,
       kind: item.edge.kind,
+      origin: INHERITED_EDGE_ORIGIN,
       fromId: item.edge.fromId,
       toId: item.edge.toId,
       fromKind: item.edge.fromKind,
       toKind: item.edge.toKind,
       props: item.edge.forkProps,
-      branchId: item.branchId
+      baseProps: item.edge.baseProps,
+      branchId: item.branchId,
+      ...validTo === void 0 ? {} : { validTo }
+    });
+  }
+  for (const item of staging.windowedEdges) {
+    const identity = mergeKeyOf(item.edge);
+    const validTo = edgeValidityEnds.get(identity);
+    if (validTo === void 0 || stagedIdentities.has(identity) || edgeDeletions.has(identity)) {
+      continue;
+    }
+    stagedIdentities.add(identity);
+    windowOnlyCarried.add(identity);
+    staged.push({
+      id: item.edge.id,
+      kind: item.edge.kind,
+      origin: INHERITED_EDGE_ORIGIN,
+      fromId: item.edge.fromId,
+      toId: item.edge.toId,
+      fromKind: item.edge.fromKind,
+      toKind: item.edge.toKind,
+      props: item.edge.props,
+      baseProps: item.edge.baseProps,
+      branchId: item.branchId,
+      validTo
     });
   }
-  return staged;
+  return { edges: staged, windowOnlyCarried };
 }
 function toStagedEdge(branchId, item) {
   return {
     id: item.edge.id,
     kind: item.edge.kind,
+    origin: BRANCH_CREATED_EDGE_ORIGIN,
     fromId: item.edge.fromId,
     toId: item.edge.toId,
     fromKind: item.edge.fromKind,
     toKind: item.edge.toKind,
     props: item.edge.props,
-    branchId
+    branchId,
+    ...item.edge.row.valid_from === void 0 ? {} : { validFrom: item.edge.row.valid_from },
+    ...item.edge.row.valid_to === void 0 ? {} : { validTo: item.edge.row.valid_to }
   };
 }
 function buildProvenanceIndex(records) {
@@ -3040,34 +4532,38 @@ function buildProvenanceIndex(records) {
   for (const [branchId, sets] of byBranch) {
     frozen.set(branchId, {
       nodeIds: [...sets.nodeIds].sort(
-        (left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right)
+        (left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right)
       ),
-      edgeIds: [...sets.edgeIds].sort((left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right)).map((id) => id)
+      edgeIds: [...sets.edgeIds].sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right)).map((id) => id)
     });
   }
   return {
     byBranch: (branchId) => frozen.get(branchId) ?? { nodeIds: [], edgeIds: [] }
   };
 }
-function pushProvenance(records, role, branchId, canonicalId, canonicalKind, sourceId) {
-  records.push({ role, canonicalId, canonicalKind, branchId, sourceId });
-}
 var EMPTY_WEIGHTS = /* @__PURE__ */ new Map();
-function planMerge(staging, candidateEdges, candidateWarnings, baseMembers, options, branchRank, subClassClosure, preferredBranchId) {
+function planMerge(staging, candidateEdges, candidateWarnings, baseMembers, options, branchRank, subClassClosure, identityContext, storedIdentityRowsById, targetPeers, preferredBranchId) {
+  const identity = planIdentityChanges(staging, storedIdentityRowsById);
   const provenanceRecords = [];
+  const recordedContributions = /* @__PURE__ */ new Set();
   const weights = options.provenanceWeights ?? EMPTY_WEIGHTS;
   const recordProvenance = (role, branchId, canonicalId, canonicalKind, sourceId) => {
     if (branchId === preferredBranchId) {
       return;
     }
-    pushProvenance(
-      provenanceRecords,
+    const record = {
       role,
-      branchId,
       canonicalId,
       canonicalKind,
+      branchId,
       sourceId
-    );
+    };
+    const key = contributionKey(record);
+    if (recordedContributions.has(key)) {
+      return;
+    }
+    recordedContributions.add(key);
+    provenanceRecords.push(record);
   };
   const newNodesById = indexNewNodesById(staging);
   const acceptedEndpointKeys = /* @__PURE__ */ new Set();
@@ -3160,6 +4656,34 @@ function planMerge(staging, candidateEdges, candidateWarnings, baseMembers, opti
   for (const deletion of deleteModify.nodeDeletions) {
     nodeDeletions.set(mergeKey(deletion.kind, deletion.id), deletion.kind);
   }
+  const anyDeletionOverruled = staging.deletedNodes.some(
+    (deletion) => !nodeDeletions.has(mergeKey(deletion.node.kind, deletion.node.id))
+  );
+  const stagedRetractionsById = /* @__PURE__ */ new Map();
+  for (const staged of staging.retractedIdentityAssertions) {
+    const contributions = stagedRetractionsById.get(staged.assertion.id) ?? [];
+    contributions.push(staged);
+    stagedRetractionsById.set(staged.assertion.id, contributions);
+  }
+  const overruledRetractionDrops = [];
+  const survivingRetractions = anyDeletionOverruled ? identity.retractions.filter((retraction) => {
+    const contributions = stagedRetractionsById.get(retraction.id) ?? [];
+    const everyContributionOverruled = contributions.length > 0 && contributions.every(
+      (staged) => staged.cause.kind === "cascade" && !nodeDeletions.has(
+        mergeKey(
+          staged.cause.deletedNode.kind,
+          staged.cause.deletedNode.id
+        )
+      )
+    );
+    if (!everyContributionOverruled) return true;
+    overruledRetractionDrops.push({
+      kind: "identity",
+      id: retraction.id,
+      reason: RETRACTION_DELETION_OVERRULED_DROP_REASON
+    });
+    return false;
+  }) : identity.retractions;
   for (const modification of deleteModify.survivingModifications) {
     recordProvenance(
       "node",
@@ -3208,6 +4732,31 @@ function planMerge(staging, candidateEdges, candidateWarnings, baseMembers, opti
   for (const conflict of reconciledEdgeModifications.conflicts) {
     propertyConflicts.push(conflict);
   }
+  const validWindows = resolveValidWindows(
+    staging,
+    new Set(nodeDeletions.keys()),
+    new Set(edgeDeletions.keys()),
+    preferredBranchId
+  );
+  const creditedNodeIdentities = /* @__PURE__ */ new Map();
+  for (const record of provenanceRecords) {
+    if (record.role !== "node" || record.sourceId !== record.canonicalId) {
+      continue;
+    }
+    const identity2 = mergeKey(record.canonicalKind, record.canonicalId);
+    const credited = creditedNodeIdentities.get(identity2) ?? /* @__PURE__ */ new Set();
+    credited.add(record.branchId);
+    creditedNodeIdentities.set(identity2, credited);
+  }
+  for (const [identity2, branchIds] of validWindows.nodeCredits) {
+    for (const branchId of branchIds) {
+      if (creditedNodeIdentities.get(identity2)?.has(branchId) === true) {
+        continue;
+      }
+      const id = idOf(identity2);
+      recordProvenance("node", branchId, id, kindOf(identity2), id);
+    }
+  }
   const reconciliation = reconcileTypes(
     reconcileInputs,
     subClassClosure,
@@ -3221,18 +4770,57 @@ function planMerge(staging, candidateEdges, candidateWarnings, baseMembers, opti
     clusters,
     (cluster) => pickClusterCanonical(cluster, entityByIdentity)
   );
-  const stagedEdges = buildStagedEdges(
+  const identityRemap = remapIdentityAssertionEndpoints(
+    identity.assertions,
+    canonicalOf,
+    reconciliation.retypeMap,
+    storedIdentityRowsById
+  );
+  assertIdentityEndpointsNotDeleted(
+    identityRemap.assertions,
+    nodeDeletions,
+    reconciliation.retypeMap
+  );
+  const identityNodeUniverse = [
+    ...canonicalEntities.filter(
+      (entity) => !nodeDeletions.has(mergeKey(entity.kind, entity.canonicalId))
+    ).map((entity) => ({
+      kind: reconciliation.retypeMap.get(
+        mergeKey(entity.kind, entity.canonicalId)
+      ) ?? entity.kind,
+      id: entity.canonicalId
+    })),
+    ...targetPeers.filter(
+      (node) => !nodeDeletions.has(mergeKey(node.kind, node.id))
+    )
+  ];
+  assertNoContradictoryIdentityClosure(
+    identityRemap.assertions,
+    survivingRetractions.map((retraction) => retraction.id),
+    staging.baseIdentityAssertions,
+    new Set(nodeDeletions.keys()),
+    canonicalOf,
+    reconciliation.retypeMap,
+    identityContext,
+    identityNodeUniverse
+  );
+  const { edges: stagedEdges, windowOnlyCarried } = buildStagedEdges(
     staging,
-    reconciledEdgeModifications.survivingModifications
+    reconciledEdgeModifications.survivingModifications,
+    validWindows.edgeEnds,
+    edgeDeletions
   );
   const stagedEdgeBranches = /* @__PURE__ */ new Map();
   for (const staged of stagedEdges) {
-    const branches = stagedEdgeBranches.get(staged.id);
-    if (branches === void 0) {
-      stagedEdgeBranches.set(staged.id, /* @__PURE__ */ new Set([staged.branchId]));
-    } else {
+    const identity2 = mergeKeyOf(staged);
+    const branches = stagedEdgeBranches.get(staged.id) ?? /* @__PURE__ */ new Set();
+    if (!windowOnlyCarried.has(identity2)) {
       branches.add(staged.branchId);
     }
+    for (const branchId of validWindows.edgeCredits.get(identity2) ?? []) {
+      branches.add(branchId);
+    }
+    stagedEdgeBranches.set(staged.id, branches);
   }
   const deletedNodeIdSet = new Set(nodeDeletions.keys());
   const repoint2 = repointEdges(
@@ -3255,9 +4843,13 @@ function planMerge(staging, candidateEdges, candidateWarnings, baseMembers, opti
     ...deleteModify.dropped,
     ...edgeDeleteModify.dropped,
     ...repoint2.dropped,
-    ...reconciliation.dropped
+    ...reconciliation.dropped,
+    ...identity.dropped,
+    ...overruledRetractionDrops,
+    ...identityRemap.dropped,
+    ...validWindows.dropped
   ].sort(
-    (left, right) => chunkTRF4EBJT_cjs.compareStrings(`${left.kind}|${left.id}`, `${right.kind}|${right.id}`)
+    (left, right) => chunkXMQSEJCF_cjs.compareStrings(`${left.kind}|${left.id}`, `${right.kind}|${right.id}`)
   );
   return {
     canonicalEntities,
@@ -3272,6 +4864,10 @@ function planMerge(staging, candidateEdges, candidateWarnings, baseMembers, opti
       ])
     ),
     retypeMap: reconciliation.retypeMap,
+    canonicalOf,
+    nodeValidityEnds: validWindows.nodeEnds,
+    edgeValidityEnds: validWindows.edgeEnds,
+    validityEnds: validWindows.resolutions,
     // Order report arrays by the composite (kind, id) identity — never a bare id
     // or a `|`-joined string. A bare id ties two different-kind entities that
     // share an id, and a `|` separator collides on caller-supplied ids/property
@@ -3290,7 +4886,7 @@ function planMerge(staging, candidateEdges, candidateWarnings, baseMembers, opti
           mergeKey(left.kind, left.entityId),
           mergeKey(right.kind, right.entityId)
         );
-        return byEntity === 0 ? chunkTRF4EBJT_cjs.compareStrings(left.property, right.property) : byEntity;
+        return byEntity === 0 ? chunkXMQSEJCF_cjs.compareStrings(left.property, right.property) : byEntity;
       }
     ),
     deleteModifyConflicts: [
@@ -3307,17 +4903,19 @@ function planMerge(staging, candidateEdges, candidateWarnings, baseMembers, opti
     baseAmbiguities: baseAmbiguities.sort(
       (left, right) => compareMergeKeys(
         mergeKey(
-          chunk764JHTLT_cjs.requireDefined(left.baseIds[0]).kind,
-          chunk764JHTLT_cjs.requireDefined(left.baseIds[0]).id
+          chunkN66HCGCY_cjs.requireDefined(left.baseIds[0]).kind,
+          chunkN66HCGCY_cjs.requireDefined(left.baseIds[0]).id
         ),
         mergeKey(
-          chunk764JHTLT_cjs.requireDefined(right.baseIds[0]).kind,
-          chunk764JHTLT_cjs.requireDefined(right.baseIds[0]).id
+          chunkN66HCGCY_cjs.requireDefined(right.baseIds[0]).kind,
+          chunkN66HCGCY_cjs.requireDefined(right.baseIds[0]).id
         )
       )
     ),
     provenanceRecords,
-    warnings: candidateWarnings
+    warnings: candidateWarnings,
+    identityAssertions: identityRemap.assertions,
+    identityRetractions: survivingRetractions
   };
 }
 function pickClusterCanonical(cluster, entityByIdentity) {
@@ -3332,78 +4930,125 @@ function pickClusterCanonical(cluster, entityByIdentity) {
   );
 }
 function commitModificationProps(baseProps, forkProps) {
-  const props = { ...forkProps };
+  const props = chunkN66HCGCY_cjs.createDataKeyedBag();
+  for (const key of Object.keys(forkProps)) {
+    props[key] = forkProps[key];
+  }
   for (const key of Object.keys(baseProps)) {
-    if (!(key in forkProps)) {
+    if (!chunkN66HCGCY_cjs.hasOwnKey(forkProps, key)) {
       props[key] = void 0;
     }
   }
   return props;
 }
-async function applyMergePlan(plan, nodesApi, edgesApi) {
-  const committedNodeIds = /* @__PURE__ */ new Set();
+function finalEdgeEndpoint(plan, kind, id) {
+  return { kind: plan.retypeMap.get(mergeKey(kind, id)) ?? kind, id };
+}
+function plannedNodeWrites(plan) {
   const canonicalIdentities = /* @__PURE__ */ new Set();
   for (const entity of plan.canonicalEntities) {
     canonicalIdentities.add(mergeKey(entity.kind, entity.canonicalId));
   }
-  const survivingModProps = /* @__PURE__ */ new Map();
+  const modificationsByIdentity = /* @__PURE__ */ new Map();
   for (const modification of plan.survivingModifications) {
-    survivingModProps.set(mergeKeyOf(modification.node), {
-      baseProps: modification.node.baseProps,
-      forkProps: modification.node.forkProps
-    });
+    modificationsByIdentity.set(
+      mergeKeyOf(modification.node),
+      modification.node
+    );
   }
+  const writes = [];
+  const written = /* @__PURE__ */ new Set();
   for (const modification of plan.survivingModifications) {
     const identity = mergeKeyOf(modification.node);
     if (plan.nodeDeletions.has(identity) || canonicalIdentities.has(identity)) {
       continue;
     }
-    const collection = nodeCollection(nodesApi, modification.node.kind);
-    await collection.upsertByIdFromRecord(
-      modification.node.id,
-      commitModificationProps(
-        modification.node.baseProps,
-        modification.node.forkProps
-      )
-    );
-    committedNodeIds.add(identity);
+    written.add(identity);
+    const validTo = plan.nodeValidityEnds.get(identity);
+    writes.push({
+      identity,
+      kind: modification.node.kind,
+      id: modification.node.id,
+      modification: modification.node,
+      ...validTo === void 0 ? {} : { validTo }
+    });
   }
   for (const entity of plan.canonicalEntities) {
-    const identity = mergeKey(entity.kind, entity.canonicalId);
-    if (plan.nodeDeletions.has(identity)) {
+    const sourceIdentity = mergeKey(entity.kind, entity.canonicalId);
+    if (plan.nodeDeletions.has(sourceIdentity)) {
       continue;
     }
-    const kind = plan.retypeMap.get(identity) ?? entity.kind;
-    const modification = survivingModProps.get(identity);
-    const props = modification === void 0 ? entity.props : {
-      ...entity.props,
-      ...commitModificationProps(
-        modification.baseProps,
-        modification.forkProps
-      )
-    };
-    const collection = nodeCollection(nodesApi, kind);
-    await collection.upsertByIdFromRecord(entity.canonicalId, props);
-    committedNodeIds.add(mergeKey(kind, entity.canonicalId));
+    const kind = plan.retypeMap.get(sourceIdentity) ?? entity.kind;
+    const modification = modificationsByIdentity.get(sourceIdentity);
+    written.add(sourceIdentity);
+    const validTo = entity.validTo ?? plan.nodeValidityEnds.get(sourceIdentity);
+    writes.push({
+      identity: mergeKey(kind, entity.canonicalId),
+      kind,
+      id: entity.canonicalId,
+      entity,
+      ...modification === void 0 ? {} : { modification },
+      ...entity.validFrom === void 0 ? {} : { validFrom: entity.validFrom },
+      ...validTo === void 0 ? {} : { validTo }
+    });
+  }
+  for (const identity of [...plan.nodeValidityEnds.keys()].sort(
+    (left, right) => compareMergeKeys(left, right)
+  )) {
+    if (written.has(identity) || plan.nodeDeletions.has(identity)) {
+      continue;
+    }
+    const kind = plan.retypeMap.get(identity) ?? kindOf(identity);
+    writes.push({
+      identity: mergeKey(kind, idOf(identity)),
+      kind,
+      id: idOf(identity),
+      validTo: chunkN66HCGCY_cjs.requireDefined(plan.nodeValidityEnds.get(identity))
+    });
   }
+  return writes;
+}
+function nodeWriteProps(write, modificationProps) {
+  return {
+    ...write.entity?.props,
+    ...write.modification === void 0 ? void 0 : modificationProps(write.modification)
+  };
+}
+async function applyMergePlan(plan, nodesApi, edgesApi, target, txBackend) {
+  const committedNodeIds = /* @__PURE__ */ new Set();
   for (const [identity, kind] of plan.nodeDeletions) {
     const collection = nodeCollection(nodesApi, kind);
     await collection.delete(idOf(identity));
   }
+  for (const write of plannedNodeWrites(plan)) {
+    const collection = nodeCollection(nodesApi, write.kind);
+    await collection.upsertByIdFromRecord(
+      write.id,
+      nodeWriteProps(
+        write,
+        (modification) => commitModificationProps(modification.baseProps, modification.forkProps)
+      ),
+      {
+        ...write.validFrom === void 0 ? {} : { validFrom: write.validFrom },
+        ...write.validTo === void 0 ? {} : { validTo: write.validTo }
+      }
+    );
+    committedNodeIds.add(write.identity);
+  }
   for (const [identity, kind] of plan.edgeDeletions) {
     await edgeCollection(edgesApi, kind).delete(idOf(identity));
   }
   const edgesByKind = /* @__PURE__ */ new Map();
   for (const edge of plan.mergedEdges) {
-    const fromKind = plan.retypeMap.get(mergeKey(edge.fromKind, edge.fromId));
-    const toKind = plan.retypeMap.get(mergeKey(edge.toKind, edge.toId));
     const edgeBaseProps = plan.inheritedEdgeBaseProps.get(edge.id);
     const props = edgeBaseProps === void 0 ? edge.props : commitModificationProps(edgeBaseProps, edge.props);
     const item = {
       id: edge.id,
-      from: { kind: fromKind ?? edge.fromKind, id: edge.fromId },
-      to: { kind: toKind ?? edge.toKind, id: edge.toId },
-      props
+      from: finalEdgeEndpoint(plan, edge.fromKind, edge.fromId),
+      to: finalEdgeEndpoint(plan, edge.toKind, edge.toId),
+      props,
+      ...edge.validFrom === void 0 ? {} : { validFrom: edge.validFrom },
+      ...edge.validTo === void 0 ? {} : { validTo: edge.validTo }
     };
     const existing = edgesByKind.get(edge.kind);
     if (existing === void 0) {
@@ -3417,10 +5062,34 @@ async function applyMergePlan(plan, nodesApi, edgesApi) {
     await edgeCollection(edgesApi, kind).bulkUpsertById(items);
     committedEdges += items.length;
   }
-  return { nodes: committedNodeIds.size, edges: committedEdges };
+  let appliedIdentity;
+  try {
+    appliedIdentity = await chunkTTAITEPJ_cjs.storeRuntime(target).applyIdentityMergeAtTarget(
+      txBackend,
+      plan.identityRetractions.map((retraction) => retraction.id),
+      plan.identityAssertions
+    );
+    await assertMergedIdentityClassesConsistent(target, txBackend, plan);
+  } catch (error) {
+    throw translateIdentityCommitError(error);
+  }
+  return {
+    nodes: committedNodeIds.size,
+    edges: committedEdges,
+    // ACTUAL ledger effects from the applier: rows created (idempotent
+    // exact/pair matches the target already held are excluded — the normal
+    // incremental case, where the target's own additions are staged back at
+    // it) and rows ended (already-ended or unknown ids excluded). Any apply
+    // failure aborts the whole merge, so the counts never describe a
+    // partial commit.
+    identity: {
+      asserted: appliedIdentity.created,
+      retracted: appliedIdentity.retracted
+    }
+  };
 }
 async function commitPlan(target, plan, expectedBaseVersion) {
-  if (!chunkJ7LXTUTP_cjs.storeBackend(target).capabilities.transactions) {
+  if (!chunkTTAITEPJ_cjs.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" } }
@@ -3430,15 +5099,18 @@ async function commitPlan(target, plan, expectedBaseVersion) {
     () => target.transaction(async (tx) => {
       if (expectedBaseVersion !== void 0) {
         await assertTargetUnchanged(
-          chunkJ7LXTUTP_cjs.transactionBackend(tx),
+          chunkTTAITEPJ_cjs.transactionBackend(tx),
           target,
           expectedBaseVersion
         );
       }
+      await assertPlannedIdentityIdsFresh(target, chunkTTAITEPJ_cjs.transactionBackend(tx), plan);
       return applyMergePlan(
         plan,
         tx.nodes,
-        tx.edges
+        tx.edges,
+        target,
+        chunkTTAITEPJ_cjs.transactionBackend(tx)
       );
     }, mergeCommitTransactionOptions(target))
   );
@@ -3451,9 +5123,9 @@ function mergeCommitTransactionOptions(target) {
 }
 async function assertTargetUnchanged(txBackend, target, expectedBaseVersion) {
   if (hasRevisionAnchor(expectedBaseVersion)) {
-    await chunkJ7LXTUTP_cjs.lockRecordedGraphWrite(txBackend, target.graphId);
+    await chunkXMQSEJCF_cjs.lockRecordedGraphWrite(txBackend, target.graphId);
     const expectedOrigin = revisionOriginOf(expectedBaseVersion);
-    const liveOrigin = await chunkJ7LXTUTP_cjs.readRevisionOrigin(
+    const liveOrigin = await chunkXMQSEJCF_cjs.readRevisionOrigin(
       txBackend,
       target.revisionSchema,
       target.graphId
@@ -3467,7 +5139,7 @@ async function assertTargetUnchanged(txBackend, target, expectedBaseVersion) {
         }
       );
     }
-    const liveRevision = await chunkJ7LXTUTP_cjs.readRecordedClock(
+    const liveRevision = await chunkXMQSEJCF_cjs.readRecordedClock(
       txBackend,
       target.revisionSchema,
       target.graphId
@@ -3487,7 +5159,8 @@ async function assertTargetUnchanged(txBackend, target, expectedBaseVersion) {
   const liveContent = await computeContentComponent(
     txBackend,
     target.graphId,
-    target.graph
+    target.graph,
+    await chunkTTAITEPJ_cjs.storeRuntime(target).identityAssertionsAtTarget(txBackend, "state")
   );
   const expectedContent = contentComponentOf(expectedBaseVersion);
   if (liveContent !== expectedContent) {
@@ -3525,7 +5198,7 @@ async function validateBaseVersions(target, branches) {
   const targetVersion = await computeBaseVersion(target);
   for (const branch2 of branches) {
     if (branch2.base !== targetVersion) {
-      return chunkJ2ICGNHO_cjs.err(
+      return chunk7BQXPCGN_cjs.err(
         new BaseVersionMismatchError(
           `Branch "${branch2.id}" forked from base@V "${branch2.base}", which does not match the merge target's current base@V "${targetVersion}".`,
           {
@@ -3539,20 +5212,50 @@ async function validateBaseVersions(target, branches) {
       );
     }
   }
-  return chunkJ2ICGNHO_cjs.ok(targetVersion);
+  return chunk7BQXPCGN_cjs.ok(targetVersion);
+}
+function tryNormalize(optionsInput, refusedOptions = []) {
+  const refusedOption = refusedOptions.find(
+    (option) => chunkN66HCGCY_cjs.hasOwnKey(optionsInput, option)
+  );
+  if (refusedOption !== void 0) {
+    return chunk7BQXPCGN_cjs.err(
+      new InvalidMergeOptionsError(
+        `This merge operation does not accept options.${refusedOption}.`,
+        { details: { option: refusedOption } }
+      )
+    );
+  }
+  try {
+    return chunk7BQXPCGN_cjs.ok(normalizeMergeOptions(optionsInput));
+  } catch (error) {
+    return chunk7BQXPCGN_cjs.err(
+      new InvalidMergeOptionsError("Invalid merge options.", { cause: error })
+    );
+  }
 }
-function tryNormalize(optionsInput) {
+async function tryOpenProvenanceStore(target) {
   try {
-    return chunkJ2ICGNHO_cjs.ok(normalizeMergeOptions(optionsInput));
+    return chunk7BQXPCGN_cjs.ok(await openProvenanceStore(target));
   } catch (error) {
-    return chunkJ2ICGNHO_cjs.err(new MergeError("Invalid merge options.", { cause: error }));
+    const code = error instanceof chunkNI72YOJB_cjs.TypeGraphError ? error.details?.code : void 0;
+    const details = {
+      option: "persistProvenance",
+      graphId: provenanceGraphId(target.graphId),
+      targetGraphId: target.graphId,
+      ...typeof code === "string" ? { provenanceErrorCode: code } : {}
+    };
+    const message = `options.persistProvenance was requested but the merge-provenance sidecar cannot be opened: ${describeCause(error)}`;
+    return chunk7BQXPCGN_cjs.err(
+      code === "GRAPH_MERGE_PROVENANCE_ID_COLLISION" || code === "GRAPH_MERGE_PROVENANCE_CLAIM_UNFENCED" ? new InvalidMergeOptionsError(message, { details, cause: error }) : new MergeError(message, { details, cause: error })
+    );
   }
 }
 async function resolveMerge(store, target, branches, options, useBaseSources, incremental, expectedBaseVersion) {
   let targetBranchSeen = false;
   for (const branch2 of branches) {
     if (branch2.id === BASE_PROVENANCE_BRANCH) {
-      return chunkJ2ICGNHO_cjs.err(
+      return chunk7BQXPCGN_cjs.err(
         new MergeError(
           `Branch id "${BASE_PROVENANCE_BRANCH}" is reserved for committed-base provenance and cannot be used as a branch id.`,
           { details: { branchId: branch2.id } }
@@ -3561,7 +5264,7 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
     }
     if (branch2.id === COMMITTED_TARGET_BRANCH) {
       if (incremental?.targetBranchId !== COMMITTED_TARGET_BRANCH || targetBranchSeen) {
-        return chunkJ2ICGNHO_cjs.err(
+        return chunk7BQXPCGN_cjs.err(
           new MergeError(
             `Branch id "${COMMITTED_TARGET_BRANCH}" is reserved for the committed incremental target and cannot be used as a branch id.`,
             { details: { branchId: branch2.id } }
@@ -3571,9 +5274,44 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
       targetBranchSeen = true;
     }
   }
+  for (const branch2 of branches) {
+    const branchSchemaRow = await chunkTTAITEPJ_cjs.storeBackend(branch2.store).getActiveSchema(
+      branch2.store.graphId
+    );
+    let drifted;
+    if ("schemaAnchor" in branch2) {
+      const anchor = branch2.schemaAnchor;
+      drifted = anchor === void 0 ? branchSchemaRow !== void 0 : branchSchemaRow?.version !== anchor.version || branchSchemaRow.schema_hash !== anchor.hash;
+    } else {
+      const sourceSchemaRow = await chunkTTAITEPJ_cjs.storeBackend(store).getActiveSchema(
+        store.graphId
+      );
+      drifted = branchSchemaRow?.schema_hash !== sourceSchemaRow?.schema_hash;
+    }
+    if (drifted) {
+      return chunk7BQXPCGN_cjs.err(
+        new BaseVersionMismatchError(
+          `Branch "${branch2.id}"'s store has a committed schema different from its at-fork state \u2014 a schema operation ran on the branch after forking. Merge carries data changes only; apply the schema change to the target first (or re-fork), then merge.`,
+          {
+            details: {
+              branchId: branch2.id,
+              branchSchemaVersion: branchSchemaRow?.version,
+              branchSchemaHash: branchSchemaRow?.schema_hash,
+              anchor: "schemaAnchor" in branch2 ? branch2.schemaAnchor : "absent"
+            }
+          }
+        )
+      );
+    }
+  }
+  const provenanceStore = options.persistProvenance ? await tryOpenProvenanceStore(target) : void 0;
+  if (provenanceStore !== void 0 && chunk7BQXPCGN_cjs.isErr(provenanceStore)) {
+    return provenanceStore;
+  }
   try {
     const preferredBranchId = incremental?.targetBranchId;
     const staging = await stageBranches(store, branches, preferredBranchId);
+    const stagedNewByKind = newNodesByKind(staging);
     const branchIds = branches.map((branch2) => branch2.id);
     const branchOrder = preferredBranchId === void 0 ? options.branchOrder ?? [] : [
       preferredBranchId,
@@ -3589,12 +5327,12 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
     }
     const subClassClosure = buildSubClassClosure(introspection.ontology);
     const embeddings = options.embedder === void 0 ? void 0 : await precomputeEmbeddings(
-      newNodesByKind(staging),
+      stagedNewByKind,
       options.resolve,
       options.embedder
     );
     const ctx = {
-      backend: chunkJ7LXTUTP_cjs.storeBackend(store),
+      backend: chunkTTAITEPJ_cjs.storeBackend(store),
       ...embeddings === void 0 ? {} : { embeddings }
     };
     const candidates = await generateAllCandidates(
@@ -3606,9 +5344,38 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
       useBaseSources,
       options.embedder
     );
-    if (chunkJ2ICGNHO_cjs.isErr(candidates)) {
-      return chunkJ2ICGNHO_cjs.err(candidates.error);
+    if (chunk7BQXPCGN_cjs.isErr(candidates)) {
+      return chunk7BQXPCGN_cjs.err(candidates.error);
     }
+    const identityProbeIds = target.graph.identity === void 0 ? void 0 : [
+      .../* @__PURE__ */ new Set([
+        ...[...stagedNewByKind.values()].flatMap(
+          (entries) => entries.map((entry) => entry.node.id)
+        ),
+        ...staging.modifiedNodes.map((entry) => entry.node.id),
+        ...candidates.data.baseMembers.map((member) => member.id),
+        ...staging.newIdentityAssertions.flatMap((staged) => [
+          staged.assertion.a.id,
+          staged.assertion.b.id
+        ])
+      ])
+    ];
+    const targetPeers = identityProbeIds === void 0 ? [] : await chunkTTAITEPJ_cjs.storeRuntime(target).liveNodesSharingIds(identityProbeIds);
+    const stagedIdentityIds = [
+      .../* @__PURE__ */ new Set([
+        ...staging.newIdentityAssertions.map((staged) => staged.assertion.id),
+        ...staging.retractedIdentityAssertions.map(
+          (staged) => staged.assertion.id
+        )
+      ])
+    ];
+    const storedIdentityRowsById = stagedIdentityIds.length === 0 || target.graph.identity === void 0 ? NO_STORED_ASSERTIONS : await chunkTTAITEPJ_cjs.storeRuntime(target).identityAssertionRowsByIds(
+      stagedIdentityIds
+    );
+    const identityContext = {
+      sameIdAcrossKinds: target.graph.identity?.sameIdAcrossKinds,
+      areDisjoint: (left, right) => target.registry.areDisjoint(left, right)
+    };
     const plan = planMerge(
       staging,
       candidates.data.edges,
@@ -3617,12 +5384,63 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
       options,
       branchRank,
       subClassClosure,
+      identityContext,
+      storedIdentityRowsById,
+      targetPeers,
       preferredBranchId
     );
+    if (plan.identityAssertions.length > 0) {
+      assertOneIdOneTruth(
+        plan.identityAssertions,
+        await chunkTTAITEPJ_cjs.storeRuntime(target).identityAssertionRowsByIds(
+          plan.identityAssertions.map((assertion) => assertion.id)
+        )
+      );
+    }
+    let identityGuard;
+    if (identityProbeIds !== void 0 && incremental !== void 0) {
+      const freshPeers = await chunkTTAITEPJ_cjs.storeRuntime(target).liveNodesSharingIds(identityProbeIds);
+      const built = await buildIdentityPeerProbe(
+        target,
+        identityProbeIds,
+        freshPeers,
+        plan,
+        target.graph.identity?.sameIdAcrossKinds ?? "ignore"
+      );
+      const canonicalIdentityOf = plan.canonicalOf;
+      assertNoContradictoryIdentityClosure(
+        plan.identityAssertions,
+        plan.identityRetractions.map((retraction) => retraction.id),
+        // The FRESH target ledger, not the pre-planning staging capture —
+        // a `different` committed in the window must invalidate the plan
+        // here, as a typed conflict, before it can become the baseline.
+        // Connectivity is REBUILT from this deletion-filtered ledger (plus
+        // the fold unions inside the checker) rather than from the old
+        // closure's member lists: filtering a deleted member out of a class
+        // does not model the post-deletion state — deleting a bridge ends
+        // its assertions and SPLITS the class, so pre-linking the filtered
+        // remainder would falsely reject a plan that deletes the bridge and
+        // asserts the ends different.
+        built.ledger,
+        new Set(plan.nodeDeletions.keys()),
+        canonicalIdentityOf,
+        plan.retypeMap,
+        identityContext,
+        // The snapshot's (deletion-filtered) class MEMBERS join the universe
+        // as unlinked refs: their same-id fold links at ids outside the probe
+        // range are re-derived by the checker's fold union, and their
+        // assertion links come from the fresh ledger — never from the old
+        // class shape itself.
+        [...built.probe.seeds, ...built.snapshot.groups.flat()]
+      );
+      identityGuard = built.probe;
+    }
     const merged = incremental === void 0 ? await commitPlan(target, plan, expectedBaseVersion) : await commitIncrementalPlan(target, plan, {
-      stagedNewByKind: newNodesByKind(staging),
+      stagedNewByKind,
       options,
       introspectionKinds,
+      forkPoint: incremental.forkPoint,
+      ...identityGuard === void 0 ? {} : { identityPeerProbe: identityGuard },
       // The committed (kind, id) keys the base sources matched at PLAN time;
       // anything NEW the in-tx re-probe surfaces is a window write.
       plannedBaseMatchKeys: new Set(
@@ -3634,11 +5452,10 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
     const provenance = options.provenance ? buildProvenanceIndex(plan.provenanceRecords) : { byBranch: () => ({ nodeIds: [], edgeIds: [] }) };
     const warnings = [...plan.warnings];
     let provenancePersisted;
-    if (options.persistProvenance) {
+    if (provenanceStore !== void 0 && !chunk7BQXPCGN_cjs.isErr(provenanceStore)) {
       try {
-        const provenanceStore = await openProvenanceStore(target);
         const count = await persistProvenanceRecords(
-          provenanceStore,
+          provenanceStore.data,
           target.graphId,
           plan.provenanceRecords
         );
@@ -3659,17 +5476,18 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
       deleteModifyConflicts: plan.deleteModifyConflicts,
       typeReconciliations: plan.typeReconciliations,
       dropped: plan.dropped,
+      validityEnds: plan.validityEnds,
       baseAmbiguities: plan.baseAmbiguities,
       provenance,
       warnings,
       ...provenancePersisted === void 0 ? {} : { provenancePersisted }
     };
-    return chunkJ2ICGNHO_cjs.ok(report);
+    return chunk7BQXPCGN_cjs.ok(report);
   } catch (error) {
     if (error instanceof MergeError) {
-      return chunkJ2ICGNHO_cjs.err(error);
+      return chunk7BQXPCGN_cjs.err(error);
     }
-    return chunkJ2ICGNHO_cjs.err(
+    return chunk7BQXPCGN_cjs.err(
       new MergeError(
         `Merge failed while staging or committing: ${describeCause(error)}`,
         { cause: error }
@@ -3679,14 +5497,14 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
 }
 async function merge(store, branches, optionsInput = {}) {
   const normalized = tryNormalize(optionsInput);
-  if (chunkJ2ICGNHO_cjs.isErr(normalized)) {
-    return chunkJ2ICGNHO_cjs.err(normalized.error);
+  if (chunk7BQXPCGN_cjs.isErr(normalized)) {
+    return chunk7BQXPCGN_cjs.err(normalized.error);
   }
   const options = normalized.data;
   const target = options.target ?? store;
   const precondition = await validateBaseVersions(target, branches);
-  if (chunkJ2ICGNHO_cjs.isErr(precondition)) {
-    return chunkJ2ICGNHO_cjs.err(precondition.error);
+  if (chunk7BQXPCGN_cjs.isErr(precondition)) {
+    return chunk7BQXPCGN_cjs.err(precondition.error);
   }
   return resolveMerge(
     store,
@@ -3702,7 +5520,7 @@ async function validateForkPointVersions(forkPoint, branches) {
   const forkVersion = await computeBaseVersion(forkPoint);
   for (const branch2 of branches) {
     if (branch2.base !== forkVersion) {
-      return chunkJ2ICGNHO_cjs.err(
+      return chunk7BQXPCGN_cjs.err(
         new BaseVersionMismatchError(
           `Branch "${branch2.id}" forked from base@V "${branch2.base}", which does not match the fork-point's base@V "${forkVersion}". mergeIncremental() requires every branch to have forked from the supplied forkPoint.`,
           {
@@ -3716,7 +5534,7 @@ async function validateForkPointVersions(forkPoint, branches) {
       );
     }
   }
-  return chunkJ2ICGNHO_cjs.ok(forkVersion);
+  return chunk7BQXPCGN_cjs.ok(forkVersion);
 }
 function nodeSchemaFor(target, kind) {
   const registry = target.graph.nodes;
@@ -3752,7 +5570,7 @@ function analyzeRevalidatingWrite(schema, current, planned) {
   };
 }
 function nodeProps2(node) {
-  const props = {};
+  const props = chunkN66HCGCY_cjs.createDataKeyedBag();
   for (const [key, value] of Object.entries(node)) {
     if (key === "id" || key === "kind" || key === "meta") continue;
     props[key] = value;
@@ -3760,7 +5578,7 @@ function nodeProps2(node) {
   return props;
 }
 function edgeProps(edge) {
-  const props = {};
+  const props = chunkN66HCGCY_cjs.createDataKeyedBag();
   for (const [key, value] of Object.entries(edge)) {
     if (key === "id" || key === "kind" || key === "fromKind" || key === "fromId" || key === "toKind" || key === "toId" || key === "meta") {
       continue;
@@ -3770,70 +5588,14 @@ function edgeProps(edge) {
   return props;
 }
 var INCLUDE_TOMBSTONES = { temporalMode: "includeTombstones" };
-function finalEdgeFrom(edge, plan) {
-  return {
-    kind: plan.retypeMap.get(mergeKey(edge.fromKind, edge.fromId)) ?? edge.fromKind,
-    id: edge.fromId
-  };
-}
-function finalEdgeTo(edge, plan) {
-  return {
-    kind: plan.retypeMap.get(mergeKey(edge.toKind, edge.toId)) ?? edge.toKind,
-    id: edge.toId
-  };
-}
 function assertValidRevalidatingWrite(analysis, message, details) {
   if (analysis.status === "invalid") {
     throw new MergeError(message, { details });
   }
 }
-function describeCause(cause) {
-  return cause instanceof Error ? cause.message : String(cause);
-}
-function plannedNodeWrites(plan) {
-  const canonicalIdentities = /* @__PURE__ */ new Set();
-  for (const entity of plan.canonicalEntities) {
-    canonicalIdentities.add(mergeKey(entity.kind, entity.canonicalId));
-  }
-  const survivingModProps = /* @__PURE__ */ new Map();
-  for (const modification of plan.survivingModifications) {
-    survivingModProps.set(
-      mergeKeyOf(modification.node),
-      modification.node.forkProps
-    );
-  }
-  const writes = [];
-  for (const modification of plan.survivingModifications) {
-    const identity = mergeKeyOf(modification.node);
-    if (plan.nodeDeletions.has(identity) || canonicalIdentities.has(identity)) {
-      continue;
-    }
-    writes.push({
-      identity,
-      kind: modification.node.kind,
-      id: modification.node.id,
-      props: modification.node.forkProps
-    });
-  }
-  for (const entity of plan.canonicalEntities) {
-    const sourceIdentity = mergeKey(entity.kind, entity.canonicalId);
-    if (plan.nodeDeletions.has(sourceIdentity)) {
-      continue;
-    }
-    const kind = plan.retypeMap.get(sourceIdentity) ?? entity.kind;
-    const forkProps = survivingModProps.get(sourceIdentity);
-    writes.push({
-      identity: mergeKey(kind, entity.canonicalId),
-      kind,
-      id: entity.canonicalId,
-      props: forkProps === void 0 ? entity.props : { ...entity.props, ...forkProps }
-    });
-  }
-  return writes;
-}
 function edgeWriteSignature(edge, plan) {
-  const from = finalEdgeFrom(edge, plan);
-  const to = finalEdgeTo(edge, plan);
+  const from = finalEdgeEndpoint(plan, edge.fromKind, edge.fromId);
+  const to = finalEdgeEndpoint(plan, edge.toKind, edge.toId);
   return JSON.stringify([
     edge.kind,
     from.kind,
@@ -3875,7 +5637,7 @@ async function validateIncrementalNodeWrites(target, nodesApi, plan) {
     const analysis = analyzeRevalidatingWrite(
       nodeSchemaFor(target, write.kind),
       nodeProps2(current),
-      write.props
+      nodeWriteProps(write, (modification) => modification.forkProps)
     );
     assertValidRevalidatingWrite(
       analysis,
@@ -3927,7 +5689,7 @@ async function validateIncrementalEdgeWrites(target, edgesApi, plan) {
       }
     }
   }
-  const notFound = [...plannedKindById.keys()].filter((id) => !existingById.has(id)).sort((left, right) => chunkTRF4EBJT_cjs.compareStrings(left, right));
+  const notFound = [...plannedKindById.keys()].filter((id) => !existingById.has(id)).sort((left, right) => chunkXMQSEJCF_cjs.compareStrings(left, right));
   if (notFound.length > 0) {
     const crossKindById = /* @__PURE__ */ new Map();
     for (const kind of Object.keys(target.graph.edges)) {
@@ -3954,12 +5716,12 @@ async function validateIncrementalEdgeWrites(target, edgesApi, plan) {
         );
       }
       throw new MergeError(
-        `mergeIncremental() would overwrite committed edge "${id}" (kind "${row.kind}") with a different-kind edge "${chunk764JHTLT_cjs.requireDefined(plannedKindById.get(id))}" of the same id.`,
+        `mergeIncremental() would overwrite committed edge "${id}" (kind "${row.kind}") with a different-kind edge "${chunkN66HCGCY_cjs.requireDefined(plannedKindById.get(id))}" of the same id.`,
         {
           details: {
             id,
             committedKind: row.kind,
-            plannedKind: chunk764JHTLT_cjs.requireDefined(plannedKindById.get(id))
+            plannedKind: chunkN66HCGCY_cjs.requireDefined(plannedKindById.get(id))
           }
         }
       );
@@ -3976,8 +5738,8 @@ async function validateIncrementalEdgeWrites(target, edgesApi, plan) {
         { details: { id: edge.id, committedKind: current.kind } }
       );
     }
-    const from = finalEdgeFrom(edge, plan);
-    const to = finalEdgeTo(edge, plan);
+    const from = finalEdgeEndpoint(plan, edge.fromKind, edge.fromId);
+    const to = finalEdgeEndpoint(plan, edge.toKind, edge.toId);
     if (current.fromId !== from.id || current.fromKind !== from.kind || current.toId !== to.id || current.toKind !== to.kind) {
       throw new MergeError(
         `mergeIncremental() would overwrite committed edge "${edge.id}" (kind "${edge.kind}") with different endpoints.`,
@@ -4079,7 +5841,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 = chunk764JHTLT_cjs.requireDefined(args.expected.get(mergeKey(kind, id)));
+      const expected = chunkN66HCGCY_cjs.requireDefined(args.expected.get(mergeKey(kind, id)));
       const current = args.deriveValue(rows[index]);
       if (current === expected) {
         continue;
@@ -4149,8 +5911,22 @@ async function assertInheritedEdgesUnchanged(edgesApi, guard, plan) {
     )
   });
 }
+async function assertForkPointUnchanged(precondition) {
+  const liveVersion = await computeBaseVersion(precondition.store);
+  if (liveVersion === precondition.version) return;
+  throw new BaseVersionMismatchError(
+    "The mergeIncremental() fork point was modified between the fork-point precondition and the commit transaction; every branch diff was computed against the previous fork-point state, so the resolved plan was not applied.",
+    {
+      details: {
+        expectedForkPointBase: precondition.version,
+        liveForkPointBase: liveVersion
+      },
+      suggestion: "Keep the fork-point store immutable for the duration of the merge (it is the diff reference, not a merge target), then re-run mergeIncremental()."
+    }
+  );
+}
 async function commitIncrementalPlan(target, plan, guard) {
-  if (!chunkJ7LXTUTP_cjs.storeBackend(target).capabilities.transactions) {
+  if (!chunkTTAITEPJ_cjs.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" } }
@@ -4159,36 +5935,56 @@ async function commitIncrementalPlan(target, plan, guard) {
   return withTxConflictRetry(
     () => target.transaction(async (tx) => {
       if (target.revisionTrackingEnabled) {
-        await chunkJ7LXTUTP_cjs.lockRecordedGraphWrite(chunkJ7LXTUTP_cjs.transactionBackend(tx), target.graphId);
+        await chunkXMQSEJCF_cjs.lockRecordedGraphWrite(chunkTTAITEPJ_cjs.transactionBackend(tx), target.graphId);
       }
+      await assertForkPointUnchanged(guard.forkPoint);
       const nodesApi = tx.nodes;
       const edgesApi = tx.edges;
       await assertBaseResolutionStable(tx, guard);
+      await assertPlannedIdentityIdsFresh(target, chunkTTAITEPJ_cjs.transactionBackend(tx), plan);
+      await assertIdentityPeersStable(
+        target,
+        chunkTTAITEPJ_cjs.transactionBackend(tx),
+        guard.identityPeerProbe,
+        plan
+      );
       await assertInheritedTargetUnchanged(nodesApi, edgesApi, guard, plan);
       await validateIncrementalNodeWrites(target, nodesApi, plan);
       await validateIncrementalEdgeWrites(target, edgesApi, plan);
-      return applyMergePlan(plan, nodesApi, edgesApi);
+      return applyMergePlan(
+        plan,
+        nodesApi,
+        edgesApi,
+        target,
+        chunkTTAITEPJ_cjs.transactionBackend(tx)
+      );
     }, mergeCommitTransactionOptions(target))
   );
 }
 async function mergeIncremental(args) {
   const { forkPoint, target, branches } = args;
-  const normalized = tryNormalize(args.options ?? {});
-  if (chunkJ2ICGNHO_cjs.isErr(normalized)) {
-    return chunkJ2ICGNHO_cjs.err(normalized.error);
+  const normalized = tryNormalize(args.options ?? {}, ["target"]);
+  if (chunk7BQXPCGN_cjs.isErr(normalized)) {
+    return chunk7BQXPCGN_cjs.err(normalized.error);
   }
   const options = normalized.data;
   if (options.onBasePropertyConflict !== "flag") {
-    return chunkJ2ICGNHO_cjs.err(
-      new MergeError(
+    return chunk7BQXPCGN_cjs.err(
+      new InvalidMergeOptionsError(
         'mergeIncremental() requires onBasePropertyConflict: "flag" (keep-base); a non-keep-base policy could overwrite a newer committed base value with a stale branch value.',
-        { details: {} }
+        {
+          details: {
+            option: "onBasePropertyConflict",
+            accepted: "flag",
+            received: options.onBasePropertyConflict
+          }
+        }
       )
     );
   }
   const forkPrecondition = await validateForkPointVersions(forkPoint, branches);
-  if (chunkJ2ICGNHO_cjs.isErr(forkPrecondition)) {
-    return chunkJ2ICGNHO_cjs.err(forkPrecondition.error);
+  if (chunk7BQXPCGN_cjs.isErr(forkPrecondition)) {
+    return chunk7BQXPCGN_cjs.err(forkPrecondition.error);
   }
   const forkVersion = forkPrecondition.data;
   const [forkSchema, targetSchema] = await Promise.all([
@@ -4196,7 +5992,7 @@ async function mergeIncremental(args) {
     computeSchemaComponent(target)
   ]);
   if (forkSchema !== targetSchema) {
-    return chunkJ2ICGNHO_cjs.err(
+    return chunk7BQXPCGN_cjs.err(
       new MergeError(
         "mergeIncremental() requires target and forkPoint to share a schema; schema drift is not supported (the target content may differ \u2014 only the schema must match).",
         { details: {} }
@@ -4214,29 +6010,38 @@ async function mergeIncremental(args) {
     [targetBranch, ...branches],
     options,
     true,
-    { targetBranchId: COMMITTED_TARGET_BRANCH }
+    {
+      targetBranchId: COMMITTED_TARGET_BRANCH,
+      // The fork-point precondition just validated, carried to the commit so
+      // it is re-established there rather than assumed to have held for the
+      // whole of planning (see `assertForkPointUnchanged`).
+      forkPoint: { store: forkPoint, version: forkVersion }
+    }
   );
 }
 
 Object.defineProperty(exports, "isErr", {
   enumerable: true,
-  get: function () { return chunkJ2ICGNHO_cjs.isErr; }
+  get: function () { return chunk7BQXPCGN_cjs.isErr; }
 });
 Object.defineProperty(exports, "isOk", {
   enumerable: true,
-  get: function () { return chunkJ2ICGNHO_cjs.isOk; }
+  get: function () { return chunk7BQXPCGN_cjs.isOk; }
 });
 Object.defineProperty(exports, "unwrap", {
   enumerable: true,
-  get: function () { return chunkJ2ICGNHO_cjs.unwrap; }
+  get: function () { return chunk7BQXPCGN_cjs.unwrap; }
 });
 exports.BaseVersionMismatchError = BaseVersionMismatchError;
 exports.BranchError = BranchError;
+exports.IdentityMergeConflictError = IdentityMergeConflictError;
+exports.InvalidMergeOptionsError = InvalidMergeOptionsError;
 exports.MERGE_ERROR_CODES = MERGE_ERROR_CODES;
 exports.MERGE_OPTION_DEFAULTS = MERGE_OPTION_DEFAULTS;
 exports.MergeConflictError = MergeConflictError;
 exports.MergeError = MergeError;
 exports.SimilarityUnavailableError = SimilarityUnavailableError;
+exports.VALIDITY_END_TARGET_PRECEDENCE = VALIDITY_END_TARGET_PRECEDENCE;
 exports.asBaseVersion = asBaseVersion;
 exports.asBranchId = asBranchId;
 exports.branch = branch;