@nicia-ai/typegraph 0.45.0 → 0.46.0

package/dist/graph-merge/index.js

@@ -1,38 +1,36 @@
-import { createStoreWithSchema } from '../chunk-ID4WXTKL.js';
-import '../chunk-YMTXMPV6.js';
-import { importGraphStream, exportGraphStream } from '../chunk-CBKG6HEP.js';
-import '../chunk-Q6EDCUXV.js';
-import { storeBackend, generateId, computeUniqueKey, transactionBackend, lockRecordedGraphWrite, readRevisionOrigin, readRecordedClock } from '../chunk-TKORQCG4.js';
-import '../chunk-35S6P5ZU.js';
-import '../chunk-MIJKEVV7.js';
-import '../chunk-55ITBQJI.js';
-import '../chunk-2L54C2C2.js';
-import { computeSchemaHash, serializeSchema } from '../chunk-FQ7ZPOTZ.js';
-import { compareStrings } from '../chunk-DRACN6XG.js';
-import { defineNode } from '../chunk-TKP5T34P.js';
-import '../chunk-DK2S42XB.js';
-import { sortedReplacer } from '../chunk-UR7W5YQK.js';
-import '../chunk-V34A6R5V.js';
-import { getNodeKinds, getEdgeKinds, defineGraph } from '../chunk-S4KQ5LV4.js';
-import '../chunk-KCO5EFJU.js';
-import '../chunk-FL5UQRES.js';
-import '../chunk-QLUXRWKL.js';
-import '../chunk-FLEQ2HBK.js';
+import { createStoreWithSchema } from '../chunk-7Z5OR7KO.js';
+import '../chunk-NMWDXFPH.js';
+import { importGraphStream, exportGraphStream, importGraph, exportGraph } from '../chunk-OH5E5KIO.js';
+import '../chunk-QWX5YA3K.js';
+import { storeBackend, storeRuntime, transactionBackend } from '../chunk-WEVQJ5LH.js';
+import { computeSchemaHash, serializeSchema } from '../chunk-QLRESYPU.js';
+import { defineNode } from '../chunk-JXA2ZP2Q.js';
+import { encodeTupleKey, normalizeIdentityPair, identityReferenceKey, identityAssertionSemanticKey } from '../chunk-JIVMTW7W.js';
+import { generateId, compareStrings, compareCodePoints, lockRecordedGraphWrite, readRevisionOrigin, readRecordedClock } from '../chunk-NQ6BRJBE.js';
+import { sortedReplacer } from '../chunk-JBQQ7THH.js';
+import '../chunk-JZUR7ZWE.js';
+import { createSqlSchema } from '../chunk-MSY7FSX4.js';
+import { snapshotExportContention } from '../chunk-AKLS3BYZ.js';
+import { getNodeKinds, getEdgeKinds, defineInternalGraph } from '../chunk-775A4ZMN.js';
+import { computeUniqueKey } from '../chunk-WDGA7IYB.js';
+import { canonicalizeDatabaseTimestamp } from '../chunk-DLNROMQ7.js';
+import '../chunk-DCQVHAYQ.js';
+import '../chunk-CBTIUB76.js';
+import '../chunk-I5MOXA4H.js';
 import { sha256Hex } from '../chunk-K34OPSJK.js';
 import '../chunk-2EBMPJBO.js';
-import '../chunk-PVUI6KGR.js';
-import '../chunk-6DCB664D.js';
-import '../chunk-D7PG5D5K.js';
-import '../chunk-SNXVDZAJ.js';
-import { requireDefined } from '../chunk-QMQLUA66.js';
+import '../chunk-YDFDBE6D.js';
+import { asCompiledStatementSql, sql, asCompiledRowsSql } from '../chunk-PQBQG7IM.js';
+import '../chunk-AMKPPFUO.js';
+import '../chunk-W6OG3HDG.js';
 import '../chunk-PC2UBAUB.js';
