@nicia-ai/typegraph 0.45.0 → 0.46.1

package/dist/{chunk-FQ7ZPOTZ.js → chunk-LGHCOKTT.js}

@@ -1,17 +1,20 @@
-import { compareStrings } from './chunk-DRACN6XG.js';
-import { META_EDGE_BRAND, getTypeName, defineEdge, defineNode } from './chunk-TKP5T34P.js';
-import { canonicalEqual, sortedReplacer } from './chunk-UR7W5YQK.js';
-import { isMissingTableError } from './chunk-V34A6R5V.js';
-import { getNodeKinds, getEdgeKinds, autoDeriveVectorIndexes, mergeVectorIndexes } from './chunk-S4KQ5LV4.js';
-import { nowIso } from './chunk-KCO5EFJU.js';
-import { defineNodeIndex, defineEdgeIndex } from './chunk-FLEQ2HBK.js';
+import { META_EDGE_BRAND, getTypeName, defineEdge, defineNode } from './chunk-JXA2ZP2Q.js';
+import { separationRebuildRequired, hasAssertionsTouchingKinds, lockIdentityGraph, lockIdentityEnablementNodes, purgeAssertionsWithUnregisteredKinds, deleteAssertionsTouchingKinds, rebuildIdentityClosureForContext } from './chunk-GF3KXUTW.js';
+import { lockRecordedGraphWrite, withRecordedIdentityMutationTarget, compareStrings } from './chunk-NLI2AVEF.js';
+import { canonicalEqual, sortedReplacer } from './chunk-JBQQ7THH.js';
+import { isMissingTableError, errorChain, isPostgresConcurrentDdlRaceError } from './chunk-JZUR7ZWE.js';
+import { createSqlSchema, requireSqlSchema } from './chunk-MSY7FSX4.js';
+import { getNodeKinds, getEdgeKinds, autoDeriveVectorIndexes, mergeVectorIndexes } from './chunk-775A4ZMN.js';
+import { captureWherePredicate } from './chunk-WDGA7IYB.js';
+import { nowIso } from './chunk-XL7SLCXS.js';
+import { defineNodeIndex, defineEdgeIndex } from './chunk-I5MOXA4H.js';
 import { sha256Hex } from './chunk-K34OPSJK.js';
-import { requireDefined } from './chunk-QMQLUA66.js';
+import { asCompiledRowsSql, sql } from './chunk-PQBQG7IM.js';
 import { resolveGraphVectorSlots, embedding, searchable } from './chunk-PC2UBAUB.js';
-import { isReachable, LEGACY_GRAPH_EXTENSION_VERSION, unwrap, validateGraphExtension, KindCollisionError, GraphExtensionUnresolvedEndpointError, RemoveCompileTimeKindError, KindHasReferentsError, computeTransitiveClosure, invertClosure } from './chunk-4GUBTVPV.js';
-import { ALL_META_EDGE_NAMES, META_EDGE_IMPLIES, META_EDGE_INVERSE_OF, META_EDGE_PART_OF, META_EDGE_HAS_PART, META_EDGE_DISJOINT_WITH, META_EDGE_DIFFERENT_FROM, META_EDGE_SAME_AS, META_EDGE_EQUIVALENT_TO, META_EDGE_RELATED_TO, META_EDGE_BROADER, META_EDGE_NARROWER, META_EDGE_SUB_CLASS_OF } from './chunk-GYA4JRP5.js';
-import { compactUndefined, freezeDeep } from './chunk-ITE4IXAK.js';
-import { ConfigurationError, KindNotFoundError, DatabaseOperationError, MigrationError, StaleVersionError } from './chunk-4MB3AQAQ.js';
+import { LEGACY_GRAPH_EXTENSION_VERSION, computeClosuresFromOntology, unwrap, validateGraphExtension, KindCollisionError, GraphExtensionUnresolvedEndpointError, isExternalIri, GraphExtensionUnresolvedOntologyEndpointError, RemoveCompileTimeKindError, KindHasReferentsError, KindRegistry, createEmptyClosures, validateOntologyRelations, computeClosuresFromNamedOntology } from './chunk-T4XNKYXB.js';
+import { ALL_META_EDGE_NAMES, META_EDGE_IMPLIES, META_EDGE_INVERSE_OF, META_EDGE_PART_OF, META_EDGE_HAS_PART, META_EDGE_DISJOINT_WITH, META_EDGE_DIFFERENT_FROM, META_EDGE_SAME_AS, META_EDGE_EQUIVALENT_TO, META_EDGE_RELATED_TO, META_EDGE_BROADER, META_EDGE_NARROWER, META_EDGE_SUB_CLASS_OF } from './chunk-JXXDZTMN.js';
+import { ConfigurationError, KindNotFoundError, DatabaseOperationError, MigrationError, StaleVersionError } from './chunk-J3WZ3FA2.js';
+import { requireDefined, hasOwnKey, createDataKeyedBag, compactUndefined, freezeDeep } from './chunk-DYATYRY4.js';
 import { z } from 'zod';
 
 // src/ontology/core-meta-edges.ts