-import { ok, err, isErr, computeTransitiveClosure, isReachable } from '../chunk-4GUBTVPV.js';
-export { isErr, isOk, unwrap } from '../chunk-4GUBTVPV.js';
-import '../chunk-GYA4JRP5.js';
-import '../chunk-42PYUGLS.js';
-import '../chunk-ITE4IXAK.js';
-import { TypeGraphError } from '../chunk-4MB3AQAQ.js';
-import '../chunk-G6Q5UM7U.js';
+import { ok, err, isErr, computeTransitiveClosure, isReachable } from '../chunk-T4XNKYXB.js';
+export { isErr, isOk, unwrap } from '../chunk-T4XNKYXB.js';
+import { META_EDGE_EQUIVALENT_TO, META_EDGE_SAME_AS } from '../chunk-JXXDZTMN.js';
+import '../chunk-K5ELX2GT.js';
+import { TypeGraphError, ConfigurationError, IdentityContradictionError, NodeNotFoundError } from '../chunk-J3WZ3FA2.js';
+import '../chunk-FWJKWH6U.js';
+import { createDataKeyedBag, hasOwnKey, requireDefined, readOwnProperty } from '../chunk-DYATYRY4.js';
 import { z } from 'zod';
 
 // src/graph-merge/canonical-props.ts
@@ -101,8 +99,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 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 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 = requireDefined(this.parent.get(root));
+    }
+    let cursor = value;
+    while (cursor !== root) {
+      const next = 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 encodeTupleKey(endpointTuple(assertion));
+}
+function identitySemanticKey(assertion) {
+  return identityAssertionSemanticKey(
+    assertion.relation,
+    assertion.a,
+    assertion.b
+  );
+}
+function compareIdentitySurvivors(left, right) {
+  const byValidity = compareCodePoints(left.validFrom, right.validFrom);
+  return byValidity === 0 ? 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) => 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) => 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] = 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(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, 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 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(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 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) => compareStrings(encodeTupleKey(left), 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 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 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 TypeGraphError)) return error;
+  const identityCode = identityRefusalCode(error);
+  const identityRefusal = error instanceof IdentityContradictionError || error instanceof 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 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) => 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: canonicalizeDatabaseTimestamp(row.valid_from),
+    validTo: 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;
@@ -163,6 +987,7 @@ function diffNodeKind(kind, baseRows, forkRows) {
   const created = [];
   const modified = [];
   const deleted = [];
+  const windowed = [];
   for (const forkRow of forkRows) {
     if (!isLive(forkRow)) {
       continue;
@@ -188,6 +1013,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)) {
@@ -195,10 +1030,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 : canonicalizeDatabaseTimestamp(forkRow.deleted_at)
+      });
     }
   }