@@ -96,7 +99,7 @@ var sameAsMetaEdge = createMetaEdge(META_EDGE_SAME_AS, {
   symmetric: true,
   transitive: true,
   inference: "substitution",
-  description: "Same individual (for deduplication)"
+  description: "Deprecated type-level equivalence alias"
 });
 function sameAs(kindA, kindBOrIri) {
   return {
@@ -108,7 +111,7 @@ function sameAs(kindA, kindBOrIri) {
 var differentFromMetaEdge = createMetaEdge(META_EDGE_DIFFERENT_FROM, {
   symmetric: true,
   inference: "constraint",
-  description: "Explicitly different individuals"
+  description: "Deprecated decorative type-level non-identity relation"
 });
 function differentFrom(kindA, kindB) {
   return {
@@ -199,7 +202,9 @@ var core = {
   narrower,
   relatedTo,
   equivalentTo,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated -- compatibility member until the next major
   sameAs,
+  // eslint-disable-next-line @typescript-eslint/no-deprecated -- compatibility member until the next major
   differentFrom,
   disjointWith,
   partOf,
@@ -213,6 +218,7 @@ function computeSchemaDiff(before, after) {
   const nodeChanges = diffNodes(before.nodes, after.nodes);
   const edgeChanges = diffEdges(before.edges, after.edges);
   const ontologyChanges = diffOntology(before.ontology, after.ontology);
+  const identityChange = diffIdentity(before.identity, after.identity);
   const indexChanges = diffIndexes(before.indexes, after.indexes);
   const extensionChange = diffExtension(before.extension, after.extension);
   const deprecatedKindsChange = diffDeprecatedKinds(
@@ -225,14 +231,13 @@ function computeSchemaDiff(before, after) {
     ...ontologyChanges,
     ...indexChanges
   ];
-  const hasBreakingChanges = allChanges.some(
-    (change) => change.severity === "breaking"
-  );
-  const hasChanges = allChanges.length > 0 || extensionChange !== void 0 || deprecatedKindsChange !== void 0;
+  const hasBreakingChanges = allChanges.some((change) => change.severity === "breaking") || identityChange?.severity === "breaking";
+  const hasChanges = allChanges.length > 0 || identityChange !== void 0 || extensionChange !== void 0 || deprecatedKindsChange !== void 0;
   const summary = generateSummary(
     nodeChanges,
     edgeChanges,
     ontologyChanges,
+    identityChange,
     indexChanges,
     extensionChange,
     deprecatedKindsChange
@@ -243,6 +248,7 @@ function computeSchemaDiff(before, after) {
     nodes: nodeChanges,
     edges: edgeChanges,
     ontology: ontologyChanges,
+    ...identityChange === void 0 ? {} : { identity: identityChange },
     indexes: indexChanges,
     ...extensionChange === void 0 ? {} : { extension: extensionChange },
     ...deprecatedKindsChange === void 0 ? {} : { deprecatedKinds: deprecatedKindsChange },
@@ -252,6 +258,29 @@ function computeSchemaDiff(before, after) {
     summary
   };
 }
+function diffIdentity(before, after) {
+  if (before === void 0 && after === void 0) return;
+  if (before === void 0) {
+    return {
+      type: "added",
+      severity: "safe",
+      details: "Operational Identity enabled"
+    };
+  }
+  if (after === void 0) {
+    return {
+      type: "removed",
+      severity: "breaking",
+      details: "Operational Identity disabled"
+    };
+  }
+  if (before.sameIdAcrossKinds === after.sameIdAcrossKinds) return;
+  return {
+    type: "modified",
+    severity: "breaking",
+    details: `Operational Identity sameIdAcrossKinds changed from "${before.sameIdAcrossKinds}" to "${after.sameIdAcrossKinds}"`
+  };
+}
 function diffNodes(before, after) {
   const changes = [];
   const beforeNames = new Set(Object.keys(before));
@@ -327,7 +356,7 @@ function orderNormalizedSchema(value) {
     return value.map((item) => orderNormalizedSchema(item));
   }
   if (value !== null && typeof value === "object") {
-    const normalized = {};
+    const normalized = createDataKeyedBag();
     for (const [key, entry] of Object.entries(value)) {
       normalized[key] = normalizedKeywordValue(key, entry);
     }
@@ -350,7 +379,7 @@ function normalizedDependentRequired(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return value;
   }
-  const normalized = {};
+  const normalized = createDataKeyedBag();
   for (const [name, required] of Object.entries(value)) {
     normalized[name] = Array.isArray(required) ? sortedByCanonicalForm(required) : required;
   }
@@ -360,7 +389,7 @@ function normalizedSubschemaMap(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return orderNormalizedSchema(value);
   }
-  const normalized = {};
+  const normalized = createDataKeyedBag();
   for (const [name, subschema] of Object.entries(value)) {
     normalized[name] = orderNormalizedSchema(subschema);
   }
@@ -440,7 +469,7 @@ var NON_CONSTRAINING_KEYWORDS = /* @__PURE__ */ new Set([
   "$schema"
 ]);
 function stripSchemaMetadata(schema) {
-  const stripped = {};
+  const stripped = createDataKeyedBag();
   for (const [key, value] of Object.entries(schema)) {
     if (!NON_CONSTRAINING_KEYWORDS.has(key)) stripped[key] = value;
   }
@@ -470,7 +499,7 @@ function isBreakingObjectSchemaChange(before, after) {
   const beforeRequired = new Set(before.required);
   const afterRequired = new Set(after.required);
   for (const key of Object.keys(beforeProps)) {
-    if (!(key in afterProps)) return true;
+    if (!hasOwnKey(afterProps, key)) return true;
   }
   for (const key of afterRequired) {
     if (!beforeRequired.has(key)) return true;
@@ -487,9 +516,15 @@ function classifyPropertyChanges(kind, before, after) {
   const afterProps = after.properties ?? {};
   const beforeRequired = new Set(before.required);
   const afterRequired = new Set(after.required);
-  const removed = Object.keys(beforeProps).filter((p) => !(p in afterProps));
-  const added = Object.keys(afterProps).filter((p) => !(p in beforeProps));
-  const newRequired = [...afterRequired].filter((p) => !beforeRequired.has(p));
+  const removed = Object.keys(beforeProps).filter(
+    (property) => !hasOwnKey(afterProps, property)
+  );
+  const added = Object.keys(afterProps).filter(
+    (property) => !hasOwnKey(beforeProps, property)
+  );
+  const newRequired = [...afterRequired].filter(
+    (property) => !beforeRequired.has(property)
+  );
   const breakingProps = [];
   for (const [property, beforeProperty] of Object.entries(beforeProps)) {
     const afterProperty = afterProps[property];
@@ -783,7 +818,7 @@ function diffDeprecatedKinds(before, after) {
     details: `Deprecated kinds: ${parts.join("; ")}`
   };
 }
-function generateSummary(nodeChanges, edgeChanges, ontologyChanges, indexChanges, extensionChange, deprecatedKindsChange) {
+function generateSummary(nodeChanges, edgeChanges, ontologyChanges, identityChange, indexChanges, extensionChange, deprecatedKindsChange) {
   const parts = [];
   const nodeAdded = nodeChanges.filter((c) => c.type === "added").length;
   const nodeRemoved = nodeChanges.filter((c) => c.type === "removed").length;
@@ -810,6 +845,9 @@ function generateSummary(nodeChanges, edgeChanges, ontologyChanges, indexChanges
   if (ontologyAdded > 0 || ontologyRemoved > 0) {
     parts.push(`Ontology: ${ontologyAdded} added, ${ontologyRemoved} removed`);
   }
+  if (identityChange !== void 0) {
+    parts.push(`Identity: ${identityChange.type}`);
+  }
   const indexAdded = indexChanges.filter((c) => c.type === "added").length;
   const indexRemoved = indexChanges.filter((c) => c.type === "removed").length;
   const indexModified = indexChanges.filter(
@@ -858,419 +896,30 @@ function getMigrationActions(diff) {
       actions.push(`DELETE data for removed edge kind "${change.kind}"`);
     }
   }
-  return actions;
-}
-
-// src/registry/kind-registry.ts
-var KindRegistry = class {
-  // === Node & Edge Kinds ===
-  nodeKinds;
-  edgeKinds;
-  // === Subsumption (subClassOf) ===
-  // Transitive closure for inheritance
-  subClassAncestors;
-  subClassDescendants;
-  // === Hierarchy (broader/narrower) ===
-  // Transitive closure for concept hierarchy (separate from subClassOf!)
-  broaderClosure;
-  narrowerClosure;
-  // === Equivalence ===
-  equivalenceSets;
-  iriToKind;
-  // === Constraints ===
-  disjointPairs;
-  // Normalized pairs: "Organization|Person"
-  // === Composition ===
-  partOfClosure;
-  hasPartClosure;
-  // === Edge Relationships ===
-  edgeInverses;
-  edgeImplicationsClosure;
-  edgeImplyingClosure;
-  constructor(nodeKinds, edgeKinds, closures) {
-    this.nodeKinds = nodeKinds;
-    this.edgeKinds = edgeKinds;
-    this.subClassAncestors = closures.subClassAncestors;
-    this.subClassDescendants = closures.subClassDescendants;
-    this.broaderClosure = closures.broaderClosure;
-    this.narrowerClosure = closures.narrowerClosure;
-    this.equivalenceSets = closures.equivalenceSets;
-    this.iriToKind = closures.iriToKind;
-    this.disjointPairs = closures.disjointPairs;
-    this.partOfClosure = closures.partOfClosure;
-    this.hasPartClosure = closures.hasPartClosure;
-    this.edgeInverses = closures.edgeInverses;
-    this.edgeImplicationsClosure = closures.edgeImplicationsClosure;
-    this.edgeImplyingClosure = closures.edgeImplyingClosure;
-  }
-  // === Subsumption Methods ===
-  /**
-   * Checks if child is a subclass of parent (directly or transitively).
-   */
-  isSubClassOf(child, parent) {
-    return isReachable(this.subClassAncestors, child, parent);
-  }
-  /**
-   * Expands a kind to include all its subclasses.
-   * Returns [kind, ...subclasses].
-   */
-  expandSubClasses(kind) {
-    const descendants = this.subClassDescendants.get(kind) ?? /* @__PURE__ */ new Set();
-    return [kind, ...descendants];
-  }
-  /**
-   * Gets all ancestors of a kind (via subClassOf).
-   */
-  getAncestors(kind) {
-    return this.subClassAncestors.get(kind) ?? /* @__PURE__ */ new Set();
-  }
-  /**
-   * Gets all descendants of a kind (via subClassOf).
-   */
-  getDescendants(kind) {
-    return this.subClassDescendants.get(kind) ?? /* @__PURE__ */ new Set();
-  }
-  // === Hierarchy Methods ===
-  /**
-   * Checks if narrowerConcept is narrower than broaderConcept.
-   */
-  isNarrowerThan(narrowerConcept, broaderConcept) {
-    return isReachable(this.broaderClosure, narrowerConcept, broaderConcept);
-  }
-  /**
-   * Checks if broaderConcept is broader than narrowerConcept.
-   */
-  isBroaderThan(broaderConcept, narrowerConcept) {
-    return isReachable(this.narrowerClosure, broaderConcept, narrowerConcept);
-  }
-  /**
-   * Expands to include all narrower concepts.
-   */
-  expandNarrower(kind) {
-    const narrower2 = this.narrowerClosure.get(kind) ?? /* @__PURE__ */ new Set();
-    return [kind, ...narrower2];
-  }
-  /**
-   * Expands to include all broader concepts.
-   */
-  expandBroader(kind) {
-    const broader2 = this.broaderClosure.get(kind) ?? /* @__PURE__ */ new Set();
-    return [kind, ...broader2];
-  }
-  // === Equivalence Methods ===
-  /**
-   * Checks if two kinds are equivalent.
-   */
-  areEquivalent(a, b) {
-    const equivalents = this.equivalenceSets.get(a);
-    return equivalents?.has(b) ?? false;
-  }
-  /**
-   * Gets all equivalents of a kind (including external IRIs).
-   */
-  getEquivalents(kind) {
-    const equivalents = this.equivalenceSets.get(kind);
-    return equivalents ? [...equivalents] : [];
-  }
-  /**
-   * Resolves an external IRI to an internal kind name.
-   */
-  resolveIri(iri) {
-    return this.iriToKind.get(iri);
-  }
-  // === Constraint Methods ===
-  /**
-   * Checks if two kinds are disjoint.
-   */
-  areDisjoint(a, b) {
-    const normalizedPair = a < b ? `${a}|${b}` : `${b}|${a}`;
-    return this.disjointPairs.has(normalizedPair);
-  }
-  /**
-   * Gets all kinds that are disjoint with the given kind.
-   */
-  getDisjointKinds(kind) {
-    const result = [];
-    for (const pair of this.disjointPairs) {
-      const parts = pair.split("|");
-      const firstKind = requireDefined(parts[0]);
-      const secondKind = requireDefined(parts[1]);
-      if (firstKind === kind) result.push(secondKind);
-      else if (secondKind === kind) result.push(firstKind);
-    }
-    return result;
-  }
-  // === Composition Methods ===
-  /**
-   * Checks if part is part of whole (directly or transitively).
-   */
-  isPartOf(part, whole) {
-    return isReachable(this.partOfClosure, part, whole);
-  }
-  /**
-   * Gets all wholes that contain this part.
-   */
-  getWholes(part) {
-    const wholes = this.partOfClosure.get(part);
-    return wholes ? [...wholes] : [];
-  }
-  /**
-   * Gets all parts of this whole.
-   */
-  getParts(whole) {
-    const parts = this.hasPartClosure.get(whole);
-    return parts ? [...parts] : [];
-  }
-  // === Edge Relationship Methods ===
-  /**
-   * Gets the inverse edge kind for a given edge kind.
-   * If edgeA inverseOf edgeB, then getInverseEdge("edgeA") returns "edgeB".
-   */
-  getInverseEdge(edgeKind) {
-    return this.edgeInverses.get(edgeKind);
-  }
-  /**
-   * Gets all edges implied by a given edge (transitively).
-   * If A implies B and B implies C, then getImpliedEdges("A") returns ["B", "C"].
-   */
-  getImpliedEdges(edgeKind) {
-    const implied = this.edgeImplicationsClosure.get(edgeKind);
-    return implied ? [...implied] : [];
-  }
-  /**
-   * Gets all edges that imply a given edge (transitively).
-   * If A implies B and B implies C, then getImplyingEdges("C") returns ["A", "B"].
-   * Used for query-time expansion: when querying for C, also include A and B edges.
-   */
-  getImplyingEdges(edgeKind) {
-    const implying = this.edgeImplyingClosure.get(edgeKind);
-    return implying ? [...implying] : [];
-  }
-  /**
-   * Expands an edge kind to include all edges that imply it.
-   * Returns [edgeKind, ...implyingEdges].
-   */
-  expandImplyingEdges(edgeKind) {
-    const implying = this.edgeImplyingClosure.get(edgeKind) ?? /* @__PURE__ */ new Set();
-    return [edgeKind, ...implying];
-  }
-  // === Edge Endpoint Validation ===
-  /**
-   * Checks if a concrete kind is assignable to a target kind.
-   * Uses subsumption: Company is assignable to Organization if Company subClassOf Organization.
-   */
-  isAssignableTo(concreteKind, targetKind) {
-    if (concreteKind === targetKind) return true;
-    return this.isSubClassOf(concreteKind, targetKind);
-  }
-  /**
-   * Checks if a concrete kind is assignable to at least one of the given
-   * target kinds. Shared by every "is this kind usable where one of these
-   * kinds is expected" check (edge endpoint validation, ontology relation
-   * endpoint compatibility) so they can't independently drift.
-   */
-  isAssignableToAny(concreteKind, targetKinds) {
-    return targetKinds.some(
-      (targetKind) => this.isAssignableTo(concreteKind, targetKind)
-    );
-  }
-  /**
-   * Validates that a kind exists in the registry.
-   */
-  hasNodeType(name) {
-    return this.nodeKinds.has(name);
-  }
-  /**
-   * Validates that an edge kind exists in the registry.
-   */
-  hasEdgeType(name) {
-    return this.edgeKinds.has(name);
-  }
-  /**
-   * Gets a node kind by name.
-   */
-  getNodeType(name) {
-    return this.nodeKinds.get(name);
-  }
-  /**
-   * Gets an edge kind by name.
-   */
-  getEdgeType(name) {
-    return this.edgeKinds.get(name);
-  }
-};
-function createEmptyClosures() {
-  return {
-    subClassAncestors: /* @__PURE__ */ new Map(),
-    subClassDescendants: /* @__PURE__ */ new Map(),
-    broaderClosure: /* @__PURE__ */ new Map(),
-    narrowerClosure: /* @__PURE__ */ new Map(),
-    equivalenceSets: /* @__PURE__ */ new Map(),
-    iriToKind: /* @__PURE__ */ new Map(),
-    disjointPairs: /* @__PURE__ */ new Set(),
-    partOfClosure: /* @__PURE__ */ new Map(),
-    hasPartClosure: /* @__PURE__ */ new Map(),
-    edgeInverses: /* @__PURE__ */ new Map(),
-    edgeImplicationsClosure: /* @__PURE__ */ new Map(),
-    edgeImplyingClosure: /* @__PURE__ */ new Map()
-  };
-}
-function computeClosuresFromOntology(ontology) {
-  const subClassRelations = [];
-  const broaderRelations = [];
-  const equivalentRelations = [];
-  const disjointRelations = [];
-  const partOfRelations = [];
-  const inverseOfRelations = [];
-  const impliesRelations = [];
-  for (const relation of ontology) {
-    const fromName = getKindName(relation.from);
-    const toName = getKindName(relation.to);
-    switch (relation.metaEdge.name) {
-      case META_EDGE_SUB_CLASS_OF: {
-        subClassRelations.push([fromName, toName]);
-        break;
-      }
-      case META_EDGE_BROADER: {
-        broaderRelations.push([fromName, toName]);
-        break;
-      }
-      case META_EDGE_NARROWER: {
-        broaderRelations.push([toName, fromName]);
-        break;
-      }
-      case META_EDGE_EQUIVALENT_TO:
-      case META_EDGE_SAME_AS: {
-        equivalentRelations.push([fromName, toName]);
-        break;
-      }
-      case META_EDGE_DISJOINT_WITH: {
-        disjointRelations.push([fromName, toName]);
+  if (diff.identity !== void 0) {
+    switch (diff.identity.type) {
+      case "added": {
+        actions.push(
+          `BUILD Operational Identity closure: ${diff.identity.details} (materializes the closure table, running a same-id fold scan when sameIdAcrossKinds is "fold")`
+        );
         break;
       }
-      case META_EDGE_PART_OF: {
-        partOfRelations.push([fromName, toName]);
+      case "modified": {
+        actions.push(
+          `REBUILD Operational Identity closure: ${diff.identity.details} (every areSame/membersOf/includeIdentityMembers answer is recomputed under the new profile)`
+        );
         break;
       }
-      case META_EDGE_HAS_PART: {
-        partOfRelations.push([toName, fromName]);
+      case "removed": {
+        actions.push(
+          `DISABLE Operational Identity: ${diff.identity.details} (the materialized closure is left in place, unread; the identity API becomes unavailable)`
+        );
         break;
       }
-      case META_EDGE_INVERSE_OF: {
-        inverseOfRelations.push([fromName, toName]);
-        break;
-      }
-      case META_EDGE_IMPLIES: {
-        impliesRelations.push([fromName, toName]);
-        break;
-      }
-    }
-  }
-  const subClassAncestors = computeTransitiveClosure(subClassRelations);
-  const subClassDescendants = invertClosure(subClassAncestors);
-  const broaderClosure = computeTransitiveClosure(broaderRelations);
-  const narrowerClosure = invertClosure(broaderClosure);
-  const equivalenceSets = computeEquivalenceSets(equivalentRelations);
-  const iriToKind = computeIriMapping(equivalentRelations);
-  const disjointPairs = computeDisjointPairs(disjointRelations);
-  const partOfClosure = computeTransitiveClosure(partOfRelations);
-  const hasPartClosure = invertClosure(partOfClosure);
-  const edgeInverses = computeEdgeInverses(inverseOfRelations);
-  const edgeImplicationsClosure = computeTransitiveClosure(impliesRelations);
-  const edgeImplyingClosure = invertClosure(edgeImplicationsClosure);
-  return {
-    subClassAncestors,
-    subClassDescendants,
-    broaderClosure,
-    narrowerClosure,
-    equivalenceSets,
-    iriToKind,
-    disjointPairs,
-    partOfClosure,
-    hasPartClosure,
-    edgeInverses,
-    edgeImplicationsClosure,
-    edgeImplyingClosure
-  };
-}
-function getKindName(kindOrIri) {
-  if (typeof kindOrIri === "string") {
-    return kindOrIri;
-  }
-  return kindOrIri.kind;
-}
-function isExternalIri(value) {
-  return value.startsWith("http://") || value.startsWith("https://");
-}
-function computeEquivalenceSets(relations) {
-  const parent = /* @__PURE__ */ new Map();
-  function find(x) {
-    if (!parent.has(x)) {
-      parent.set(x, x);
-      return x;
-    }
-    const parentNode = requireDefined(parent.get(x));
-    if (parentNode === x) return x;
-    const root = find(parentNode);
-    parent.set(x, root);
-    return root;
-  }
-  function union(a, b) {
-    const rootA = find(a);
-    const rootB = find(b);
-    if (rootA !== rootB) {
-      parent.set(rootA, rootB);
-    }
-  }
-  for (const [a, b] of relations) {
-    union(a, b);
-  }
-  const classes = /* @__PURE__ */ new Map();
-  for (const key of parent.keys()) {
-    const root = find(key);
-    const existing = classes.get(root) ?? /* @__PURE__ */ new Set();
-    existing.add(key);
-    classes.set(root, existing);
-  }
-  const result = /* @__PURE__ */ new Map();
-  for (const members of classes.values()) {
-    for (const member of members) {
-      const others = new Set(members);
-      others.delete(member);
-      result.set(member, others);
     }
   }
-  return result;
-}
-function computeIriMapping(relations) {
-  const result = /* @__PURE__ */ new Map();
-  for (const [a, b] of relations) {
-    if (isExternalIri(a) && !isExternalIri(b)) {
-      result.set(a, b);
-    } else if (isExternalIri(b) && !isExternalIri(a)) {
-      result.set(b, a);
-    }
-  }
-  return result;
-}
-function computeDisjointPairs(relations) {
-  const result = /* @__PURE__ */ new Set();
-  for (const [a, b] of relations) {
-    const normalized = a < b ? `${a}|${b}` : `${b}|${a}`;
-    result.add(normalized);
-  }
-  return result;
-}
-function computeEdgeInverses(relations) {
-  const result = /* @__PURE__ */ new Map();
-  for (const [a, b] of relations) {
-    result.set(a, b);
-    result.set(b, a);
-  }
-  return result;
+  return actions;
 }
-
-// src/schema/serializer.ts
 function serializeSchema(graph, version) {
   const nodes = serializeNodes(graph);
   const edges = serializeEdges(graph);
@@ -1289,6 +938,7 @@ function serializeSchema(graph, version) {
       onNodeDelete: graph.defaults.onNodeDelete,
       temporalMode: graph.defaults.temporalMode
     },
+    ...graph.identity === void 0 ? {} : { identity: graph.identity },
     // `serializeIndexes` collapses both absent and empty inputs to
     // `undefined` (see the helper's docstring); omit the field entirely
     // in that case so legacy graphs hash byte-identically to the
@@ -1397,13 +1047,13 @@ function serializeEdgeIndexDeclaration(declaration) {
   };
 }
 function serializeNodes(graph) {
-  const result = {};
+  const result = createDataKeyedBag();
   for (const kindName of getNodeKinds(graph)) {
     const registration = graph.nodes[kindName];
     if (registration === void 0) continue;
     result[kindName] = serializeNodeDef(registration);
   }
-  return result;
+  return { ...result };
 }
 function serializeNodeDef(registration) {
   const node = registration.type;
@@ -1427,26 +1077,16 @@ function serializeUniqueConstraints(constraints) {
   }));
 }
 function serializeWherePredicate(whereFunction) {
-  const builder = new Proxy(
-    {},
-    {
-      get(_target, field) {
-        return {
-          isNull: () => ({
-            __type: "unique_predicate",
-            field,
-            op: "isNull"
-          }),
-          isNotNull: () => ({
-            __type: "unique_predicate",
-            field,
-            op: "isNotNull"
-          })
-        };
+  const predicate = captureWherePredicate(whereFunction);
+  if (predicate === void 0) {
+    throw new ConfigurationError(
+      `A unique constraint's \`where\` callback did not return a predicate, so it cannot be persisted.`,
+      {},
+      {
+        suggestion: `Return a field predicate, e.g. \`where: (fields) => fields.someField.isNotNull()\`.`
       }
-    }
-  );
-  const predicate = whereFunction(builder);
+    );
+  }
   return JSON.stringify({ field: predicate.field, op: predicate.op });
 }
 function deserializeWherePredicate(serialized) {
@@ -1465,13 +1105,13 @@ function deserializeWherePredicate(serialized) {
   };
 }
 function serializeEdges(graph) {
-  const result = {};
+  const result = createDataKeyedBag();
   for (const kindName of getEdgeKinds(graph)) {
     const registration = graph.edges[kindName];
     if (registration === void 0) continue;
     result[kindName] = serializeEdgeDef(registration);
   }
-  return result;
+  return { ...result };
 }
 function serializeEdgeDef(registration) {
   const edge = registration.type;
@@ -1495,7 +1135,7 @@ function serializeOntology(relations) {
       metaEdgeMap.set(metaEdge.name, metaEdge);
     }
   }
-  const metaEdges = {};
+  const metaEdges = createDataKeyedBag();
   for (const [name, metaEdge] of metaEdgeMap) {
     metaEdges[name] = serializeMetaEdge(metaEdge);
   }
@@ -1504,7 +1144,7 @@ function serializeOntology(relations) {
   );
   const closures = serializeClosures(relations);
   return {
-    metaEdges,
+    metaEdges: { ...metaEdges },
     relations: serializedRelations,
     closures
   };
@@ -1561,11 +1201,11 @@ function serializeClosures(relations) {
   };
 }
 function mapToRecord(map) {
-  const result = {};
+  const result = createDataKeyedBag();
   for (const [key, values] of map) {
     result[key] = [...values];
   }
-  return result;
+  return { ...result };
 }
 function mapToSimpleRecord(map) {
   return Object.fromEntries(map);
@@ -1606,6 +1246,7 @@ async function computeSchemaHash(schema) {
     edges: schema.edges,
     ontology: schema.ontology,
     defaults: schema.defaults,
+    ...schema.identity === void 0 ? {} : { identity: schema.identity },
     ...schema.indexes === void 0 ? {} : { indexes: schema.indexes },
     ...schema.extension === void 0 ? {} : { extension: schema.extension },
     ...schema.deprecatedKinds === void 0 ? {} : { deprecatedKinds: schema.deprecatedKinds }
@@ -1694,7 +1335,7 @@ function compileEdge(kindName, document, nodeTypeByName) {
   );
 }
 function buildObjectSchema(properties) {
-  const shape = {};
+  const shape = createDataKeyedBag();
   for (const [propertyName, propertyType] of Object.entries(properties)) {
     shape[propertyName] = applyOptional(
       compileProperty(propertyType),
@@ -1873,7 +1514,7 @@ function mergeGraphExtension(graph, document) {
     );
     nodeKinds.set(node.type.kind, node.type);
   }
-  const mergedNodes = {};
+  const mergedNodes = createDataKeyedBag();
   for (const [name, registration] of Object.entries(graph.nodes)) {
     if (runtimeNodeNames.has(name)) continue;
     mergedNodes[name] = registration;
@@ -1884,7 +1525,7 @@ function mergeGraphExtension(graph, document) {
       ...node.unique.length === 0 ? {} : { unique: [...node.unique] }
     };
   }
-  const mergedEdges = {};
+  const mergedEdges = createDataKeyedBag();
   for (const [name, registration] of Object.entries(graph.edges)) {
     if (runtimeEdgeNames.has(name)) continue;
     mergedEdges[name] = registration;
@@ -1893,7 +1534,7 @@ function mergeGraphExtension(graph, document) {
     assertNoCollision(
       edge.kindName,
       "edge",
-      mergedEdges[edge.kindName] !== void 0,
+      hasOwnKey(mergedEdges, edge.kindName),
       graph.id
     );
     const from = resolveEndpoints(edge.from, nodeKinds, {
@@ -1925,7 +1566,7 @@ function mergeGraphExtension(graph, document) {
   const mergedOntology = [
     ...compileTimeOntology,
     ...compiled.ontology.map(
-      (relation) => resolveOntologyEndpoints(relation, nodeKinds)
+      (relation) => resolveOntologyEndpoints(relation, nodeKinds, mergedEdges, graph.id)
     )
   ];
   const runtimeVectorIndexes = deriveGraphExtensionVectorIndexes(compiled.nodes);
@@ -1942,8 +1583,8 @@ function mergeGraphExtension(graph, document) {
   );
   return Object.freeze({
     ...graph,
-    nodes: mergedNodes,
-    edges: mergedEdges,
+    nodes: { ...mergedNodes },
+    edges: { ...mergedEdges },
     ontology: mergedOntology,
     indexes: mergedIndexes,
     extension: validatedUnion
@@ -1951,7 +1592,7 @@ function mergeGraphExtension(graph, document) {
 }
 function deriveGraphExtensionVectorIndexes(compiledNodes) {
   if (compiledNodes.length === 0) return [];
-  const registrations = {};
+  const registrations = createDataKeyedBag();
   for (const compiled of compiledNodes) {
     registrations[compiled.type.kind] = {
       type: compiled.type,
@@ -2127,11 +1768,38 @@ function resolveEndpoints(entries, nodeKinds, context) {
     return resolved;
   });
 }
-function resolveOntologyEndpoints(relation, nodeKinds) {
+function resolveOntologyEndpoints(relation, nodeKinds, edgeKinds, graphId) {
+  if (relation.metaEdge.name === META_EDGE_INVERSE_OF || relation.metaEdge.name === META_EDGE_IMPLIES) {
+    return {
+      ...relation,
+      from: resolveOntologyEdgeEndpoint(
+        relation.metaEdge.name,
+        relation.from,
+        edgeKinds,
+        graphId
+      ),
+      to: resolveOntologyEdgeEndpoint(
+        relation.metaEdge.name,
+        relation.to,
+        edgeKinds,
+        graphId
+      )
+    };
+  }
   const from = typeof relation.from === "string" ? nodeKinds.get(relation.from) ?? relation.from : relation.from;
   const to = typeof relation.to === "string" ? nodeKinds.get(relation.to) ?? relation.to : relation.to;
   return { ...relation, from, to };
 }
+function resolveOntologyEdgeEndpoint(metaEdge, endpoint, edgeKinds, graphId) {
+  if (typeof endpoint !== "string") return endpoint;
+  if (Object.hasOwn(edgeKinds, endpoint)) return endpoint;
+  if (isExternalIri(endpoint)) return endpoint;
+  throw new GraphExtensionUnresolvedOntologyEndpointError(
+    metaEdge,
+    endpoint,
+    graphId
+  );
+}
 
 // src/graph-extension/remove.ts
 function planRemovals(graph, names) {
@@ -2181,7 +1849,7 @@ function planRemovals(graph, names) {
   const removedNodeKindsSet = new Set(removedNodeKinds);
   const explicitlyRemovedEdgeKindsSet = new Set(explicitlyRemovedEdgeKinds);
   const cascadeEdges = /* @__PURE__ */ new Set();
-  const updatedEdges = {};
+  const updatedEdges = createDataKeyedBag();
   for (const [edgeName, edgeDocument] of Object.entries(document.edges ?? {})) {
     if (explicitlyRemovedEdgeKindsSet.has(edgeName)) {
       cascadeEdges.add(edgeName);
@@ -2203,7 +1871,7 @@ function planRemovals(graph, names) {
       to: newTo
     };
   }
-  const updatedNodes = {};
+  const updatedNodes = createDataKeyedBag();
   for (const [nodeName, nodeDocument] of Object.entries(document.nodes ?? {})) {
     if (removedNodeKindsSet.has(nodeName)) continue;
     updatedNodes[nodeName] = nodeDocument;
@@ -2221,8 +1889,11 @@ function planRemovals(graph, names) {
   );
   const newDocument = Object.freeze({
     ...document.version === void 0 ? {} : { version: document.version },
-    ...Object.keys(updatedNodes).length === 0 ? {} : { nodes: updatedNodes },
-    ...Object.keys(updatedEdges).length === 0 ? {} : { edges: updatedEdges },
+    // Spread at the boundary: these land on the returned extension document,
+    // which is public as `graph.extension`. See `createDataKeyedBag` in
+    // ../utils/object.ts.
+    ...Object.keys(updatedNodes).length === 0 ? {} : { nodes: { ...updatedNodes } },
+    ...Object.keys(updatedEdges).length === 0 ? {} : { edges: { ...updatedEdges } },
     ...survivingOntology.length === 0 ? {} : { ontology: survivingOntology },
     ...survivingIndexes.length === 0 ? {} : { indexes: survivingIndexes }
   });
@@ -2242,12 +1913,12 @@ function stripGraphExtension(graph) {
   if (document === void 0) return graph;
   const { nodes: runtimeNodeNames, edges: runtimeEdgeNames } = extensionKindNames(document);
   const runtimeOntologyKeys = buildGraphExtensionOntologyKeySet(document);
-  const compileNodes = {};
+  const compileNodes = createDataKeyedBag();
   for (const [name, registration] of Object.entries(graph.nodes)) {
     if (runtimeNodeNames.has(name)) continue;
     compileNodes[name] = registration;
   }
-  const compileEdges = {};
+  const compileEdges = createDataKeyedBag();
   for (const [name, registration] of Object.entries(graph.edges)) {
     if (runtimeEdgeNames.has(name)) continue;
     compileEdges[name] = registration;
@@ -2260,8 +1931,8 @@ function stripGraphExtension(graph) {
   );
   return Object.freeze({
     ...graph,
-    nodes: compileNodes,
-    edges: compileEdges,
+    nodes: { ...compileNodes },
+    edges: { ...compileEdges },
     ontology: compileOntology,
     indexes: compileIndexes.length === 0 ? void 0 : compileIndexes,
     extension: void 0
@@ -2310,6 +1981,244 @@ function buildCompileTimeReferentIndex(graph, runtimeEdgeNames) {
   return index;
 }
 
+// src/identity/schema-transition.ts
+function identityTableNames(schema) {
+  return {
+    identityAssertions: schema.tables.identityAssertions,
+    recordedIdentityAssertions: schema.tables.recordedIdentityAssertions,
+    identityClosure: schema.tables.identityClosure,
+    identitySeparation: schema.tables.identitySeparation
+  };
+}
+var IDENTITY_SEPARATION_RELATION = "identitySeparation";
+var UPGRADEABLE_DERIVED_RELATIONS = /* @__PURE__ */ new Set([
+  IDENTITY_SEPARATION_RELATION
+]);
+var NOTHING_OWED = { provisionInCommit: [] };
+async function ensureIdentitySchemaStorage(backend, schema, options) {
+  const ensureIdentityTables = backend.ensureIdentityTables;
+  if (ensureIdentityTables === void 0) return NOTHING_OWED;
+  const tableNames = identityTableNames(schema);
+  const missingTables = await ensureIdentityTables(tableNames, {
+    provisionMissing: options.enablement
+  });
+  if (options.enablement) return NOTHING_OWED;
+  assertIdentityStoragePresent(
+    options.graphId,
+    missingTables.filter((name) => !UPGRADEABLE_DERIVED_RELATIONS.has(name))
+  );
+  const separationMissing = missingTables.includes(
+    IDENTITY_SEPARATION_RELATION
+  );
+  const rebuildRequired = await separationRebuildRequired(
+    backend,
+    schema,
+    options.graphId,
+    { relationExists: !separationMissing, registry: options.registry }
+  );
+  if (!separationMissing && !rebuildRequired) return NOTHING_OWED;
+  const recompute = options.recomputeDerivedRelations;
+  if (recompute === void 0) {
+    return provisioningForCommit(backend, tableNames, options.graphId, {
+      ensureIdentityTables,
+      separationMissing,
+      rebuildRequired
+    });
+  }
+  await provisionDerivedRelations(backend, tableNames, options.graphId, {
+    ensureIdentityTables,
+    recompute,
+    separationMissing,
+    rebuildRequired
+  });
+  return NOTHING_OWED;
+}
+async function provisioningForCommit(backend, tableNames, graphId, input) {
+  if (!input.separationMissing) return NOTHING_OWED;
+  const identityTableDdl = backend.identityTableDdl;
+  if (identityTableDdl !== void 0) {
+    return { provisionInCommit: identityTableDdl(tableNames) };
+  }
+  if (input.rebuildRequired) {
+    throw identityDerivedUpgradeUnsupportedError(graphId, ["identityTableDdl"]);
+  }
+  await input.ensureIdentityTables(tableNames, { provisionMissing: true });
+  return NOTHING_OWED;
+}
+async function provisionDerivedRelations(backend, tableNames, graphId, ports) {
+  if (!ports.separationMissing) {
+    await ports.recompute(backend);
+    return;
+  }
+  if (!ports.rebuildRequired) {
+    await ports.ensureIdentityTables(tableNames, { provisionMissing: true });
+    return;
+  }
+  const fence = backend.schemaWriteTransaction;
+  const identityTableDdl = backend.identityTableDdl;
+  if (fence === void 0 || identityTableDdl === void 0) {
+    throw identityDerivedUpgradeUnsupportedError(graphId, [
+      ...fence === void 0 ? ["schemaWriteTransaction"] : [],
+      ...identityTableDdl === void 0 ? ["identityTableDdl"] : []
+    ]);
+  }
+  await withIdentityDdlRaceRetry(
+    async () => fence(graphId, async (target) => {
+      await lockIdentityDdl(target);
+      await executeIdentityDdl(
+        (ddl) => target.executeSchemaDdl(ddl),
+        identityTableDdl(tableNames)
+      );
+      await ports.recompute(target);
+    })
+  );
+}
+var IDENTITY_DDL_RACES = /* @__PURE__ */ new WeakSet();
+function markIdentityDdlRace(error) {
+  if (typeof error === "object" && error !== null) {
+    IDENTITY_DDL_RACES.add(error);
+  }
+  return error;
+}
+function isIdentityDdlRace(error) {
+  for (const link of errorChain(error)) {
+    if (typeof link === "object" && link !== null && IDENTITY_DDL_RACES.has(link)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function executeIdentityDdl(execute, statements) {
+  for (const statement of statements) {
+    try {
+      await execute(statement);
+    } catch (error) {
+      if (isPostgresConcurrentDdlRaceError(error)) {
+        throw markIdentityDdlRace(error);
+      }
+      throw error;
+    }
+  }
+}
+async function withIdentityDdlRaceRetry(attempt) {
+  try {
+    return await attempt();
+  } catch (error) {
+    if (!isIdentityDdlRace(error)) throw error;
+    return attempt();
+  }
+}
+async function lockIdentityDdl(target) {
+  if (target.dialect !== "postgres") return;
+  await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT pg_advisory_xact_lock(hashtext(${IDENTITY_DDL_LOCK_KEY}), 0)
+    `)
+  );
+}
+var IDENTITY_DDL_LOCK_KEY = "typegraph:identity-ddl";
+function identityDerivedUpgradeUnsupportedError(graphId, missingPorts) {
+  return new ConfigurationError(
+    "This backend cannot publish an Operational Identity derived-relation upgrade atomically.",
+    {
+      code: "IDENTITY_UPGRADE_REQUIRES_ATOMIC_DDL",
+      graphId,
+      missingPorts,
+      tables: [IDENTITY_SEPARATION_RELATION]
+    },
+    {
+      suggestion: "Use a backend that implements schemaWriteTransaction and identityTableDdl (both bundled Drizzle backends do when transactions are enabled). Creating the separation relation and filling it as two steps would leave it readable and empty in between, where every pair reads as not separated. To upgrade out of band, create the relation with the standard TypeGraph DDL and run rebuildIdentityClosure(store) before serving traffic."
+    }
+  );
+}
+async function identityKindCascadeNeeded(backend, schema, graphId, droppedNodeKinds) {
+  if (droppedNodeKinds.length === 0) return false;
+  const ensureIdentityTables = backend.ensureIdentityTables;
+  if (ensureIdentityTables === void 0) return false;
+  const missingTables = await ensureIdentityTables(identityTableNames(schema), {
+    provisionMissing: false
+  });
+  if (missingTables.length > 0) return false;
+  return hasAssertionsTouchingKinds(backend, schema, graphId, droppedNodeKinds);
+}
+function assertIdentityStoragePresent(graphId, missingTables) {
+  if (missingTables.length === 0) return;
+  throw new ConfigurationError(
+    "Operational Identity storage was missing from an already enabled graph.",
+    {
+      code: "IDENTITY_STORAGE_MISSING",
+      graphId,
+      tables: missingTables
+    },
+    {
+      suggestion: "Restore missing assertion-ledger tables from backup. If only the derived relations (closure, separation) are missing, recreate them with the standard TypeGraph DDL, open the Store, and run rebuildIdentityClosure() before serving traffic."
+    }
+  );
+}
+function identitySchemaCommitPreflight(ctx, options) {
+  return async (target) => {
+    await provisionDerivedRelationsInCommit(
+      target,
+      ctx.graphId,
+      options.provisionDerivedRelations ?? []
+    );
+    await lockRecordedGraphWrite(target, ctx.graphId);
+    await lockIdentityGraph(target, ctx.graphId);
+    if (options.enablement) {
+      await lockIdentityEnablementNodes(target, ctx.schema);
+      await withRecordedIdentityMutationTarget(
+        target,
+        (rawTarget, touch) => purgeAssertionsWithUnregisteredKinds(
+          rawTarget,
+          ctx.schema,
+          ctx.graphId,
+          new Set(ctx.registry.nodeKinds.keys()),
+          touch
+        )
+      );
+    }
+    const droppedNodeKinds = options.droppedNodeKinds ?? [];
+    if (droppedNodeKinds.length > 0) {
+      await withRecordedIdentityMutationTarget(
+        target,
+        (rawTarget, touch) => deleteAssertionsTouchingKinds(
+          rawTarget,
+          ctx.schema,
+          ctx.graphId,
+          droppedNodeKinds,
+          touch
+        )
+      );
+    }
+    await rebuildIdentityClosureForContext({ ...ctx, backend: target });
+  };
+}
+async function provisionDerivedRelationsInCommit(target, graphId, ddl) {
+  if (ddl.length === 0) return;
+  const executeSchemaDdl = target.executeSchemaDdl;
+  if (executeSchemaDdl === void 0) {
+    throw identityDerivedUpgradeUnsupportedError(graphId, ["executeSchemaDdl"]);
+  }
+  await lockIdentityDdl(target);
+  await executeIdentityDdl((statement) => executeSchemaDdl(statement), ddl);
+}
+function identityKindCascadePreflight(ctx, droppedNodeKinds) {
+  return async (target) => {
+    await lockRecordedGraphWrite(target, ctx.graphId);
+    await lockIdentityGraph(target, ctx.graphId);
+    await withRecordedIdentityMutationTarget(
+      target,
+      (rawTarget, touch) => deleteAssertionsTouchingKinds(
+        rawTarget,
+        ctx.schema,
+        ctx.graphId,
+        droppedNodeKinds,
+        touch
+      )
+    );
+  };
+}
+
 // src/registry/validate-implies.ts
 function validateImpliesEndpointCompatibility(edgeEndpoints, registry) {
   for (const [impliedEdgeKind, impliedEndpoints] of edgeEndpoints) {
@@ -2359,17 +2268,132 @@ function assertEndpointCompatible(side, implyingEdgeKind, implyingKinds, implied
   );
 }
 
+// src/registry/validate-inverse.ts
+function validateInverseEndpointCompatibility(ontology, edgeEndpoints, registry) {
+  for (const relation of ontology) {
+    if (relation.metaEdge !== META_EDGE_INVERSE_OF) continue;
+    const left = edgeEndpoints.get(relation.from);
+    const right = edgeEndpoints.get(relation.to);
+    if (left === void 0 || right === void 0) continue;
+    assertInverseSideCompatible(
+      relation.from,
+      "from",
+      left.from,
+      relation.to,
+      "to",
+      right.to,
+      registry
+    );
+    assertInverseSideCompatible(
+      relation.from,
+      "to",
+      left.to,
+      relation.to,
+      "from",
+      right.from,
+      registry
+    );
+    if (relation.from === relation.to) continue;
+    assertInverseSideCompatible(
+      relation.to,
+      "from",
+      right.from,
+      relation.from,
+      "to",
+      left.to,
+      registry
+    );
+    assertInverseSideCompatible(
+      relation.to,
+      "to",
+      right.to,
+      relation.from,
+      "from",
+      left.from,
+      registry
+    );
+  }
+}
+function assertInverseSideCompatible(sourceEdge, sourceSide, sourceKinds, inverseEdge, inverseSide, inverseKinds, registry) {
+  const incompatibleKinds = sourceKinds.filter(
+    (kind) => !registry.isAssignableToAny(kind, inverseKinds)
+  );
+  if (incompatibleKinds.length === 0) return;
+  throw new ConfigurationError(
+    `inverseOf("${sourceEdge}", "${inverseEdge}") is endpoint-incompatible: ${sourceSide} kind(s) [${incompatibleKinds.join(", ")}] declared on "${sourceEdge}" cannot be assigned to any of "${inverseEdge}"'s ${inverseSide} kind(s) [${inverseKinds.join(", ")}].`,
+    {
+      metaEdge: META_EDGE_INVERSE_OF,
+      sourceEdge,
+      inverseEdge,
+      sourceEndpoint: sourceSide,
+      inverseEndpoint: inverseSide,
+      incompatibleKinds,
+      allowedKinds: inverseKinds
+    },
+    {
+      suggestion: "Make the inverse edge declarations exact reversals (allowing subClassOf assignability), or remove the inverseOf relation."
+    }
+  );
+}
+
+// src/registry/build-validated.ts
+function buildValidatedKindRegistry(input) {
+  if (input.ontology.length === 0) {
+    const registry2 = new KindRegistry(
+      input.nodeKinds,
+      input.edgeKinds,
+      createEmptyClosures(),
+      input.identity
+    );
+    validateImpliesEndpointCompatibility(input.edgeEndpoints, registry2);
+    return registry2;
+  }
+  const issues = validateOntologyRelations(input.ontology);
+  if (issues.length > 0) {
+    const firstIssue = requireDefined(issues[0]);
+    throw new ConfigurationError(
+      `Ontology is incoherent: ${firstIssue.message}`,
+      {
+        code: firstIssue.code,
+        issues
+      },
+      {
+        suggestion: "Correct the ontology relations before constructing or loading the graph registry."
+      }
+    );
+  }
+  const closures = computeClosuresFromNamedOntology(input.ontology);
+  const registry = new KindRegistry(
+    input.nodeKinds,
+    input.edgeKinds,
+    closures,
+    input.identity
+  );
+  validateImpliesEndpointCompatibility(input.edgeEndpoints, registry);
+  validateInverseEndpointCompatibility(
+    input.ontology,
+    input.edgeEndpoints,
+    registry
+  );
+  return registry;
+}
+
 // src/registry/builders.ts
+var EMPTY_NAMED_ONTOLOGY = [];
 function buildKindRegistry(graph) {
   const nodeTypes = extractNodeTypes(graph);
   const edgeTypes = extractEdgeTypes(graph);
-  const closures = graph.ontology.length > 0 ? computeClosuresFromOntology(graph.ontology) : createEmptyClosures();
-  const registry = new KindRegistry(nodeTypes, edgeTypes, closures);
-  validateImpliesEndpointCompatibility(
-    buildEdgeEndpointKinds(graph.edges),
-    registry
-  );
-  return registry;
+  return buildValidatedKindRegistry({
+    nodeKinds: nodeTypes,
+    edgeKinds: edgeTypes,
+    ontology: graph.ontology.length === 0 ? EMPTY_NAMED_ONTOLOGY : graph.ontology.map((relation) => ({
+      metaEdge: relation.metaEdge.name,
+      from: typeof relation.from === "string" ? relation.from : relation.from.kind,
+      to: typeof relation.to === "string" ? relation.to : relation.to.kind
+    })),
+    edgeEndpoints: buildEdgeEndpointKinds(graph.edges),
+    ...graph.identity === void 0 ? {} : { identity: graph.identity }
+  });
 }
 function buildEdgeEndpointKinds(edges) {
   const result = /* @__PURE__ */ new Map();
@@ -2695,6 +2719,7 @@ var serializedSchemaZod = z.object({
     onNodeDelete: deleteBehaviorZod,
     temporalMode: temporalModeZod
   }).loose(),
+  identity: z.object({ sameIdAcrossKinds: z.enum(["fold", "ignore"]) }).readonly().optional(),
   /**
    * Index declarations attached to the graph.
    *
@@ -2810,7 +2835,9 @@ async function ensureSchema(backend, graph, options) {
   const preloaded = options?.preloaded;
   const activeSchema = preloaded === void 0 ? await loadActiveSchemaWithBootstrap(backend, graph.id) : preloaded.activeRow;
   if (activeSchema === void 0) {
-    const result = await initializeSchema(backend, graph);
+    const result = await initializeSchema(backend, graph, {
+      ...options?.schema === void 0 ? {} : { schema: options.schema }
+    });
     return {
       status: "initialized",
       version: result.version,
@@ -2837,10 +2864,15 @@ async function ensureSchema(backend, graph, options) {
         diff
       };
       await options?.onBeforeMigrate?.(hookContext);
-      const committedRow = await commitNewSchemaVersion(
+      const preflight = graph.identity === void 0 ? void 0 : await prepareIdentitySchemaCommit(backend, graph, {
+        enablement: storedSchema.identity === void 0,
+        ...options?.schema === void 0 ? {} : { schema: options.schema }
+      });
+      const committedRow = preflight === void 0 ? await commitNewSchemaVersion(backend, graph, activeSchema.version) : await commitNewSchemaVersionWithPreflight(
         backend,
         graph,
-        activeSchema.version
+        activeSchema.version,
+        preflight
       );
       await options?.onAfterMigrate?.(hookContext);
       return {
@@ -2955,17 +2987,39 @@ function schemaNotInitializedError(graphId, cause) {
     }
   );
 }
-async function initializeSchema(backend, graph) {
+function requireCommitWithPreflight(backend, graph) {
+  const commitWithPreflight = backend.commitSchemaVersionWithPreflight;
+  if (commitWithPreflight === void 0) {
+    throw new ConfigurationError(
+      "This backend cannot atomically commit identity data with a schema transition.",
+      {
+        code: "IDENTITY_REQUIRES_ATOMIC_BACKEND",
+        graphId: graph.id
+      }
+    );
+  }
+  return commitWithPreflight;
+}
+async function initializeSchema(backend, graph, options) {
   buildKindRegistry(graph);
   const schema = serializeSchema(graph, 1);
   const hash = await computeSchemaHash(schema);
-  return backend.commitSchemaVersion({
+  const commit = {
     graphId: graph.id,
     expected: { kind: "initial" },
     version: 1,
     schemaHash: hash,
     schemaDoc: schema
+  };
+  if (graph.identity === void 0) {
+    return backend.commitSchemaVersion(commit);
+  }
+  const preflight = await prepareIdentitySchemaCommit(backend, graph, {
+    enablement: true,
+    ...options?.schema === void 0 ? {} : { schema: options.schema }
   });
+  const commitWithPreflight = requireCommitWithPreflight(backend, graph);
+  return withIdentityDdlRaceRetry(() => commitWithPreflight(commit, preflight));
 }
 async function migrateSchema(backend, graph, currentVersion, options) {
   const {
@@ -2984,14 +3038,96 @@ async function migrateSchema(backend, graph, currentVersion, options) {
     ...droppedKinds(storedSchema.nodes, getNodeKinds(target), "node"),
     ...droppedKinds(storedSchema.edges, getEdgeKinds(target), "edge")
   ];
-  const committed = dropped.length > 0 && options?.discardDroppedKindRows !== true ? await commitDroppedKindsOnlyWhenEmpty(
+  const guardedDrops = options?.discardDroppedKindRows === true ? [] : dropped;
+  const droppedNodeKinds = dropped.filter((drop) => drop.entity === "node").map((drop) => drop.kind);
+  const identityPreflight = activeRow === void 0 ? void 0 : target.identity === void 0 ? (
+    // Identity being OFF in the target is not evidence the ledger is empty:
+    // disabling retains the assertion rows. A drop committed here would
+    // strand every assertion touching the kind — a later re-enablement
+    // filters them out of the closure while raw ledger reads and merge
+    // staging still see them.
+    await prepareIdentityKindCascade(backend, target, {
+      droppedNodeKinds,
+      probeBeforeCascade: storedSchema?.identity === void 0,
+      ...options?.schema === void 0 ? {} : { schema: options.schema }
+    })
+  ) : await prepareIdentitySchemaCommit(backend, target, {
+    enablement: storedSchema?.identity === void 0,
+    droppedNodeKinds,
+    ...options?.schema === void 0 ? {} : { schema: options.schema }
+  });
+  const committed = identityPreflight === void 0 ? guardedDrops.length > 0 ? await commitDroppedKindsOnlyWhenEmpty(
     backend,
     target,
     currentVersion,
-    dropped
-  ) : await commitNewSchemaVersion(backend, target, currentVersion);
+    guardedDrops
+  ) : await commitNewSchemaVersion(backend, target, currentVersion) : await commitNewSchemaVersionWithPreflight(
+    backend,
+    target,
+    currentVersion,
+    async (transactionBackend) => {
+      await assertDroppedKindsEmpty(
+        transactionBackend,
+        target.id,
+        currentVersion,
+        guardedDrops
+      );
+      await identityPreflight(transactionBackend);
+    }
+  );
   return committed.version;
 }
+async function prepareIdentityKindCascade(backend, target, options) {
+  if (options.droppedNodeKinds.length === 0) return void 0;
+  const schema = options.schema === void 0 ? createSqlSchema(backend.tableNames) : requireSqlSchema(options.schema, "The schema option");
+  if (options.probeBeforeCascade) {
+    const needed = await identityKindCascadeNeeded(
+      backend,
+      schema,
+      target.id,
+      options.droppedNodeKinds
+    );
+    if (!needed) return void 0;
+  }
+  return identityKindCascadePreflight(
+    { graphId: target.id, schema },
+    options.droppedNodeKinds
+  );
+}
+async function prepareIdentitySchemaCommit(backend, target, options) {
+  const schema = options.schema === void 0 ? createSqlSchema(backend.tableNames) : requireSqlSchema(options.schema, "The schema option");
+  const registry = buildKindRegistry(target);
+  const provisioning = await ensureIdentitySchemaStorage(backend, schema, {
+    graphId: target.id,
+    enablement: options.enablement,
+    registry
+  });
+  return identitySchemaCommitPreflight(
+    {
+      graphId: target.id,
+      registry,
+      schema,
+      sameIdAcrossKinds: target.identity?.sameIdAcrossKinds ?? "ignore"
+    },
+    {
+      enablement: options.enablement,
+      droppedNodeKinds: options.droppedNodeKinds ?? [],
+      provisionDerivedRelations: provisioning.provisionInCommit
+    }
+  );
+}
+async function assertDroppedKindsEmpty(backend, graphId, currentVersion, dropped) {
+  const counts = await Promise.all(
+    dropped.map(async (entry) => ({
+      entity: entry.entity,
+      kind: entry.kind,
+      count: entry.entity === "node" ? await backend.countNodesByKind({ graphId, kind: entry.kind }) : await backend.countEdgesByKind({ graphId, kind: entry.kind })
+    }))
+  );
+  const populated = counts.filter((entry) => entry.count > 0);
+  if (populated.length === 0) return;
+  throwPopulatedKindRemovalError(graphId, currentVersion, populated);
+}
 async function commitDroppedKindsOnlyWhenEmpty(backend, graph, currentVersion, dropped) {
   const result = await commitNewSchemaVersionIfKindsEmpty(
     backend,
@@ -3053,6 +3189,14 @@ async function buildNewSchemaVersionCommit(graph, currentVersion) {
     schemaDoc: schema
   };
 }
+async function commitNewSchemaVersionWithPreflight(backend, graph, currentVersion, preflight) {
+  if (backend.commitSchemaVersionWithPreflight === void 0) {
+    buildKindRegistry(graph);
+  }
+  const commitWithPreflight = requireCommitWithPreflight(backend, graph);
+  const commit = await buildNewSchemaVersionCommit(graph, currentVersion);
+  return withIdentityDdlRaceRetry(() => commitWithPreflight(commit, preflight));
+}
 async function rollbackSchema(backend, graphId, targetVersion) {
   const activeRow = await backend.getActiveSchema(graphId);
   if (activeRow === void 0) {
@@ -3101,6 +3245,6 @@ async function getCommittedSchemaVersion(backend, graphId) {
   return row?.version;
 }
 
-export { KindRegistry, applyDeprecatedKinds, assertSchemaCurrent, broader, buildGraphExtensionOntologyKeySet, buildKindRegistry, classifySchemaChanges, commitNewSchemaVersion, commitNewSchemaVersionIfKindsEmpty, compileTimeOntologyKey, computeSchemaDiff, computeSchemaHash, core, deserializeWherePredicate, differentFrom, disjointWith, ensureSchema, equivalentTo, extensionKindNames, getActiveSchema, getCommittedSchemaVersion, getMigrationActions, getSchemaChanges, hasPart, implies, initializeSchema, inverseOf, isBackwardsCompatible, isSchemaInitialized, loadActiveSchemaWithBootstrap, loadAndMergeGraphExtensionDocument, loadAndVerifyGraph, mergeGraphExtension, migrateSchema, narrower, parseSerializedSchema, partOf, planRemovals, relatedTo, requiresMigration, rollbackSchema, sameAs, serializeIndexDeclaration, serializeSchema, serializeSchemaProperties, stripGraphExtension, subClassOf, validateImpliesEndpointCompatibility };
-//# sourceMappingURL=chunk-FQ7ZPOTZ.js.map
-//# sourceMappingURL=chunk-FQ7ZPOTZ.js.map
+export { applyDeprecatedKinds, assertSchemaCurrent, broader, buildGraphExtensionOntologyKeySet, buildKindRegistry, buildValidatedKindRegistry, classifySchemaChanges, commitNewSchemaVersion, commitNewSchemaVersionIfKindsEmpty, commitNewSchemaVersionWithPreflight, compileTimeOntologyKey, computeSchemaDiff, computeSchemaHash, core, deserializeWherePredicate, differentFrom, disjointWith, ensureIdentitySchemaStorage, ensureSchema, equivalentTo, extensionKindNames, getActiveSchema, getCommittedSchemaVersion, getMigrationActions, getSchemaChanges, hasPart, identityKindCascadeNeeded, identitySchemaCommitPreflight, implies, initializeSchema, inverseOf, isBackwardsCompatible, isSchemaInitialized, loadActiveSchemaWithBootstrap, loadAndMergeGraphExtensionDocument, loadAndVerifyGraph, mergeGraphExtension, migrateSchema, narrower, parseSerializedSchema, partOf, planRemovals, relatedTo, requiresMigration, rollbackSchema, sameAs, serializeIndexDeclaration, serializeSchema, serializeSchemaProperties, stripGraphExtension, subClassOf };
+//# sourceMappingURL=chunk-LGHCOKTT.js.map
+//# sourceMappingURL=chunk-LGHCOKTT.js.map