-  return { new: created, modified, deleted };
+  return { new: created, modified, deleted, windowed };
 }
 function diffEdgeKind(kind, baseRows, forkRows) {
   const baseIndex = indexById(baseRows);
@@ -206,6 +1045,7 @@ function diffEdgeKind(kind, baseRows, forkRows) {
   const created = [];
   const modified = [];
   const deleted = [];
+  const windowed = [];
   for (const forkRow of forkRows) {
     if (!isLive(forkRow)) {
       continue;
@@ -239,6 +1079,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)) {
@@ -249,7 +1105,51 @@ 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 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 compareStrings(left.id, right.id);
@@ -258,9 +1158,20 @@ async function diffAgainstBase(baseStore, forkStore, captureForkState = true) {
   const graph = baseStore.graph;
   const nodeKinds = getNodeKinds(graph);
   const edgeKinds = getEdgeKinds(graph);
+  const [baseIdentity, forkIdentity] = await Promise.all([
+    storeRuntime(baseStore).readCurrentIdentityAssertions("state"),
+    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(
@@ -288,10 +1199,14 @@ 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(
@@ -329,17 +1244,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) => 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) => compareStrings(left.id, right.id)),
+      retracted: classifiedRetractions
     },
     forkNodeVersions,
     forkEdgeSignatures
@@ -353,9 +1297,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";
@@ -376,7 +1322,7 @@ function byDigestEntry(left, right) {
   return byKind === 0 ? compareStrings(left.id, right.id) : byKind;
 }
 var CONTENT_FINGERPRINT_BYTES = 16;
-async function computeContentComponent(backend, graphId, graph) {
+async function computeContentComponent(backend, graphId, graph, identityAssertions) {
   const nodeKinds = getNodeKinds(graph);
   const edgeKinds = getEdgeKinds(graph);
   const nodeDigest = [];
@@ -416,30 +1362,41 @@ async function computeContentComponent(backend, graphId, graph) {
   return 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(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(storeBackend(store), store.graphId, store.graph)
+    computeStoreContentComponent(store)
   ]);
   return asBaseVersion(
     `${schemaComponent}${TOKEN_SEPARATOR}${contentComponent}`
   );
 }
+async function computeStoreContentComponent(store) {
+  const identityAssertions = await storeRuntime(store).readCurrentIdentityAssertions("state");
+  return computeContentComponent(
+    storeBackend(store),
+    store.graphId,
+    store.graph,
+    identityAssertions
+  );
+}
 function revisionComponent(origin, revision) {
   return `${REVISION_COMPONENT_PREFIX}${origin}${REVISION_COMPONENT_SEPARATOR}${revision ?? INITIAL_REVISION}`;
 }
@@ -469,70 +1426,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 TypeGraphError {
-  constructor(message, options = {}) {
-    super(
-      message,
-      MERGE_ERROR_CODES.merge,
-      toTypeGraphErrorOptions("system", options)
-    );
-    this.name = "MergeError";
-  }
-};
-var BranchError = class extends 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) {
@@ -549,20 +1442,29 @@ function cloneWorkingCopyStrategy(makeBackend) {
             revisionTracking: baseStore.revisionTrackingEnabled
           }
         );
-        const result = await 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 = snapshotExportContention(
+          storeBackend(baseStore),
+          storeBackend(freshStore)
+        ) === void 0 ? await importGraphStream(
           freshStore,
-          exportGraphStream(baseStore, {
-            includeMeta: true,
-            includeTemporal: true,
-            includeDeleted: false,
-            batchSize: CLONE_IMPORT_BATCH_SIZE
-          }),
-          {
-            onConflict: "error",
-            onUnknownProperty: "error",
-            validateReferences: true,
-            batchSize: CLONE_IMPORT_BATCH_SIZE
-          }
+          exportGraphStream(baseStore, exportOptions),
+          importOptions
+        ) : await importGraph(
+          freshStore,
+          await exportGraph(baseStore, exportOptions),
+          importOptions
         );
         if (!result.success) {
           throw new BranchError(
@@ -589,7 +1491,13 @@ async function branch(baseStore, makeBackend, options, strategy) {
     const id = options?.id ?? asBranchId(generateId());
     const workingCopyStrategy = strategy ?? cloneWorkingCopyStrategy(makeBackend);
     const store = await workingCopyStrategy.create(baseStore);
-    return ok({ id, base, store });
+    const schemaAnchor = await readSchemaAnchor(store);
+    return ok({
+      id,
+      base,
+      store,
+      ...schemaAnchor === void 0 ? { schemaAnchor: void 0 } : { schemaAnchor }
+    });
   } catch (error) {
     return err(
       new BranchError("Failed to create working-copy branch of base store", {
@@ -598,6 +1506,18 @@ async function branch(baseStore, makeBackend, options, strategy) {
     );
   }
 }
+async function readSchemaAnchor(store) {
+  try {
+    const schemaRow = await storeBackend(store).getActiveSchema(store.graphId);
+    return schemaRow === void 0 ? void 0 : { version: schemaRow.version, hash: schemaRow.schema_hash };
+  } catch (error) {
+    try {
+      await storeBackend(store).close();
+    } catch {
+    }
+    throw error;
+  }
+}
 
 // src/graph-merge/blocking.ts
 var UNBLOCKED_BUCKET_KEY = "unblocked";
@@ -610,7 +1530,7 @@ function isUniqueBucketKey(key) {
 function constraintSignature(node, constraint) {
   const props = node;
   for (const field of constraint.fields) {
-    const value = props[field];
+    const value = readOwnProperty(props, field);
     if (value === void 0 || value === null) {
       return void 0;
     }
@@ -734,7 +1654,7 @@ function collectConflictingValues(property, contributions) {
   const seen = /* @__PURE__ */ new Set();
   const values = [];
   for (const { branchId, props } of contributions) {
-    if (!(property in props)) {
+    if (!hasOwnKey(props, property)) {
       continue;
     }
     const value = props[property];
@@ -807,6 +1727,9 @@ 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);
@@ -839,11 +1762,11 @@ function findPreferredMember(members, property, preferredBranchId) {
     return void 0;
   }
   return members.find(
-    (member) => member.branchId === preferredBranchId && property in member.props
+    (member) => member.branchId === preferredBranchId && hasOwnKey(member.props, property)
   );
 }
 function memberPropertyValue(member, property) {
-  if (!(property in member.props)) {
+  if (!hasOwnKey(member.props, property)) {
     return void 0;
   }
   return member.props[property];
@@ -871,7 +1794,7 @@ function unionProperties(canonicalMember, members, context, baseContext, branchR
       propertyNames.add(name);
     }
   }
-  const props = {};
+  const props = createDataKeyedBag();
   const conflicts = [];
   for (const property of [...propertyNames].sort(
     (left, right) => compareStrings(left, right)
@@ -888,7 +1811,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" && hasOwnKey(member.props, property)
     );
     const reportedValues = values.filter(
       (value2) => value2.branchId !== BASE_PROVENANCE_BRANCH && value2.branchId !== preferredBranchId
@@ -929,89 +1852,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) => compareStrings(left, right));
-  const branchOrigins = [
-    ...new Set(
-      members.map((member) => member.branchId).filter(
-        (branchId) => branchId !== BASE_PROVENANCE_BRANCH && branchId !== preferredBranchId
-      )
-    )
-  ].sort((left, right) => 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 = requireDefined(this.parent.get(root));
-    }
-    let cursor = value;
-    while (cursor !== root) {
-      const next = 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) => compareStrings(left, right));
+  const branchOrigins = [
+    ...new Set(
+      members.map((member) => member.branchId).filter(
+        (branchId) => branchId !== BASE_PROVENANCE_BRANCH && branchId !== preferredBranchId
+      )
+    )
+  ].sort((left, right) => 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([
+  META_EDGE_EQUIVALENT_TO,
+  META_EDGE_SAME_AS
+]);
 function buildSubClassClosure(ontology) {
   const unionFind = new UnionFind(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);
     }
   }
@@ -1073,7 +1963,7 @@ function clampScore(value) {
   return value;
 }
 function readField(node, field) {
-  return node[field];
+  return readOwnProperty(node, field);
 }
 function fieldText(node, fields) {
   const parts = [];
@@ -1611,7 +2501,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 = [];
@@ -1656,7 +2546,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) {
@@ -1746,7 +2636,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
@@ -1759,7 +2649,7 @@ function resolveDeleteModify(staging, policy, branchRank, preferredBranchId) {
   };
 }
 function threeWayMergeProps(entityId, kind, baseProps, contributions, context, branchRank, preferredBranchId) {
-  const merged = {};
+  const merged = createDataKeyedBag();
   const conflicts = [];
   const propertyNames = new Set(Object.keys(baseProps));
   for (const contribution of contributions) {
@@ -1768,10 +2658,10 @@ function threeWayMergeProps(entityId, kind, baseProps, contributions, context, b
     }
   }
   for (const property of [...propertyNames].sort(compareStrings)) {
-    const baseHas = property in baseProps;
+    const baseHas = hasOwnKey(baseProps, property);
     const baseKey = baseHas ? canonicalValueKey(requireDefined(baseProps[property])) : void 0;
     const changed = contributions.filter((contribution) => {
-      if (!(property in contribution.forkProps)) {
+      if (!hasOwnKey(contribution.forkProps, property)) {
         return false;
       }
       const value2 = contribution.forkProps[property];
@@ -1783,7 +2673,7 @@ 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) => !hasOwnKey(contribution.forkProps, property)
       );
       if (baseHas && !deletedByFork) {
         merged[property] = requireDefined(baseProps[property]);
@@ -1834,7 +2724,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
@@ -1861,8 +2751,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 || 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) => 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 = 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) => 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) {
@@ -1882,16 +2930,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) => compareStrings(left, right));
+    pairs.set(id, 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 || compareStrings(id, representative) < 0) {
+      representatives.set(pair, id);
+    }
+  }
+  const collapsed = [];
+  const parallel = [];
+  for (const id of [...rows.keys()].sort(
+    (left, right) => compareStrings(left, right)
+  )) {
+    const members = requireDefined(rows.get(id));
+    const pair = 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 = 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 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 = 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 requireDefined(
+    [...candidates].sort(
+      (left, right) => compareMembers(left, right, preferredBranchId)
+    )[0]
+  );
+}
+function authoredProperty(edge, property) {
+  const { props, baseProps } = edge.staged;
+  if (!hasOwnKey(props, property)) {
+    return false;
+  }
+  if (baseProps === void 0 || !hasOwnKey(baseProps, property)) {
+    return true;
   }
-  return survivor;
+  return canonicalValueKey(props[property]) !== canonicalValueKey(baseProps[property]);
+}
+function unauthoredValue(property, edges) {
+  const carriers = edges.filter((edge) => hasOwnKey(edge.staged.props, property)).sort((left, right) => {
+    const byId2 = compareStrings(left.staged.id, right.staged.id);
+    return byId2 === 0 ? compareStrings(
+      canonicalValueKey(left.staged.props[property]),
+      canonicalValueKey(right.staged.props[property])
+    ) : byId2;
+  });
+  return requireDefined(carriers[0]).staged.props[property];
 }
 function unionEdgeProps(survivorId, kind, survivor, edges, context, branchRank, preferredBranchId) {
   const propertyNames = /* @__PURE__ */ new Set();
@@ -1900,17 +3029,18 @@ function unionEdgeProps(survivorId, kind, survivor, edges, context, branchRank,
       propertyNames.add(name);
     }
   }
-  const props = {};
+  const props = createDataKeyedBag();
   const conflicts = [];
-  const contributions = edges.map((edge) => edge.staged);
   for (const property of [...propertyNames].sort(
     (left, right) => 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] = hasOwnKey(survivor.staged.props, property) ? survivor.staged.props[property] : unauthoredValue(property, edges);
       continue;
     }
-    const survivorValue = property in survivor.staged.props ? survivor.staged.props[property] : requireDefined(values[0]).value;
+    const survivorValue = hasOwnKey(survivor.staged.props, property) ? survivor.staged.props[property] : requireDefined(values[0]).value;
     const canonicalValue = values.find((value2) => value2.branchId === preferredBranchId)?.value ?? survivorValue;
     const reportedValues = preferredBranchId === void 0 ? values : values.filter((value2) => value2.branchId !== preferredBranchId);
     const { value, conflict } = resolvePropertyUnion(
@@ -1932,16 +3062,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) => 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: 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",
@@ -1950,21 +3139,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,
@@ -1972,68 +3160,35 @@ function repointEdges(stagedEdges, canonicalOf, deletedNodeIds, policy, branchRa
   };
   const merged = [];
   const conflicts = [];
-  const sortedGroups = [...dedupeKeyByGroup.keys()].sort(
+  const sortedGroups = [...liveByGroup.keys()].sort(
     (left, right) => compareStrings(left, right)
   );
   for (const group of sortedGroups) {
-    const dedupeKeys = [...requireDefined(dedupeKeyByGroup.get(group))];
-    const groupEdges = [];
-    for (const key of dedupeKeys) {
-      for (const edge of requireDefined(liveByDedupeKey.get(key))) {
-        groupEdges.push(edge);
+    const groupEdges = 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) => 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
-    )
+    sortKey: JSON.stringify([
+      dedupeKey(
+        mergeKey(edge.fromKind, edge.fromId),
+        edge.kind,
+        mergeKey(edge.toKind, edge.toId),
+        edge.props
+      ),
+      edge.id
+    ])
   })).sort((left, right) => compareStrings(left.sortKey, right.sortKey)).map(({ edge }) => edge);
   return {
     edges: sortedEdges,
@@ -2085,7 +3240,7 @@ function validateResolveMap(resolve) {
     return {};
   }
   const configs = resolve;
-  const validated = {};
+  const validated = createDataKeyedBag();
   for (const [kind, config] of Object.entries(configs)) {
     const parsed = resolveConfigScalarSchema.safeParse({
       threshold: config.threshold
@@ -2113,7 +3268,7 @@ function validateResolveMap(resolve) {
     }
     validated[kind] = config;
   }
-  return validated;
+  return { ...validated };
 }
 function validateProvenanceWeights(weights) {
   for (const [branchId, weight] of weights) {
@@ -2168,7 +3323,9 @@ function normalizeMergeOptions(options = {}) {
     ...provenanceWeights === void 0 ? {} : { provenanceWeights }
   };
 }
-var Provenance = defineNode("Provenance", {
+var PROVENANCE_KIND = "Provenance";
+var PROVENANCE_OWNER_KIND = "ProvenanceOwner";
+var Provenance = defineNode(PROVENANCE_KIND, {
   schema: z.object({
     targetGraphId: z.string(),
     role: z.enum(["node", "edge"]),
@@ -2178,11 +3335,31 @@ var Provenance = defineNode("Provenance", {
     sourceId: z.string()
   })
 });
+var PROVENANCE_OWNER = "@nicia-ai/typegraph/merge-provenance";
+var PROVENANCE_OWNER_VERSION = 1;
+var PROVENANCE_OWNER_ID = "merge-provenance-owner";
+var ProvenanceOwner = defineNode(PROVENANCE_OWNER_KIND, {
+  schema: z.object({
+    owner: z.literal(PROVENANCE_OWNER),
+    version: z.literal(PROVENANCE_OWNER_VERSION),
+    targetGraphId: z.string()
+  })
+});
 function provenanceGraphId(targetGraphId) {
   return `${targetGraphId}::merge-provenance`;
 }
+function buildOwnedProvenanceGraph(targetGraphId) {
+  return defineInternalGraph({
+    id: provenanceGraphId(targetGraphId),
+    nodes: {
+      Provenance: { type: Provenance },
+      ProvenanceOwner: { type: ProvenanceOwner }
+    },
+    edges: {}
+  });
+}
 function buildProvenanceGraph(targetGraphId) {
-  return defineGraph({
+  return defineInternalGraph({
     id: provenanceGraphId(targetGraphId),
     nodes: { Provenance: { type: Provenance } },
     edges: {}
@@ -2190,26 +3367,276 @@ function buildProvenanceGraph(targetGraphId) {
 }
 async function openProvenanceStore(...args) {
   const [backend, targetGraphId] = args.length === 1 ? [storeBackend(args[0]), args[0].graphId] : args;
-  const [store] = await createStoreWithSchema(
-    buildProvenanceGraph(targetGraphId),
-    backend
-  );
+  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 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 = createSqlSchema(tx.tableNames);
+  await tx.executeStatement(
+    asCompiledStatementSql(
+      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 computeSchemaHash(
+    serializeSchema(graph, activeSchema.version)
+  );
+  if (activeSchema.schema_hash === ownedHash) {
+    return { state: "refuse", reason: "unowned-exact-schema-graph" };
+  }
+  const legacyHash = await computeSchemaHash(
+    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 ConfigurationError(
+    refusal.describe(graphId, targetGraphId),
+    {
+      code: "GRAPH_MERGE_PROVENANCE_ID_COLLISION",
+      reason,
+      graphId,
+      targetGraphId
+    },
+    { suggestion: refusal.suggestion(graphId) }
+  );
+}
+function provenanceClaimUnfenced(graphId, targetGraphId) {
+  return new 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 = createSqlSchema(port.tableNames);
+  const kindFilter = scope === "any" ? sql.empty() : sql` AND kind <> ${PROVENANCE_KIND}`;
+  if (await hasRowsInTable(port, schema.tables.nodes, graphId, kindFilter)) {
+    return true;
+  }
+  if (await hasRowsInTable(port, schema.tables.edges, graphId, 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(
+    asCompiledRowsSql(
+      sql`SELECT 1 AS present FROM ${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, sql.empty());
+  }
+  try {
+    return await hasRowsInTable(port, tableName, graphId, 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
+  });
+  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)) ? 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 sha256Hex(tuple, ID_DIGEST_BYTES);
   return `prov_${digest}`;
 }
@@ -2217,7 +3644,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: {
@@ -2230,6 +3657,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;
 }
@@ -2254,7 +3686,7 @@ function sortedBucketKeys(blocks) {
 }
 var NODE_SYSTEM_FIELDS = /* @__PURE__ */ new Set(["id", "kind", "meta"]);
 function nodeProps(node) {
-  const props = {};
+  const props = createDataKeyedBag();
   for (const [key, value] of Object.entries(
     node
   )) {
@@ -2597,6 +4029,11 @@ async function stageBranches(baseStore, branches, captureTargetStateFor) {
   const newEdges = [];
   const modifiedEdges = [];
   const deletedEdges = [];
+  const windowedNodes = [];
+  const windowedEdges = [];
+  const newIdentityAssertions = [];
+  const retractedIdentityAssertions = [];
+  const baseIdentityAssertions = await storeRuntime(baseStore).readCurrentIdentityAssertions("state");
   let targetNodeVersions = /* @__PURE__ */ new Map();
   let targetEdgeSignatures = /* @__PURE__ */ new Map();
   for (const branch2 of branches) {
@@ -2628,6 +4065,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),
@@ -2644,6 +4097,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 = compareStrings(left.assertion.id, right.assertion.id);
+      return byId2 === 0 ? compareStrings(left.branchId, right.branchId) : byId2;
+    }),
+    retractedIdentityAssertions: retractedIdentityAssertions.toSorted(
+      (left, right) => {
+        const byId2 = compareStrings(left.assertion.id, right.assertion.id);
+        return byId2 === 0 ? compareStrings(left.branchId, right.branchId) : byId2;
+      }
+    ),
+    baseIdentityAssertions: baseIdentityAssertions.toSorted(
+      (left, right) => compareStrings(left.id, right.id)
+    ),
     targetNodeVersions,
     targetEdgeSignatures
   };
@@ -2759,7 +4231,6 @@ function reconcileTypes(clusters, closure, mode) {
 }
 
 // src/graph-merge/merge.ts
-var COMMITTED_TARGET_BRANCH = asBranchId("__committed_target__");
 function asNode(staged) {
   return {
     kind: staged.node.kind,
@@ -2801,10 +4272,12 @@ 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) => compareStrings(left, right)
   );
@@ -2818,6 +4291,7 @@ async function precomputeEmbeddings(byKind, resolve, embedder) {
       }
     );
   }
+  const lookup = /* @__PURE__ */ new Map();
   for (const [index, text] of orderedTexts.entries()) {
     lookup.set(text, requireDefined(vectors[index]));
   }
@@ -2841,24 +4315,7 @@ async function embedMissingPairTexts(base, pairs, strategy, embedder) {
   if (missing.size === 0) {
     return existing;
   }
-  const orderedTexts = [...missing].sort(
-    (left, right) => 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, 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 = [];
@@ -2957,7 +4414,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);
@@ -2988,37 +4447,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) {
@@ -3048,25 +4540,29 @@ function buildProvenanceIndex(records) {
     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();
@@ -3159,6 +4655,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",
@@ -3207,6 +4731,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,
@@ -3220,18 +4769,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(
@@ -3254,7 +4842,11 @@ 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) => compareStrings(`${left.kind}|${left.id}`, `${right.kind}|${right.id}`)
   );
@@ -3271,6 +4863,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
@@ -3316,7 +4912,9 @@ function planMerge(staging, candidateEdges, candidateWarnings, baseMembers, opti
       )
     ),
     provenanceRecords,
-    warnings: candidateWarnings
+    warnings: candidateWarnings,
+    identityAssertions: identityRemap.assertions,
+    identityRetractions: survivingRetractions
   };
 }
 function pickClusterCanonical(cluster, entityByIdentity) {
@@ -3331,78 +4929,125 @@ function pickClusterCanonical(cluster, entityByIdentity) {
   );
 }
 function commitModificationProps(baseProps, forkProps) {
-  const props = { ...forkProps };
+  const props = createDataKeyedBag();
+  for (const key of Object.keys(forkProps)) {
+    props[key] = forkProps[key];
+  }
   for (const key of Object.keys(baseProps)) {
-    if (!(key in forkProps)) {
+    if (!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: 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) {
@@ -3416,7 +5061,31 @@ 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 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 (!storeBackend(target).capabilities.transactions) {
@@ -3434,10 +5103,13 @@ async function commitPlan(target, plan, expectedBaseVersion) {
           expectedBaseVersion
         );
       }
+      await assertPlannedIdentityIdsFresh(target, transactionBackend(tx), plan);
       return applyMergePlan(
         plan,
         tx.nodes,
-        tx.edges
+        tx.edges,
+        target,
+        transactionBackend(tx)
       );
     }, mergeCommitTransactionOptions(target))
   );
@@ -3486,7 +5158,8 @@ async function assertTargetUnchanged(txBackend, target, expectedBaseVersion) {
   const liveContent = await computeContentComponent(
     txBackend,
     target.graphId,
-    target.graph
+    target.graph,
+    await storeRuntime(target).identityAssertionsAtTarget(txBackend, "state")
   );
   const expectedContent = contentComponentOf(expectedBaseVersion);
   if (liveContent !== expectedContent) {
@@ -3540,11 +5213,41 @@ async function validateBaseVersions(target, branches) {
   }
   return ok(targetVersion);
 }
-function tryNormalize(optionsInput) {
+function tryNormalize(optionsInput, refusedOptions = []) {
+  const refusedOption = refusedOptions.find(
+    (option) => hasOwnKey(optionsInput, option)
+  );
+  if (refusedOption !== void 0) {
+    return err(
+      new InvalidMergeOptionsError(
+        `This merge operation does not accept options.${refusedOption}.`,
+        { details: { option: refusedOption } }
+      )
+    );
+  }
   try {
     return ok(normalizeMergeOptions(optionsInput));
   } catch (error) {
-    return err(new MergeError("Invalid merge options.", { cause: error }));
+    return err(
+      new InvalidMergeOptionsError("Invalid merge options.", { cause: error })
+    );
+  }
+}
+async function tryOpenProvenanceStore(target) {
+  try {
+    return ok(await openProvenanceStore(target));
+  } catch (error) {
+    const code = error instanceof 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 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) {
@@ -3570,9 +5273,44 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
       targetBranchSeen = true;
     }
   }
+  for (const branch2 of branches) {
+    const branchSchemaRow = await 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 storeBackend(store).getActiveSchema(
+        store.graphId
+      );
+      drifted = branchSchemaRow?.schema_hash !== sourceSchemaRow?.schema_hash;
+    }
+    if (drifted) {
+      return 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 && 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,
@@ -3588,7 +5326,7 @@ 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
     );
@@ -3608,6 +5346,35 @@ async function resolveMerge(store, target, branches, options, useBaseSources, in
     if (isErr(candidates)) {
       return 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 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 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,
@@ -3616,12 +5383,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 storeRuntime(target).identityAssertionRowsByIds(
+          plan.identityAssertions.map((assertion) => assertion.id)
+        )
+      );
+    }
+    let identityGuard;
+    if (identityProbeIds !== void 0 && incremental !== void 0) {
+      const freshPeers = await 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(
@@ -3633,11 +5451,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 && !isErr(provenanceStore)) {
       try {
-        const provenanceStore = await openProvenanceStore(target);
         const count = await persistProvenanceRecords(
-          provenanceStore,
+          provenanceStore.data,
           target.graphId,
           plan.provenanceRecords
         );
@@ -3658,6 +5475,7 @@ 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,
@@ -3751,7 +5569,7 @@ function analyzeRevalidatingWrite(schema, current, planned) {
   };
 }
 function nodeProps2(node) {
-  const props = {};
+  const props = createDataKeyedBag();
   for (const [key, value] of Object.entries(node)) {
     if (key === "id" || key === "kind" || key === "meta") continue;
     props[key] = value;
@@ -3759,7 +5577,7 @@ function nodeProps2(node) {
   return props;
 }
 function edgeProps(edge) {
-  const props = {};
+  const props = 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;
@@ -3769,70 +5587,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,
@@ -3874,7 +5636,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,
@@ -3975,8 +5737,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.`,
@@ -4148,6 +5910,20 @@ 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 (!storeBackend(target).capabilities.transactions) {
     throw new MergeError(
@@ -4160,28 +5936,48 @@ async function commitIncrementalPlan(target, plan, guard) {
       if (target.revisionTrackingEnabled) {
         await lockRecordedGraphWrite(transactionBackend(tx), target.graphId);
       }
+      await assertForkPointUnchanged(guard.forkPoint);
       const nodesApi = tx.nodes;
       const edgesApi = tx.edges;
       await assertBaseResolutionStable(tx, guard);
+      await assertPlannedIdentityIdsFresh(target, transactionBackend(tx), plan);
+      await assertIdentityPeersStable(
+        target,
+        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,
+        transactionBackend(tx)
+      );
     }, mergeCommitTransactionOptions(target))
   );
 }
 async function mergeIncremental(args) {
   const { forkPoint, target, branches } = args;
-  const normalized = tryNormalize(args.options ?? {});
+  const normalized = tryNormalize(args.options ?? {}, ["target"]);
   if (isErr(normalized)) {
     return err(normalized.error);
   }
   const options = normalized.data;
   if (options.onBasePropertyConflict !== "flag") {
     return err(
-      new MergeError(
+      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
+          }
+        }
       )
     );
   }
@@ -4213,10 +6009,16 @@ 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 }
+    }
   );
 }
 
-export { BaseVersionMismatchError, BranchError, MERGE_ERROR_CODES, MERGE_OPTION_DEFAULTS, MergeConflictError, MergeError, SimilarityUnavailableError, asBaseVersion, asBranchId, branch, cloneWorkingCopyStrategy, computeBaseVersion, merge, mergeIncremental, normalizeMergeOptions, openProvenanceStore, persistProvenanceRecords, provenanceGraphId, readProvenance };
+export { BaseVersionMismatchError, BranchError, IdentityMergeConflictError, InvalidMergeOptionsError, MERGE_ERROR_CODES, MERGE_OPTION_DEFAULTS, MergeConflictError, MergeError, SimilarityUnavailableError, VALIDITY_END_TARGET_PRECEDENCE, asBaseVersion, asBranchId, branch, cloneWorkingCopyStrategy, computeBaseVersion, merge, mergeIncremental, normalizeMergeOptions, openProvenanceStore, persistProvenanceRecords, provenanceGraphId, readProvenance };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map