@nicia-ai/typegraph 0.24.1 → 0.25.1

package/dist/chunk-AAA2CR3P.js

@@ -0,0 +1,2628 @@
+import { NODE_TYPE_BRAND, EDGE_TYPE_BRAND, nowIso, getNodeKinds, getEdgeKinds, autoDeriveVectorIndexes, mergeVectorIndexes } from './chunk-EG6TJ3I5.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, assertJsonValue, isReachable, computeTransitiveClosure, invertClosure, LEGACY_GRAPH_EXTENSION_VERSION, unwrap, validateGraphExtension, compactUndefined, KindCollisionError, GraphExtensionUnresolvedEndpointError, freezeDeep, assertSchemaKeysAreFree, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS } from './chunk-4BOWVUGQ.js';
+import { sha256Hex, defineNodeIndex, defineEdgeIndex } from './chunk-EJCDOA37.js';
+import { searchable } from './chunk-OOS2RKRH.js';
+import { embedding } from './chunk-WVQXAFP3.js';
+import { ConfigurationError, KindNotFoundError, DatabaseOperationError, MigrationError, ValidationError } from './chunk-DOTEN2FG.js';
+import { z } from 'zod';
+
+// src/core/node.ts
+function validateSchemaKeys(schema, name) {
+  assertSchemaKeysAreFree(
+    "Node",
+    name,
+    Object.keys(schema.shape),
+    RESERVED_NODE_KEYS
+  );
+}
+function defineNode(name, options) {
+  validateSchemaKeys(options.schema, name);
+  if (options.annotations !== void 0) {
+    assertJsonValue(options.annotations, "annotations", `Node "${name}"`);
+  }
+  return Object.freeze({
+    [NODE_TYPE_BRAND]: true,
+    kind: name,
+    schema: options.schema,
+    description: options.description,
+    annotations: options.annotations
+  });
+}
+var EMPTY_SCHEMA = z.object({});
+function validateSchemaKeys2(schema, name) {
+  assertSchemaKeysAreFree(
+    "Edge",
+    name,
+    Object.keys(schema.shape),
+    RESERVED_EDGE_KEYS
+  );
+}
+function defineEdge(name, options) {
+  const schema = options?.schema ?? EMPTY_SCHEMA;
+  validateSchemaKeys2(schema, name);
+  if (options?.annotations !== void 0) {
+    assertJsonValue(options.annotations, "annotations", `Edge "${name}"`);
+  }
+  return Object.freeze({
+    [EDGE_TYPE_BRAND]: true,
+    kind: name,
+    schema,
+    description: options?.description,
+    annotations: options?.annotations,
+    from: options?.from,
+    to: options?.to
+  });
+}
+
+// src/ontology/types.ts
+var META_EDGE_BRAND = "__metaEdge";
+function isMetaEdge(value) {
+  return typeof value === "object" && value !== null && META_EDGE_BRAND in value && value[META_EDGE_BRAND] === true;
+}
+function getTypeName(typeOrIri) {
+  if (typeof typeOrIri === "string") {
+    return typeOrIri;
+  }
+  return typeOrIri.kind;
+}
+
+// src/ontology/core-meta-edges.ts
+function createMetaEdge(name, properties) {
+  return Object.freeze({
+    [META_EDGE_BRAND]: true,
+    name,
+    properties: {
+      transitive: properties.transitive ?? false,
+      symmetric: properties.symmetric ?? false,
+      reflexive: properties.reflexive ?? false,
+      inverse: properties.inverse,
+      inference: properties.inference,
+      description: properties.description
+    }
+  });
+}
+var subClassOfMetaEdge = createMetaEdge(META_EDGE_SUB_CLASS_OF, {
+  transitive: true,
+  inference: "subsumption",
+  description: "Type inheritance (Podcast subClassOf Media)"
+});
+function subClassOf(child, parent) {
+  return {
+    metaEdge: subClassOfMetaEdge,
+    from: child,
+    to: parent
+  };
+}
+var broaderMetaEdge = createMetaEdge(META_EDGE_BROADER, {
+  transitive: true,
+  inverse: META_EDGE_NARROWER,
+  inference: "hierarchy",
+  description: "Broader concept (ML broader AI)"
+});
+function broader(narrowerConcept, broaderConcept) {
+  return {
+    metaEdge: broaderMetaEdge,
+    from: narrowerConcept,
+    to: broaderConcept
+  };
+}
+var narrowerMetaEdge = createMetaEdge(META_EDGE_NARROWER, {
+  transitive: true,
+  inverse: META_EDGE_BROADER,
+  inference: "hierarchy",
+  description: "Narrower concept (AI narrower ML)"
+});
+function narrower(broaderConcept, narrowerConcept) {
+  return {
+    metaEdge: narrowerMetaEdge,
+    from: broaderConcept,
+    to: narrowerConcept
+  };
+}
+var relatedToMetaEdge = createMetaEdge(META_EDGE_RELATED_TO, {
+  symmetric: true,
+  inference: "association",
+  description: "Non-hierarchical association"
+});
+function relatedTo(conceptA, conceptB) {
+  return {
+    metaEdge: relatedToMetaEdge,
+    from: conceptA,
+    to: conceptB
+  };
+}
+var equivalentToMetaEdge = createMetaEdge(META_EDGE_EQUIVALENT_TO, {
+  symmetric: true,
+  transitive: true,
+  inference: "substitution",
+  description: "Same class, different representation"
+});
+function equivalentTo(kindA, kindBOrIri) {
+  return {
+    metaEdge: equivalentToMetaEdge,
+    from: kindA,
+    to: kindBOrIri
+  };
+}
+var sameAsMetaEdge = createMetaEdge(META_EDGE_SAME_AS, {
+  symmetric: true,
+  transitive: true,
+  inference: "substitution",
+  description: "Same individual (for deduplication)"
+});
+function sameAs(kindA, kindBOrIri) {
+  return {
+    metaEdge: sameAsMetaEdge,
+    from: kindA,
+    to: kindBOrIri
+  };
+}
+var differentFromMetaEdge = createMetaEdge(META_EDGE_DIFFERENT_FROM, {
+  symmetric: true,
+  inference: "constraint",
+  description: "Explicitly different individuals"
+});
+function differentFrom(kindA, kindB) {
+  return {
+    metaEdge: differentFromMetaEdge,
+    from: kindA,
+    to: kindB
+  };
+}
+var disjointWithMetaEdge = createMetaEdge(META_EDGE_DISJOINT_WITH, {
+  symmetric: true,
+  inference: "constraint",
+  description: "Mutually exclusive types"
+});
+function disjointWith(kindA, kindB) {
+  return {
+    metaEdge: disjointWithMetaEdge,
+    from: kindA,
+    to: kindB
+  };
+}
+var partOfMetaEdge = createMetaEdge(META_EDGE_PART_OF, {
+  transitive: true,
+  inverse: META_EDGE_HAS_PART,
+  inference: "composition",
+  description: "X is part of Y"
+});
+function partOf(part, whole) {
+  return {
+    metaEdge: partOfMetaEdge,
+    from: part,
+    to: whole
+  };
+}
+var hasPartMetaEdge = createMetaEdge(META_EDGE_HAS_PART, {
+  transitive: true,
+  inverse: META_EDGE_PART_OF,
+  inference: "composition",
+  description: "Y has part X"
+});
+function hasPart(whole, part) {
+  return {
+    metaEdge: hasPartMetaEdge,
+    from: whole,
+    to: part
+  };
+}
+var inverseOfMetaEdge = createMetaEdge(META_EDGE_INVERSE_OF, {
+  symmetric: true,
+  inference: "none",
+  description: "Edge A is inverse of edge B"
+});
+var impliesMetaEdge = createMetaEdge(META_EDGE_IMPLIES, {
+  transitive: true,
+  inference: "none",
+  description: "Edge A implies edge B exists"
+});
+function inverseOf(edgeA, edgeB) {
+  return {
+    metaEdge: inverseOfMetaEdge,
+    from: edgeA,
+    to: edgeB
+  };
+}
+function implies(edgeA, edgeB) {
+  return {
+    metaEdge: impliesMetaEdge,
+    from: edgeA,
+    to: edgeB
+  };
+}
+var core = {
+  // Meta-edges
+  subClassOfMetaEdge,
+  broaderMetaEdge,
+  narrowerMetaEdge,
+  relatedToMetaEdge,
+  equivalentToMetaEdge,
+  sameAsMetaEdge,
+  differentFromMetaEdge,
+  disjointWithMetaEdge,
+  partOfMetaEdge,
+  hasPartMetaEdge,
+  inverseOfMetaEdge,
+  impliesMetaEdge,
+  // Relation factories
+  subClassOf,
+  broader,
+  narrower,
+  relatedTo,
+  equivalentTo,
+  sameAs,
+  differentFrom,
+  disjointWith,
+  partOf,
+  hasPart,
+  inverseOf,
+  implies
+};
+
+// src/schema/canonical.ts
+function sortedReplacer(_key, value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const sorted = {};
+    for (const key of Object.keys(value).toSorted()) {
+      sorted[key] = value[key];
+    }
+    return sorted;
+  }
+  return value;
+}
+function canonicalEqual(a, b) {
+  return JSON.stringify(a, sortedReplacer) === JSON.stringify(b, sortedReplacer);
+}
+
+// src/schema/migration.ts
+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 indexChanges = diffIndexes(before.indexes, after.indexes);
+  const extensionChange = diffExtension(before.extension, after.extension);
+  const deprecatedKindsChange = diffDeprecatedKinds(
+    before.deprecatedKinds,
+    after.deprecatedKinds
+  );
+  const allChanges = [
+    ...nodeChanges,
+    ...edgeChanges,
+    ...ontologyChanges,
+    ...indexChanges
+  ];
+  const hasBreakingChanges = allChanges.some(
+    (change) => change.severity === "breaking"
+  );
+  const hasChanges = allChanges.length > 0 || extensionChange !== void 0 || deprecatedKindsChange !== void 0;
+  const summary = generateSummary(
+    nodeChanges,
+    edgeChanges,
+    ontologyChanges,
+    indexChanges,
+    extensionChange,
+    deprecatedKindsChange
+  );
+  return {
+    fromVersion: before.version,
+    toVersion: after.version,
+    nodes: nodeChanges,
+    edges: edgeChanges,
+    ontology: ontologyChanges,
+    indexes: indexChanges,
+    ...extensionChange === void 0 ? {} : { extension: extensionChange },
+    ...deprecatedKindsChange === void 0 ? {} : { deprecatedKinds: deprecatedKindsChange },
+    hasBreakingChanges,
+    isBackwardsCompatible: !hasBreakingChanges,
+    hasChanges,
+    summary
+  };
+}
+function diffNodes(before, after) {
+  const changes = [];
+  const beforeNames = new Set(Object.keys(before));
+  const afterNames = new Set(Object.keys(after));
+  for (const name of beforeNames) {
+    if (!afterNames.has(name)) {
+      changes.push({
+        type: "removed",
+        kind: name,
+        severity: "breaking",
+        details: `Node kind "${name}" was removed`,
+        before: before[name]
+      });
+    }
+  }
+  for (const name of afterNames) {
+    if (!beforeNames.has(name)) {
+      changes.push({
+        type: "added",
+        kind: name,
+        severity: "safe",
+        details: `Node kind "${name}" was added`,
+        after: after[name]
+      });
+    }
+  }
+  for (const name of beforeNames) {
+    if (afterNames.has(name)) {
+      const nodeBefore = before[name];
+      const nodeAfter = after[name];
+      const nodeChanges = diffNodeDef(name, nodeBefore, nodeAfter);
+      changes.push(...nodeChanges);
+    }
+  }
+  return changes;
+}
+function diffNodeDef(name, before, after) {
+  const changes = [];
+  if (!canonicalEqual(before.properties, after.properties)) {
+    const beforeProps = before.properties.properties ?? {};
+    const afterProps = after.properties.properties ?? {};
+    const beforeRequired = new Set(before.properties.required);
+    const afterRequired = new Set(after.properties.required);
+    const addedProps = Object.keys(afterProps).filter(
+      (p) => !(p in beforeProps)
+    );
+    const removedProps = Object.keys(beforeProps).filter(
+      (p) => !(p in afterProps)
+    );
+    const newRequired = [...afterRequired].filter(
+      (p) => !beforeRequired.has(p)
+    );
+    const { severity, details } = computePropertyChangeSeverity(
+      name,
+      removedProps,
+      addedProps,
+      newRequired
+    );
+    changes.push({
+      type: "modified",
+      kind: name,
+      severity,
+      details,
+      before,
+      after
+    });
+  }
+  if (before.onDelete !== after.onDelete) {
+    changes.push({
+      type: "modified",
+      kind: name,
+      severity: "warning",
+      details: `onDelete changed from "${before.onDelete}" to "${after.onDelete}" for "${name}"`,
+      before,
+      after
+    });
+  }
+  if (!canonicalEqual(before.uniqueConstraints, after.uniqueConstraints)) {
+    changes.push({
+      type: "modified",
+      kind: name,
+      severity: "warning",
+      details: `Unique constraints changed for "${name}"`,
+      before,
+      after
+    });
+  }
+  if (annotationsChanged(before.annotations, after.annotations)) {
+    changes.push({
+      type: "modified",
+      kind: name,
+      severity: "safe",
+      details: `Annotations changed for "${name}"`,
+      before,
+      after
+    });
+  }
+  return changes;
+}
+function computePropertyChangeSeverity(name, removedProps, addedProps, newRequired) {
+  if (removedProps.length > 0) {
+    return {
+      severity: "breaking",
+      details: `Properties removed from "${name}": ${removedProps.join(", ")}`
+    };
+  }
+  if (newRequired.length > 0) {
+    return {
+      severity: "breaking",
+      details: `New required properties in "${name}": ${newRequired.join(", ")}`
+    };
+  }
+  if (addedProps.length > 0) {
+    return {
+      severity: "safe",
+      details: `Properties added to "${name}": ${addedProps.join(", ")}`
+    };
+  }
+  return {
+    severity: "safe",
+    details: `Properties changed in "${name}"`
+  };
+}
+function diffEdges(before, after) {
+  const changes = [];
+  const beforeNames = new Set(Object.keys(before));
+  const afterNames = new Set(Object.keys(after));
+  for (const name of beforeNames) {
+    if (!afterNames.has(name)) {
+      changes.push({
+        type: "removed",
+        kind: name,
+        severity: "breaking",
+        details: `Edge kind "${name}" was removed`,
+        before: before[name]
+      });
+    }
+  }
+  for (const name of afterNames) {
+    if (!beforeNames.has(name)) {
+      changes.push({
+        type: "added",
+        kind: name,
+        severity: "safe",
+        details: `Edge kind "${name}" was added`,
+        after: after[name]
+      });
+    }
+  }
+  for (const name of beforeNames) {
+    if (afterNames.has(name)) {
+      const edgeBefore = before[name];
+      const edgeAfter = after[name];
+      const edgeChanges = diffEdgeDef(name, edgeBefore, edgeAfter);
+      changes.push(...edgeChanges);
+    }
+  }
+  return changes;
+}
+function diffEdgeDef(name, before, after) {
+  const changes = [];
+  if (!canonicalEqual(before.fromKinds, after.fromKinds)) {
+    changes.push({
+      type: "modified",
+      kind: name,
+      severity: "warning",
+      details: `fromKinds changed for "${name}"`,
+      before,
+      after
+    });
+  }
+  if (!canonicalEqual(before.toKinds, after.toKinds)) {
+    changes.push({
+      type: "modified",
+      kind: name,
+      severity: "warning",
+      details: `toKinds changed for "${name}"`,
+      before,
+      after
+    });
+  }
+  if (before.cardinality !== after.cardinality) {
+    changes.push({
+      type: "modified",
+      kind: name,
+      severity: "warning",
+      details: `Cardinality changed from "${before.cardinality}" to "${after.cardinality}" for "${name}"`,
+      before,
+      after
+    });
+  }
+  if (!canonicalEqual(before.properties, after.properties)) {
+    changes.push({
+      type: "modified",
+      kind: name,
+      severity: "safe",
+      details: `Properties changed for "${name}"`,
+      before,
+      after
+    });
+  }
+  if (annotationsChanged(before.annotations, after.annotations)) {
+    changes.push({
+      type: "modified",
+      kind: name,
+      severity: "safe",
+      details: `Annotations changed for "${name}"`,
+      before,
+      after
+    });
+  }
+  return changes;
+}
+function annotationsChanged(before, after) {
+  if (before === void 0 && after === void 0) return false;
+  if (before === void 0 || after === void 0) return true;
+  return !canonicalEqual(before, after);
+}
+function diffOntology(before, after) {
+  const changes = [];
+  const metaEdgesBefore = new Set(Object.keys(before.metaEdges));
+  const metaEdgesAfter = new Set(Object.keys(after.metaEdges));
+  for (const name of metaEdgesBefore) {
+    if (!metaEdgesAfter.has(name)) {
+      changes.push({
+        type: "removed",
+        entity: "metaEdge",
+        name,
+        severity: "breaking",
+        details: `Meta-edge "${name}" was removed`
+      });
+    }
+  }
+  for (const name of metaEdgesAfter) {
+    if (!metaEdgesBefore.has(name)) {
+      changes.push({
+        type: "added",
+        entity: "metaEdge",
+        name,
+        severity: "safe",
+        details: `Meta-edge "${name}" was added`
+      });
+    }
+  }
+  const relationsBefore = new Set(
+    before.relations.map((r) => `${r.metaEdge}:${r.from}:${r.to}`)
+  );
+  const relationsAfter = new Set(
+    after.relations.map((r) => `${r.metaEdge}:${r.from}:${r.to}`)
+  );
+  for (const relationKey of relationsBefore) {
+    if (!relationsAfter.has(relationKey)) {
+      const [metaEdge, from, to] = relationKey.split(":");
+      changes.push({
+        type: "removed",
+        entity: "relation",
+        name: relationKey,
+        severity: "warning",
+        details: `Relation ${metaEdge}(${from}, ${to}) was removed`
+      });
+    }
+  }
+  for (const relationKey of relationsAfter) {
+    if (!relationsBefore.has(relationKey)) {
+      const [metaEdge, from, to] = relationKey.split(":");
+      changes.push({
+        type: "added",
+        entity: "relation",
+        name: relationKey,
+        severity: "safe",
+        details: `Relation ${metaEdge}(${from}, ${to}) was added`
+      });
+    }
+  }
+  return changes;
+}
+function diffIndexes(before, after) {
+  const beforeIndexes = before ?? [];
+  const afterIndexes = after ?? [];
+  const beforeByName = /* @__PURE__ */ new Map();
+  for (const index of beforeIndexes) {
+    beforeByName.set(index.name, index);
+  }
+  const afterByName = /* @__PURE__ */ new Map();
+  for (const index of afterIndexes) {
+    afterByName.set(index.name, index);
+  }
+  const changes = [];
+  for (const [name, index] of beforeByName) {
+    if (!afterByName.has(name)) {
+      changes.push({
+        type: "removed",
+        name,
+        entity: index.entity,
+        severity: "safe",
+        details: `Index "${name}" was removed`,
+        before: index
+      });
+    }
+  }
+  for (const [name, index] of afterByName) {
+    if (!beforeByName.has(name)) {
+      changes.push({
+        type: "added",
+        name,
+        entity: index.entity,
+        severity: "safe",
+        details: `Index "${name}" was added`,
+        after: index
+      });
+    }
+  }
+  for (const [name, beforeIndex] of beforeByName) {
+    const afterIndex = afterByName.get(name);
+    if (!afterIndex) continue;
+    if (!canonicalEqual(beforeIndex, afterIndex)) {
+      changes.push({
+        type: "modified",
+        name,
+        entity: beforeIndex.entity,
+        severity: "safe",
+        details: `Index "${name}" was modified`,
+        before: beforeIndex,
+        after: afterIndex
+      });
+    }
+  }
+  return changes;
+}
+function diffExtension(before, after) {
+  if (before === after) return void 0;
+  if (before === void 0) {
+    return {
+      type: "added",
+      severity: "safe",
+      details: "Graph extension document was added"
+    };
+  }
+  if (after === void 0) {
+    return {
+      type: "removed",
+      severity: "safe",
+      details: "Graph extension document was removed"
+    };
+  }
+  if (canonicalEqual(before, after)) return void 0;
+  return {
+    type: "modified",
+    severity: "safe",
+    details: "Graph extension document was modified"
+  };
+}
+function diffDeprecatedKinds(before, after) {
+  const beforeSet = new Set(before);
+  const afterSet = new Set(after);
+  const added = [];
+  const removed = [];
+  for (const name of afterSet) {
+    if (!beforeSet.has(name)) added.push(name);
+  }
+  for (const name of beforeSet) {
+    if (!afterSet.has(name)) removed.push(name);
+  }
+  if (added.length === 0 && removed.length === 0) return void 0;
+  added.sort();
+  removed.sort();
+  const parts = [];
+  if (added.length > 0) parts.push(`added ${added.join(", ")}`);
+  if (removed.length > 0) parts.push(`removed ${removed.join(", ")}`);
+  return {
+    added,
+    removed,
+    severity: "safe",
+    details: `Deprecated kinds: ${parts.join("; ")}`
+  };
+}
+function generateSummary(nodeChanges, edgeChanges, ontologyChanges, indexChanges, extensionChange, deprecatedKindsChange) {
+  const parts = [];
+  const nodeAdded = nodeChanges.filter((c) => c.type === "added").length;
+  const nodeRemoved = nodeChanges.filter((c) => c.type === "removed").length;
+  const nodeModified = nodeChanges.filter((c) => c.type === "modified").length;
+  if (nodeAdded > 0 || nodeRemoved > 0 || nodeModified > 0) {
+    parts.push(
+      `Nodes: ${nodeAdded} added, ${nodeRemoved} removed, ${nodeModified} modified`
+    );
+  }
+  const edgeAdded = edgeChanges.filter((c) => c.type === "added").length;
+  const edgeRemoved = edgeChanges.filter((c) => c.type === "removed").length;
+  const edgeModified = edgeChanges.filter((c) => c.type === "modified").length;
+  if (edgeAdded > 0 || edgeRemoved > 0 || edgeModified > 0) {
+    parts.push(
+      `Edges: ${edgeAdded} added, ${edgeRemoved} removed, ${edgeModified} modified`
+    );
+  }
+  const ontologyAdded = ontologyChanges.filter(
+    (c) => c.type === "added"
+  ).length;
+  const ontologyRemoved = ontologyChanges.filter(
+    (c) => c.type === "removed"
+  ).length;
+  if (ontologyAdded > 0 || ontologyRemoved > 0) {
+    parts.push(`Ontology: ${ontologyAdded} added, ${ontologyRemoved} removed`);
+  }
+  const indexAdded = indexChanges.filter((c) => c.type === "added").length;
+  const indexRemoved = indexChanges.filter((c) => c.type === "removed").length;
+  const indexModified = indexChanges.filter(
+    (c) => c.type === "modified"
+  ).length;
+  if (indexAdded > 0 || indexRemoved > 0 || indexModified > 0) {
+    parts.push(
+      `Indexes: ${indexAdded} added, ${indexRemoved} removed, ${indexModified} modified`
+    );
+  }
+  if (extensionChange !== void 0) {
+    parts.push(`Graph extension document: ${extensionChange.type}`);
+  }
+  if (deprecatedKindsChange !== void 0) {
+    const { added, removed } = deprecatedKindsChange;
+    parts.push(
+      `Deprecated kinds: ${added.length} added, ${removed.length} removed`
+    );
+  }
+  if (parts.length === 0) {
+    return "No changes";
+  }
+  return parts.join("; ");
+}
+function isBackwardsCompatible(diff) {
+  return !diff.hasBreakingChanges;
+}
+function getMigrationActions(diff) {
+  const actions = [];
+  for (const change of diff.nodes) {
+    if (change.type === "removed") {
+      actions.push(`DELETE data for removed node kind "${change.kind}"`);
+    }
+    if (change.severity === "breaking" && change.type === "modified") {
+      actions.push(
+        `MIGRATE data for node kind "${change.kind}": ${change.details}`
+      );
+    }
+  }
+  for (const change of diff.edges) {
+    if (change.type === "removed") {
+      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 = parts[0];
+      const secondKind = 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);
+  }
+  /**
+   * 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]);
+        break;
+      }
+      case META_EDGE_PART_OF: {
+        partOfRelations.push([fromName, toName]);
+        break;
+      }
+      case META_EDGE_HAS_PART: {
+        partOfRelations.push([toName, fromName]);
+        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 = 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;
+}
+
+// src/schema/serializer.ts
+function serializeSchema(graph, version) {
+  const nodes = serializeNodes(graph);
+  const edges = serializeEdges(graph);
+  const ontology = serializeOntology(graph.ontology);
+  const indexes = serializeIndexes(graph.indexes);
+  const extension = canonicalExtension(graph.extension);
+  const deprecatedKinds = serializeDeprecatedKinds(graph.deprecatedKinds);
+  return {
+    graphId: graph.id,
+    version,
+    generatedAt: nowIso(),
+    nodes,
+    edges,
+    ontology,
+    defaults: {
+      onNodeDelete: graph.defaults.onNodeDelete,
+      temporalMode: graph.defaults.temporalMode
+    },
+    // `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
+    // pre-`indexes` form.
+    ...indexes === void 0 ? {} : { indexes },
+    // The graph extension is the durable source the loader uses to
+    // rebuild extension-kind Zod validators on restart. Omitted on
+    // graphs that have never been extended so legacy schemas hash
+    // byte-identically.
+    ...extension === void 0 ? {} : { extension },
+    // Soft-deprecated kind names. Omitted when empty so legacy
+    // schemas hash byte-identically; sorted for canonical-form
+    // stability across insertion-order differences.
+    ...deprecatedKinds === void 0 ? {} : { deprecatedKinds }
+  };
+}
+function serializeDeprecatedKinds(set) {
+  if (set === void 0 || set.size === 0) return void 0;
+  return [...set].toSorted();
+}
+function canonicalExtension(document) {
+  if (document === void 0) return void 0;
+  if (document.version === void 0) return document;
+  if (document.version !== LEGACY_GRAPH_EXTENSION_VERSION) return document;
+  const { version: _omit, ...rest } = document;
+  return rest;
+}
+function canonicalAnnotations(annotations) {
+  if (annotations === void 0) return void 0;
+  if (Object.keys(annotations).length === 0) return void 0;
+  return annotations;
+}
+function serializeIndexes(indexes) {
+  if (indexes === void 0 || indexes.length === 0) return void 0;
+  return indexes.toSorted(
+    (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0
+  ).map((index) => serializeIndexDeclaration(index));
+}
+function serializeIndexDeclaration(declaration) {
+  if (declaration.entity === "node") {
+    return serializeNodeIndexDeclaration(declaration);
+  }
+  if (declaration.entity === "edge") {
+    return serializeEdgeIndexDeclaration(declaration);
+  }
+  return serializeVectorIndexDeclaration(declaration);
+}
+function serializeVectorIndexDeclaration(declaration) {
+  return {
+    entity: "vector",
+    kind: declaration.kind,
+    name: declaration.name,
+    fieldPath: declaration.fieldPath,
+    dimensions: declaration.dimensions,
+    metric: declaration.metric,
+    indexType: declaration.indexType,
+    indexParams: declaration.indexParams,
+    ...declaration.origin === "runtime" ? { origin: "runtime" } : {}
+  };
+}
+function serializeNodeIndexDeclaration(declaration) {
+  return {
+    entity: "node",
+    kind: declaration.kind,
+    name: declaration.name,
+    fields: declaration.fields,
+    fieldValueTypes: declaration.fieldValueTypes,
+    coveringFields: declaration.coveringFields,
+    coveringFieldValueTypes: declaration.coveringFieldValueTypes,
+    unique: declaration.unique,
+    scope: declaration.scope,
+    where: declaration.where,
+    // `origin: "compile-time"` is the default and is omitted from the
+    // canonical form (absence == compile-time). Only `runtime` is
+    // emitted explicitly so the restart loader can route the declaration
+    // through the runtime compiler.
+    ...declaration.origin === "runtime" ? { origin: "runtime" } : {}
+  };
+}
+function serializeEdgeIndexDeclaration(declaration) {
+  return {
+    entity: "edge",
+    kind: declaration.kind,
+    name: declaration.name,
+    direction: declaration.direction,
+    fields: declaration.fields,
+    fieldValueTypes: declaration.fieldValueTypes,
+    coveringFields: declaration.coveringFields,
+    coveringFieldValueTypes: declaration.coveringFieldValueTypes,
+    unique: declaration.unique,
+    scope: declaration.scope,
+    where: declaration.where,
+    ...declaration.origin === "runtime" ? { origin: "runtime" } : {}
+  };
+}
+function serializeNodes(graph) {
+  const result = {};
+  for (const kindName of getNodeKinds(graph)) {
+    const registration = graph.nodes[kindName];
+    if (registration === void 0) continue;
+    result[kindName] = serializeNodeDef(registration);
+  }
+  return result;
+}
+function serializeNodeDef(registration) {
+  const node = registration.type;
+  const annotations = canonicalAnnotations(node.annotations);
+  return {
+    kind: node.kind,
+    properties: serializeZodSchema(node.schema),
+    uniqueConstraints: serializeUniqueConstraints(registration.unique ?? []),
+    onDelete: registration.onDelete ?? "restrict",
+    description: node.description,
+    ...annotations === void 0 ? {} : { annotations }
+  };
+}
+function serializeUniqueConstraints(constraints) {
+  return constraints.map((constraint) => ({
+    name: constraint.name,
+    fields: [...constraint.fields],
+    where: constraint.where ? serializeWherePredicate(constraint.where) : void 0,
+    scope: constraint.scope,
+    collation: constraint.collation
+  }));
+}
+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 = whereFunction(builder);
+  return JSON.stringify({ field: predicate.field, op: predicate.op });
+}
+function deserializeWherePredicate(serialized) {
+  const parsed = JSON.parse(serialized);
+  return (builder) => {
+    const fieldBuilder = builder[parsed.field];
+    if (!fieldBuilder) {
+      throw new Error(`Unknown field in where predicate: ${parsed.field}`);
+    }
+    const result = parsed.op === "isNull" ? fieldBuilder.isNull() : fieldBuilder.isNotNull();
+    return {
+      __type: "unique_predicate",
+      field: result.field,
+      op: result.op
+    };
+  };
+}
+function serializeEdges(graph) {
+  const result = {};
+  for (const kindName of getEdgeKinds(graph)) {
+    const registration = graph.edges[kindName];
+    if (registration === void 0) continue;
+    result[kindName] = serializeEdgeDef(registration);
+  }
+  return result;
+}
+function serializeEdgeDef(registration) {
+  const edge = registration.type;
+  const annotations = canonicalAnnotations(edge.annotations);
+  return {
+    kind: edge.kind,
+    fromKinds: registration.from.map((node) => node.kind),
+    toKinds: registration.to.map((node) => node.kind),
+    properties: serializeZodSchema(edge.schema),
+    cardinality: registration.cardinality ?? "many",
+    endpointExistence: registration.endpointExistence ?? "notDeleted",
+    description: edge.description,
+    ...annotations === void 0 ? {} : { annotations }
+  };
+}
+function serializeOntology(relations) {
+  const metaEdgeMap = /* @__PURE__ */ new Map();
+  for (const relation of relations) {
+    const metaEdge = relation.metaEdge;
+    if (!metaEdgeMap.has(metaEdge.name)) {
+      metaEdgeMap.set(metaEdge.name, metaEdge);
+    }
+  }
+  const metaEdges = {};
+  for (const [name, metaEdge] of metaEdgeMap) {
+    metaEdges[name] = serializeMetaEdge(metaEdge);
+  }
+  const serializedRelations = relations.map(
+    (relation) => serializeOntologyRelation(relation)
+  );
+  const closures = serializeClosures(relations);
+  return {
+    metaEdges,
+    relations: serializedRelations,
+    closures
+  };
+}
+function serializeMetaEdge(metaEdge) {
+  return {
+    name: metaEdge.name,
+    transitive: metaEdge.properties.transitive,
+    symmetric: metaEdge.properties.symmetric,
+    reflexive: metaEdge.properties.reflexive,
+    inverse: metaEdge.properties.inverse,
+    inference: metaEdge.properties.inference,
+    description: metaEdge.properties.description
+  };
+}
+function serializeOntologyRelation(relation) {
+  return {
+    metaEdge: relation.metaEdge.name,
+    from: getTypeName(relation.from),
+    to: getTypeName(relation.to)
+  };
+}
+function serializeClosures(relations) {
+  if (relations.length === 0) {
+    return {
+      subClassAncestors: {},
+      subClassDescendants: {},
+      broaderClosure: {},
+      narrowerClosure: {},
+      equivalenceSets: {},
+      disjointPairs: [],
+      partOfClosure: {},
+      hasPartClosure: {},
+      iriToKind: {},
+      edgeInverses: {},
+      edgeImplicationsClosure: {},
+      edgeImplyingClosure: {}
+    };
+  }
+  const computed = computeClosuresFromOntology(relations);
+  return {
+    subClassAncestors: mapToRecord(computed.subClassAncestors),
+    subClassDescendants: mapToRecord(computed.subClassDescendants),
+    broaderClosure: mapToRecord(computed.broaderClosure),
+    narrowerClosure: mapToRecord(computed.narrowerClosure),
+    equivalenceSets: mapToRecord(computed.equivalenceSets),
+    disjointPairs: [...computed.disjointPairs],
+    partOfClosure: mapToRecord(computed.partOfClosure),
+    hasPartClosure: mapToRecord(computed.hasPartClosure),
+    iriToKind: mapToSimpleRecord(computed.iriToKind),
+    edgeInverses: mapToSimpleRecord(computed.edgeInverses),
+    edgeImplicationsClosure: mapToRecord(computed.edgeImplicationsClosure),
+    edgeImplyingClosure: mapToRecord(computed.edgeImplyingClosure)
+  };
+}
+function mapToRecord(map) {
+  const result = {};
+  for (const [key, values] of map) {
+    result[key] = [...values];
+  }
+  return result;
+}
+function mapToSimpleRecord(map) {
+  const result = {};
+  for (const [key, value] of map) {
+    result[key] = value;
+  }
+  return result;
+}
+var SCHEMA_PROPERTIES_CACHE = /* @__PURE__ */ new WeakMap();
+function serializeSchemaProperties(schema) {
+  const cached = SCHEMA_PROPERTIES_CACHE.get(schema);
+  if (cached !== void 0) return cached;
+  const computed = serializeZodSchema(schema);
+  SCHEMA_PROPERTIES_CACHE.set(schema, computed);
+  return computed;
+}
+function serializeZodSchema(schema) {
+  try {
+    const jsonSchema = z.toJSONSchema(schema);
+    return jsonSchema;
+  } catch {
+    return { type: "object" };
+  }
+}
+var SCHEMA_HASH_CACHE = /* @__PURE__ */ new WeakMap();
+async function getSchemaHash(graph, version) {
+  const perGraph = SCHEMA_HASH_CACHE.get(graph);
+  const cached = perGraph?.get(version);
+  if (cached !== void 0) return cached;
+  const hash = await computeSchemaHash(serializeSchema(graph, version));
+  if (perGraph === void 0) {
+    SCHEMA_HASH_CACHE.set(graph, /* @__PURE__ */ new Map([[version, hash]]));
+  } else {
+    perGraph.set(version, hash);
+  }
+  return hash;
+}
+async function computeSchemaHash(schema) {
+  const hashable = {
+    graphId: schema.graphId,
+    nodes: schema.nodes,
+    edges: schema.edges,
+    ontology: schema.ontology,
+    defaults: schema.defaults,
+    ...schema.indexes === void 0 ? {} : { indexes: schema.indexes },
+    ...schema.extension === void 0 ? {} : { extension: schema.extension },
+    ...schema.deprecatedKinds === void 0 ? {} : { deprecatedKinds: schema.deprecatedKinds }
+  };
+  const json = JSON.stringify(hashable, sortedReplacer);
+  return sha256Hex(json);
+}
+var COMPILE_NODE_CACHE = /* @__PURE__ */ new Map();
+var COMPILE_EDGE_SCHEMA_CACHE = /* @__PURE__ */ new WeakMap();
+function compileGraphExtension(document) {
+  const nodes = [];
+  const nodeTypeByName = /* @__PURE__ */ new Map();
+  for (const [kindName, nodeDocument] of Object.entries(document.nodes ?? {})) {
+    const compiled = compileNodeCached(kindName, nodeDocument);
+    nodes.push(compiled);
+    nodeTypeByName.set(kindName, compiled.type);
+  }
+  const edges = [];
+  for (const [kindName, edgeDocument] of Object.entries(document.edges ?? {})) {
+    const compiled = compileEdge(kindName, edgeDocument, nodeTypeByName);
+    edges.push(compiled);
+  }
+  const ontology = [];
+  for (const relation of document.ontology ?? []) {
+    ontology.push(compileOntologyRelation(relation, nodeTypeByName));
+  }
+  return Object.freeze({
+    nodes: Object.freeze(nodes),
+    edges: Object.freeze(edges),
+    ontology: Object.freeze(ontology),
+    // Indexes pass through — the merge step resolves the kind name
+    // against graph-extension-or-compile-time NodeType / EdgeType and builds
+    // the final `IndexDeclaration` via `defineNodeIndex` /
+    // `defineEdgeIndex`.
+    indexes: Object.freeze([...document.indexes ?? []])
+  });
+}
+function compileNodeCached(kindName, document) {
+  const perName = COMPILE_NODE_CACHE.get(kindName);
+  const cached = perName?.get(document);
+  if (cached !== void 0) return cached;
+  const computed = compileNode(kindName, document);
+  if (perName === void 0) {
+    COMPILE_NODE_CACHE.set(kindName, new WeakMap([[document, computed]]));
+  } else {
+    perName.set(document, computed);
+  }
+  return computed;
+}
+function compileNode(kindName, document) {
+  const schema = buildObjectSchema(document.properties);
+  const type = defineNode(
+    kindName,
+    compactUndefined({
+      schema,
+      description: document.description,
+      annotations: document.annotations
+    })
+  );
+  const unique = (document.unique ?? []).map(
+    (constraint) => compileUniqueConstraint(constraint)
+  );
+  return Object.freeze({ type, unique: Object.freeze(unique) });
+}
+function compileEdge(kindName, document, nodeTypeByName) {
+  let schema = COMPILE_EDGE_SCHEMA_CACHE.get(document);
+  if (schema === void 0) {
+    schema = buildObjectSchema(document.properties ?? {});
+    COMPILE_EDGE_SCHEMA_CACHE.set(document, schema);
+  }
+  const from = document.from.map(
+    (name) => nodeTypeByName.get(name) ?? name
+  );
+  const to = document.to.map(
+    (name) => nodeTypeByName.get(name) ?? name
+  );
+  return Object.freeze(
+    compactUndefined({
+      kindName,
+      schema,
+      description: document.description,
+      annotations: document.annotations,
+      from: Object.freeze(from),
+      to: Object.freeze(to)
+    })
+  );
+}
+function buildObjectSchema(properties) {
+  const shape = {};
+  for (const [propertyName, propertyType] of Object.entries(properties)) {
+    shape[propertyName] = applyOptional(
+      compileProperty(propertyType),
+      propertyType
+    );
+  }
+  return z.object(shape);
+}
+function compileProperty(property) {
+  switch (property.type) {
+    case "string": {
+      return compileStringProperty(property);
+    }
+    case "number": {
+      return compileNumberProperty(property);
+    }
+    case "boolean": {
+      return z.boolean();
+    }
+    case "enum": {
+      return compileEnumProperty(property);
+    }
+    case "array": {
+      return compileArrayProperty(property);
+    }
+    case "object": {
+      return compileObjectProperty(property);
+    }
+  }
+}
+function compileStringProperty(property) {
+  if (property.searchable !== void 0) {
+    return applyStringRefinements(searchable(property.searchable), property);
+  }
+  if (property.format === void 0) {
+    return applyStringRefinements(z.string(), property);
+  }
+  switch (property.format) {
+    case "datetime": {
+      return z.iso.datetime();
+    }
+    case "date": {
+      return z.iso.date();
+    }
+    case "uri": {
+      return z.url();
+    }
+    case "email": {
+      return z.email();
+    }
+    case "uuid": {
+      return z.uuid();
+    }
+  }
+}
+function applyStringRefinements(base, property) {
+  let schema = base;
+  if (property.minLength !== void 0) schema = schema.min(property.minLength);
+  if (property.maxLength !== void 0) schema = schema.max(property.maxLength);
+  if (property.pattern !== void 0) {
+    schema = schema.regex(new RegExp(property.pattern));
+  }
+  return schema;
+}
+function compileNumberProperty(property) {
+  let schema = z.number();
+  if (property.int === true) {
+    schema = schema.int();
+  }
+  if (property.min !== void 0) {
+    schema = schema.min(property.min);
+  }
+  if (property.max !== void 0) {
+    schema = schema.max(property.max);
+  }
+  return schema;
+}
+function compileEnumProperty(property) {
+  return z.enum(property.values);
+}
+function compileArrayProperty(property) {
+  if (property.embedding !== void 0) {
+    return embedding(property.embedding.dimensions);
+  }
+  const inner = compilePropertyForArrayItem(property.items);
+  return z.array(inner);
+}
+function compilePropertyForArrayItem(item) {
+  return applyOptional(compileProperty(item), item);
+}
+function compileObjectProperty(property) {
+  return buildObjectSchema(property.properties);
+}
+function applyOptional(schema, property) {
+  return property.optional === true ? schema.optional() : schema;
+}
+function compileUniqueConstraint(document) {
+  const base = {
+    name: document.name,
+    fields: document.fields,
+    scope: document.scope ?? "kind",
+    collation: document.collation ?? "binary"
+  };
+  if (document.where === void 0) {
+    return base;
+  }
+  return {
+    ...base,
+    where: makeWherePredicate(document.where.field, document.where.op)
+  };
+}
+function makeWherePredicate(field, op) {
+  return (props) => {
+    const builder = props[field];
+    if (builder === void 0) {
+      return { __type: "unique_predicate", field, op };
+    }
+    const result = op === "isNull" ? builder.isNull() : builder.isNotNull();
+    return result;
+  };
+}
+var META_EDGE_BY_NAME = Object.fromEntries(
+  ALL_META_EDGE_NAMES.map((name) => [name, core[`${name}MetaEdge`]])
+);
+function compileOntologyRelation(relation, nodeTypeByName) {
+  const metaEdge = META_EDGE_BY_NAME[relation.metaEdge];
+  const fromNode = nodeTypeByName.get(relation.from);
+  const toNode = nodeTypeByName.get(relation.to);
+  return {
+    metaEdge,
+    from: fromNode ?? relation.from,
+    to: toNode ?? relation.to
+  };
+}
+
+// src/graph-extension/ontology-keys.ts
+function graphExtensionOntologyKey(entry) {
+  return `${entry.metaEdge}|${entry.from}|${entry.to}`;
+}
+function compileTimeOntologyKey(relation) {
+  return `${relation.metaEdge.name}|${getTypeName(relation.from)}|${getTypeName(relation.to)}`;
+}
+function buildGraphExtensionOntologyKeySet(document) {
+  return new Set(
+    (document?.ontology ?? []).map((entry) => graphExtensionOntologyKey(entry))
+  );
+}
+function extensionKindNames(document) {
+  return {
+    nodes: new Set(Object.keys(document?.nodes ?? {})),
+    edges: new Set(Object.keys(document?.edges ?? {}))
+  };
+}
+
+// src/graph-extension/merge.ts
+function mergeGraphExtension(graph, document) {
+  const existingDocument = graph.extension ?? Object.freeze({});
+  const unionDocument = unionDocuments(existingDocument, document);
+  if (graph.extension !== void 0 && canonicalEqual(unionDocument, existingDocument)) {
+    return graph;
+  }
+  const validatedUnion = unwrap(validateGraphExtension(unionDocument));
+  const compiled = compileGraphExtension(validatedUnion);
+  const { nodes: runtimeNodeNames, edges: runtimeEdgeNames } = extensionKindNames(existingDocument);
+  const nodeKinds = /* @__PURE__ */ new Map();
+  for (const registration of Object.values(graph.nodes)) {
+    if (runtimeNodeNames.has(registration.type.kind)) continue;
+    nodeKinds.set(registration.type.kind, registration.type);
+  }
+  for (const node of compiled.nodes) {
+    assertNoCollision(
+      node.type.kind,
+      "node",
+      nodeKinds.has(node.type.kind),
+      graph.id
+    );
+    nodeKinds.set(node.type.kind, node.type);
+  }
+  const mergedNodes = {};
+  for (const [name, registration] of Object.entries(graph.nodes)) {
+    if (runtimeNodeNames.has(name)) continue;
+    mergedNodes[name] = registration;
+  }
+  for (const node of compiled.nodes) {
+    mergedNodes[node.type.kind] = {
+      type: node.type,
+      ...node.unique.length === 0 ? {} : { unique: [...node.unique] }
+    };
+  }
+  const mergedEdges = {};
+  for (const [name, registration] of Object.entries(graph.edges)) {
+    if (runtimeEdgeNames.has(name)) continue;
+    mergedEdges[name] = registration;
+  }
+  for (const edge of compiled.edges) {
+    assertNoCollision(
+      edge.kindName,
+      "edge",
+      mergedEdges[edge.kindName] !== void 0,
+      graph.id
+    );
+    const from = resolveEndpoints(edge.from, nodeKinds, {
+      graphId: graph.id,
+      edgeKind: edge.kindName,
+      side: "from"
+    });
+    const to = resolveEndpoints(edge.to, nodeKinds, {
+      graphId: graph.id,
+      edgeKind: edge.kindName,
+      side: "to"
+    });
+    const type = defineEdge(
+      edge.kindName,
+      compactUndefined({
+        schema: edge.schema,
+        description: edge.description,
+        annotations: edge.annotations,
+        from,
+        to
+      })
+    );
+    mergedEdges[edge.kindName] = { type, from, to };
+  }
+  const runtimeOntologyKeys = buildGraphExtensionOntologyKeySet(existingDocument);
+  const compileTimeOntology = graph.ontology.filter(
+    (relation) => !runtimeOntologyKeys.has(compileTimeOntologyKey(relation))
+  );
+  const mergedOntology = [
+    ...compileTimeOntology,
+    ...compiled.ontology.map(
+      (relation) => resolveOntologyEndpoints(relation, nodeKinds)
+    )
+  ];
+  const runtimeVectorIndexes = deriveGraphExtensionVectorIndexes(compiled.nodes);
+  const runtimeRelationalIndexes = compileGraphExtensionRelationalIndexes(
+    compiled.indexes,
+    nodeKinds,
+    mergedEdges,
+    graph.id
+  );
+  const mergedIndexes = mergeIndexesWithGraphExtension(
+    graph.indexes,
+    [...runtimeVectorIndexes, ...runtimeRelationalIndexes],
+    graph.id
+  );
+  return Object.freeze({
+    ...graph,
+    nodes: mergedNodes,
+    edges: mergedEdges,
+    ontology: mergedOntology,
+    indexes: mergedIndexes,
+    extension: validatedUnion
+  });
+}
+function deriveGraphExtensionVectorIndexes(compiledNodes) {
+  if (compiledNodes.length === 0) return [];
+  const registrations = {};
+  for (const compiled of compiledNodes) {
+    registrations[compiled.type.kind] = {
+      type: compiled.type,
+      ...compiled.unique.length === 0 ? {} : { unique: [...compiled.unique] }
+    };
+  }
+  return autoDeriveVectorIndexes(registrations).map(
+    (index) => Object.freeze({ ...index, origin: "runtime" })
+  );
+}
+function mergeIndexesWithGraphExtension(existing, runtimeIndexes, graphId) {
+  if (existing === void 0 && runtimeIndexes.length === 0) {
+    return void 0;
+  }
+  const compileTimeIndexes = (existing ?? []).filter(
+    (index) => index.origin !== "runtime"
+  );
+  if (runtimeIndexes.length === 0) return compileTimeIndexes;
+  const runtimeVectors = runtimeIndexes.filter(
+    (index) => index.entity === "vector"
+  );
+  const runtimeRelational = runtimeIndexes.filter(
+    (index) => index.entity !== "vector"
+  );
+  const vectorMerged = mergeVectorIndexes(compileTimeIndexes, runtimeVectors);
+  const merged = [...vectorMerged, ...runtimeRelational];
+  assertUniqueIndexNames(merged, graphId);
+  return merged;
+}
+function assertUniqueIndexNames(indexes, graphId) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const index of indexes) {
+    if (!seen.has(index.name)) {
+      seen.add(index.name);
+      continue;
+    }
+    throw new ConfigurationError(
+      `Duplicate index name "${index.name}" after merging graph extension into graph "${graphId}". Index names must be unique within a graph.`,
+      { graphId, indexName: index.name, code: "DUPLICATE_INDEX_NAME" },
+      {
+        suggestion: "Give the graph-extension index a unique `name`, or remove the duplicate declaration."
+      }
+    );
+  }
+}
+function compileGraphExtensionRelationalIndexes(documents, nodeKinds, mergedEdges, graphId) {
+  if (documents.length === 0) return [];
+  const result = [];
+  for (const document of documents) {
+    if (document.entity === "node") {
+      const node = nodeKinds.get(document.kind);
+      if (node === void 0) {
+        throw new KindNotFoundError(document.kind, "node", {
+          graphId,
+          suggestion: "Declare the kind under `nodes` in this graph extension, or remove the index from `indexes`."
+        });
+      }
+      const declaration2 = defineNodeIndex(
+        node,
+        toNodeIndexConfig(document)
+      );
+      result.push(Object.freeze({ ...declaration2, origin: "runtime" }));
+      continue;
+    }
+    const edgeRegistration = mergedEdges[document.kind];
+    if (edgeRegistration === void 0) {
+      throw new KindNotFoundError(document.kind, "edge", {
+        graphId,
+        suggestion: "Declare the edge under `edges` in this graph extension, or remove the index from `indexes`."
+      });
+    }
+    const declaration = defineEdgeIndex(
+      edgeRegistration.type,
+      toEdgeIndexConfig(document)
+    );
+    result.push(Object.freeze({ ...declaration, origin: "runtime" }));
+  }
+  return result;
+}
+function buildWhereCallback(where) {
+  return (props) => {
+    const builder = props[where.field];
+    if (builder === void 0) {
+      throw new ConfigurationError(
+        `Graph-extension index \`where\` references unknown field "${where.field}".`,
+        { field: where.field, code: "EXTENSION_INDEX_WHERE_UNKNOWN_FIELD" }
+      );
+    }
+    return where.op === "isNull" ? builder.isNull() : builder.isNotNull();
+  };
+}
+function toNodeIndexConfig(document) {
+  return compactUndefined({
+    fields: document.fields,
+    coveringFields: document.coveringFields,
+    unique: document.unique,
+    name: document.name,
+    scope: document.scope,
+    where: document.where === void 0 ? void 0 : buildWhereCallback(document.where)
+  });
+}
+function toEdgeIndexConfig(document) {
+  return compactUndefined({
+    fields: document.fields,
+    coveringFields: document.coveringFields,
+    unique: document.unique,
+    name: document.name,
+    scope: document.scope,
+    direction: document.direction,
+    where: document.where === void 0 ? void 0 : buildWhereCallback(document.where)
+  });
+}
+function unionDocuments(existing, next) {
+  if (isEmptyExtension(existing)) {
+    return next;
+  }
+  const nodes = existing.nodes === void 0 && next.nodes === void 0 ? void 0 : { ...existing.nodes, ...next.nodes };
+  const edges = existing.edges === void 0 && next.edges === void 0 ? void 0 : { ...existing.edges, ...next.edges };
+  const ontology = existing.ontology === void 0 && next.ontology === void 0 ? void 0 : dedupBy(
+    [...existing.ontology ?? [], ...next.ontology ?? []],
+    graphExtensionOntologyKey
+  );
+  const indexes = existing.indexes === void 0 && next.indexes === void 0 ? void 0 : dedupBy(
+    [...existing.indexes ?? [], ...next.indexes ?? []],
+    indexCompositeKey,
+    "last"
+  );
+  const version = next.version ?? existing.version;
+  return Object.freeze({
+    ...version === void 0 ? {} : { version },
+    ...nodes === void 0 ? {} : { nodes },
+    ...edges === void 0 ? {} : { edges },
+    ...ontology === void 0 ? {} : { ontology },
+    ...indexes === void 0 ? {} : { indexes }
+  });
+}
+function dedupBy(items, keyFunction, strategy = "first") {
+  const seen = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const item of items) {
+    const key = keyFunction(item);
+    if (!seen.has(key)) {
+      order.push(key);
+      seen.set(key, item);
+    } else if (strategy === "last") {
+      seen.set(key, item);
+    }
+  }
+  return order.map((key) => seen.get(key));
+}
+function indexCompositeKey(entry) {
+  return `${entry.entity}|${entry.kind}|${entry.name ?? ""}|${entry.fields.join(",")}`;
+}
+function isEmptyExtension(extension) {
+  return extension.nodes === void 0 && extension.edges === void 0 && extension.ontology === void 0 && extension.indexes === void 0;
+}
+function assertNoCollision(kindName, entity, collides, graphId) {
+  if (!collides) return;
+  throw new KindCollisionError(kindName, entity, graphId);
+}
+function resolveEndpoints(entries, nodeKinds, context) {
+  return entries.map((entry) => {
+    if (typeof entry !== "string") return entry;
+    const resolved = nodeKinds.get(entry);
+    if (resolved === void 0) {
+      throw new GraphExtensionUnresolvedEndpointError(
+        context.edgeKind,
+        context.side,
+        entry,
+        context.graphId
+      );
+    }
+    return resolved;
+  });
+}
+function resolveOntologyEndpoints(relation, nodeKinds) {
+  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 };
+}
+var deleteBehaviorZod = z.enum(["restrict", "cascade", "disconnect"]);
+var cardinalityZod = z.enum(["many", "one", "unique", "oneActive"]);
+var endpointExistenceZod = z.enum(["notDeleted", "currentlyValid", "ever"]);
+var temporalModeZod = z.enum([
+  "current",
+  "asOf",
+  "includeEnded",
+  "includeTombstones"
+]);
+var uniquenessScopeZod = z.enum(["kind", "kindWithSubClasses"]);
+var collationZod = z.enum(["binary", "caseInsensitive"]);
+var inferenceTypeZod = z.enum([
+  "subsumption",
+  "hierarchy",
+  "substitution",
+  "constraint",
+  "composition",
+  "association",
+  "none"
+]);
+var indexScopeZod = z.enum(["graphAndKind", "graph", "none"]);
+var indexOriginZod = z.enum(["compile-time", "runtime"]);
+var edgeIndexDirectionZod = z.enum(["out", "in", "none"]);
+var valueTypeZod = z.enum([
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "array",
+  "object",
+  "embedding",
+  "unknown"
+]);
+var valueTypeOrUndefinedZod = valueTypeZod.optional();
+var systemColumnNameZod = z.enum([
+  "graph_id",
+  "kind",
+  "id",
+  "from_kind",
+  "from_id",
+  "to_kind",
+  "to_id",
+  "deleted_at",
+  "valid_from",
+  "valid_to",
+  "created_at",
+  "updated_at",
+  "version"
+]);
+var indexWhereOperandZod = z.discriminatedUnion("__type", [
+  z.object({
+    __type: z.literal("index_operand_system"),
+    column: systemColumnNameZod,
+    valueType: valueTypeOrUndefinedZod
+  }),
+  z.object({
+    __type: z.literal("index_operand_prop"),
+    field: z.string(),
+    valueType: valueTypeOrUndefinedZod
+  })
+]);
+var indexWhereLiteralZod = z.object({
+  __type: z.literal("index_where_literal"),
+  value: z.union([z.string(), z.number(), z.boolean()]),
+  valueType: valueTypeZod
+});
+var indexWhereOpZod = z.enum([
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "notIn"
+]);
+var indexWhereExpressionZod = z.lazy(
+  () => z.discriminatedUnion("__type", [
+    z.object({
+      __type: z.literal("index_where_and"),
+      predicates: z.array(indexWhereExpressionZod)
+    }),
+    z.object({
+      __type: z.literal("index_where_or"),
+      predicates: z.array(indexWhereExpressionZod)
+    }),
+    z.object({
+      __type: z.literal("index_where_not"),
+      predicate: indexWhereExpressionZod
+    }),
+    z.object({
+      __type: z.literal("index_where_comparison"),
+      left: indexWhereOperandZod,
+      op: indexWhereOpZod,
+      right: z.union([indexWhereLiteralZod, z.array(indexWhereLiteralZod)])
+    }),
+    z.object({
+      __type: z.literal("index_where_null_check"),
+      operand: indexWhereOperandZod,
+      op: z.enum(["isNull", "isNotNull"])
+    })
+  ])
+);
+var jsonPointerZod = z.custom(
+  (value) => typeof value === "string",
+  { message: "Expected a JSON pointer string" }
+);
+var indexDeclarationCommonShape = {
+  name: z.string(),
+  // `origin` is optional. `"compile-time"` is the default and is omitted
+  // from canonical form so legacy graphs without indexes hash
+  // byte-identically. Consumers that need a concrete value should
+  // coalesce `index.origin ?? "compile-time"`.
+  origin: indexOriginZod.optional(),
+  fields: z.array(jsonPointerZod),
+  fieldValueTypes: z.array(valueTypeOrUndefinedZod),
+  coveringFields: z.array(jsonPointerZod),
+  coveringFieldValueTypes: z.array(valueTypeOrUndefinedZod),
+  unique: z.boolean(),
+  scope: indexScopeZod,
+  where: indexWhereExpressionZod.optional()
+};
+var nodeIndexDeclarationZod = z.object({
+  entity: z.literal("node"),
+  kind: z.string(),
+  ...indexDeclarationCommonShape
+}).loose();
+var edgeIndexDeclarationZod = z.object({
+  entity: z.literal("edge"),
+  kind: z.string(),
+  direction: edgeIndexDirectionZod,
+  ...indexDeclarationCommonShape
+}).loose();
+var vectorIndexMetricZod = z.enum(["cosine", "l2", "inner_product"]);
+var vectorIndexImplementationZod = z.enum(["hnsw", "ivfflat", "none"]);
+var vectorIndexParamsZod = z.object({
+  m: z.number(),
+  efConstruction: z.number(),
+  lists: z.number().optional()
+}).loose();
+var vectorIndexDeclarationZod = z.object({
+  entity: z.literal("vector"),
+  name: z.string(),
+  origin: indexOriginZod.optional(),
+  kind: z.string(),
+  fieldPath: z.string(),
+  dimensions: z.number(),
+  metric: vectorIndexMetricZod,
+  indexType: vectorIndexImplementationZod,
+  indexParams: vectorIndexParamsZod
+}).loose();
+var indexDeclarationZod = z.discriminatedUnion("entity", [
+  nodeIndexDeclarationZod,
+  edgeIndexDeclarationZod,
+  vectorIndexDeclarationZod
+]);
+var runtimePropertyZod = z.record(z.string(), z.unknown());
+var runtimeNodeDocumentZod = z.object({
+  description: z.string().optional(),
+  annotations: z.record(z.string(), z.json()).optional(),
+  properties: z.record(z.string(), runtimePropertyZod),
+  unique: z.array(z.object({}).loose()).optional()
+}).loose();
+var runtimeEdgeDocumentZod = z.object({
+  description: z.string().optional(),
+  annotations: z.record(z.string(), z.json()).optional(),
+  from: z.array(z.string()),
+  to: z.array(z.string()),
+  properties: z.record(z.string(), runtimePropertyZod).optional()
+}).loose();
+var runtimeOntologyRelationZod = z.object({
+  metaEdge: z.string(),
+  from: z.string(),
+  to: z.string()
+}).loose();
+var runtimeIndexDocumentZod = z.object({
+  entity: z.string(),
+  kind: z.string(),
+  name: z.string().optional(),
+  fields: z.array(z.string()).optional(),
+  coveringFields: z.array(z.string()).optional(),
+  unique: z.boolean().optional(),
+  scope: z.string().optional(),
+  direction: z.string().optional(),
+  where: z.object({ field: z.string(), op: z.string() }).loose().optional()
+}).loose();
+var graphExtensionZod = z.object({
+  // Version is parsed loosely here so the persistence boundary
+  // never rejects a stored document — the runtime validator owns
+  // the version check and produces actionable errors. Documents
+  // that pre-date the field round-trip as `version: undefined`.
+  version: z.number().optional(),
+  nodes: z.record(z.string(), runtimeNodeDocumentZod).optional(),
+  edges: z.record(z.string(), runtimeEdgeDocumentZod).optional(),
+  ontology: z.array(runtimeOntologyRelationZod).optional(),
+  indexes: z.array(runtimeIndexDocumentZod).optional()
+}).loose();
+function checkRecordKeyMatchesField(field, section) {
+  return (record, ctx) => {
+    for (const [key, value] of Object.entries(record)) {
+      const embedded = value[field];
+      if (typeof embedded === "string" && embedded !== key) {
+        ctx.addIssue({
+          code: "custom",
+          path: [key, field],
+          message: `Record key "${key}" does not match ${field} "${embedded}" in ${section}`
+        });
+      }
+    }
+  };
+}
+var serializedSchemaZod = z.object({
+  graphId: z.string(),
+  version: z.number(),
+  generatedAt: z.string(),
+  nodes: z.record(
+    z.string(),
+    z.object({
+      kind: z.string(),
+      properties: z.record(z.string(), z.unknown()),
+      uniqueConstraints: z.array(
+        z.object({
+          name: z.string(),
+          fields: z.array(z.string()),
+          where: z.string().optional(),
+          scope: uniquenessScopeZod,
+          collation: collationZod
+        }).loose()
+      ),
+      onDelete: deleteBehaviorZod,
+      description: z.string().optional(),
+      annotations: z.record(z.string(), z.json()).optional()
+    }).loose()
+  ).superRefine(checkRecordKeyMatchesField("kind", "nodes")),
+  edges: z.record(
+    z.string(),
+    z.object({
+      kind: z.string(),
+      fromKinds: z.array(z.string()),
+      toKinds: z.array(z.string()),
+      properties: z.record(z.string(), z.unknown()),
+      cardinality: cardinalityZod,
+      endpointExistence: endpointExistenceZod,
+      description: z.string().optional(),
+      annotations: z.record(z.string(), z.json()).optional()
+    }).loose()
+  ).superRefine(checkRecordKeyMatchesField("kind", "edges")),
+  ontology: z.object({
+    metaEdges: z.record(
+      z.string(),
+      z.object({
+        name: z.string(),
+        transitive: z.boolean(),
+        symmetric: z.boolean(),
+        reflexive: z.boolean(),
+        inference: inferenceTypeZod,
+        inverse: z.string().optional(),
+        description: z.string().optional()
+      }).loose()
+    ).superRefine(checkRecordKeyMatchesField("name", "ontology.metaEdges")),
+    relations: z.array(
+      z.object({
+        metaEdge: z.string(),
+        from: z.string(),
+        to: z.string()
+      }).loose()
+    ),
+    closures: z.object({
+      subClassAncestors: z.record(z.string(), z.array(z.string())),
+      subClassDescendants: z.record(z.string(), z.array(z.string())),
+      broaderClosure: z.record(z.string(), z.array(z.string())),
+      narrowerClosure: z.record(z.string(), z.array(z.string())),
+      equivalenceSets: z.record(z.string(), z.array(z.string())),
+      disjointPairs: z.array(z.string()),
+      partOfClosure: z.record(z.string(), z.array(z.string())),
+      hasPartClosure: z.record(z.string(), z.array(z.string())),
+      iriToKind: z.record(z.string(), z.string()),
+      edgeInverses: z.record(z.string(), z.string()),
+      edgeImplicationsClosure: z.record(z.string(), z.array(z.string())),
+      edgeImplyingClosure: z.record(z.string(), z.array(z.string()))
+    }).loose()
+  }).loose(),
+  defaults: z.object({
+    onNodeDelete: deleteBehaviorZod,
+    temporalMode: temporalModeZod
+  }).loose(),
+  /**
+   * Index declarations attached to the graph.
+   *
+   * Optional: graphs that never declared the slice omit the field
+   * entirely so their canonical-form hash is byte-identical to graphs
+   * authored before `indexes` existed.
+   */
+  indexes: z.array(indexDeclarationZod).optional(),
+  /**
+   * Graph extension persisted alongside the compiled `nodes` / `edges`
+   * / `ontology` slices. The loader rebuilds extension-kind Zod
+   * validators from this value (the only durable source); legacy
+   * graphs omit the field and hash byte-identically to before
+   * extensions existed.
+   *
+   * `.loose()` on the inner shape accepts forward-compatible additions
+   * without breaking older readers.
+   */
+  extension: graphExtensionZod.optional(),
+  /**
+   * Names of node and edge kinds the operator has soft-deprecated via
+   * `store.deprecateKinds(...)`. Surfaces in introspection so consumers
+   * (codegen, UI tooling, lints) can route around them. Does not affect
+   * reads, writes, or queries.
+   *
+   * Omitted when empty so legacy schemas hash byte-identically.
+   */
+  deprecatedKinds: z.array(z.string()).optional()
+});
+
+// src/schema/manager.ts
+var PARSE_CACHE_LIMIT = 100;
+var PARSE_CACHE = /* @__PURE__ */ new Map();
+function parseSerializedSchema(json) {
+  const cached = PARSE_CACHE.get(json);
+  if (cached !== void 0) {
+    PARSE_CACHE.delete(json);
+    PARSE_CACHE.set(json, cached);
+    return cached;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    throw new DatabaseOperationError(
+      "Stored schema document is not valid JSON",
+      { operation: "select", entity: "schema" }
+    );
+  }
+  const result = serializedSchemaZod.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ");
+    throw new DatabaseOperationError(
+      `Stored schema document is malformed: ${issues}`,
+      { operation: "select", entity: "schema" }
+    );
+  }
+  const validated = freezeDeep(result.data);
+  if (PARSE_CACHE.size >= PARSE_CACHE_LIMIT) {
+    const oldest = PARSE_CACHE.keys().next().value;
+    if (oldest !== void 0) PARSE_CACHE.delete(oldest);
+  }
+  PARSE_CACHE.set(json, validated);
+  return validated;
+}
+var MISSING_TABLE_PATTERNS = [
+  "no such table",
+  // SQLite
+  "does not exist",
+  // PostgreSQL ("relation ... does not exist")
+  "SQLITE_ERROR"
+  // D1 / Durable Objects error code
+];
+function isMissingTableError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return MISSING_TABLE_PATTERNS.some((pattern) => message.includes(pattern));
+}
+async function loadActiveSchemaWithBootstrap(backend, graphId) {
+  try {
+    const row = await backend.getActiveSchema(graphId);
+    await backend.ensureFulltextTable?.();
+    return row;
+  } catch (error) {
+    if (backend.bootstrapTables && isMissingTableError(error)) {
+      await backend.bootstrapTables();
+      return await backend.getActiveSchema(graphId);
+    }
+    throw error;
+  }
+}
+async function loadAndMergeGraphExtensionDocument(backend, graph) {
+  const activeRow = await loadActiveSchemaWithBootstrap(backend, graph.id);
+  if (activeRow === void 0) {
+    return { graph, activeRow: void 0, storedSchema: void 0 };
+  }
+  const storedSchema = parseSerializedSchema(activeRow.schema_doc);
+  const merged = storedSchema.extension === void 0 ? graph : mergeGraphExtension(graph, storedSchema.extension);
+  return {
+    graph: applyDeprecatedKinds(merged, storedSchema.deprecatedKinds),
+    activeRow,
+    storedSchema
+  };
+}
+function applyDeprecatedKinds(graph, names) {
+  const current = graph.deprecatedKinds;
+  if (names === current) return graph;
+  const nextSet = names === void 0 ? /* @__PURE__ */ new Set() : names instanceof Set ? names : new Set(names);
+  if (nextSet.size === 0 && current.size === 0) return graph;
+  if (nextSet.size === current.size && [...nextSet].every((name) => current.has(name))) {
+    return graph;
+  }
+  return Object.freeze({
+    ...graph,
+    deprecatedKinds: Object.freeze(new Set(nextSet))
+  });
+}
+async function ensureSchema(backend, graph, options) {
+  const autoMigrate = options?.autoMigrate ?? true;
+  const throwOnBreaking = options?.throwOnBreaking ?? true;
+  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);
+    return {
+      status: "initialized",
+      version: result.version,
+      committedRow: result
+    };
+  }
+  const storedHash = activeSchema.schema_hash;
+  const currentHash = await getSchemaHash(graph, activeSchema.version + 1);
+  if (storedHash === currentHash) {
+    return { status: "unchanged", version: activeSchema.version };
+  }
+  const storedSchema = preloaded?.storedSchema ?? parseSerializedSchema(activeSchema.schema_doc);
+  const currentSchema = serializeSchema(graph, activeSchema.version + 1);
+  const diff = computeSchemaDiff(storedSchema, currentSchema);
+  if (!diff.hasChanges) {
+    return { status: "unchanged", version: activeSchema.version };
+  }
+  if (isBackwardsCompatible(diff)) {
+    if (autoMigrate) {
+      const hookContext = {
+        graphId: graph.id,
+        fromVersion: activeSchema.version,
+        toVersion: activeSchema.version + 1,
+        diff
+      };
+      await options?.onBeforeMigrate?.(hookContext);
+      const committedRow = await commitNewSchemaVersion(
+        backend,
+        graph,
+        activeSchema.version
+      );
+      await options?.onAfterMigrate?.(hookContext);
+      return {
+        status: "migrated",
+        fromVersion: activeSchema.version,
+        toVersion: committedRow.version,
+        diff,
+        committedRow
+      };
+    }
+    return {
+      status: "pending",
+      version: activeSchema.version,
+      diff
+    };
+  }
+  const actions = getMigrationActions(diff);
+  if (throwOnBreaking) {
+    throw new MigrationError(
+      `Schema migration required: ${diff.summary}. ${actions.length} migration action(s) needed. Use getSchemaChanges() to review, then migrateSchema() to apply.`,
+      {
+        graphId: graph.id,
+        fromVersion: activeSchema.version,
+        toVersion: activeSchema.version + 1
+      }
+    );
+  }
+  return { status: "breaking", diff, actions };
+}
+async function initializeSchema(backend, graph) {
+  const schema = serializeSchema(graph, 1);
+  const hash = await computeSchemaHash(schema);
+  return backend.commitSchemaVersion({
+    graphId: graph.id,
+    expected: { kind: "initial" },
+    version: 1,
+    schemaHash: hash,
+    schemaDoc: schema
+  });
+}
+async function migrateSchema(backend, graph, currentVersion) {
+  const committed = await commitNewSchemaVersion(
+    backend,
+    graph,
+    currentVersion
+  );
+  return committed.version;
+}
+async function commitNewSchemaVersion(backend, graph, currentVersion) {
+  const newVersion = currentVersion + 1;
+  const schema = serializeSchema(graph, newVersion);
+  const hash = await computeSchemaHash(schema);
+  return backend.commitSchemaVersion({
+    graphId: graph.id,
+    expected: { kind: "active", version: currentVersion },
+    version: newVersion,
+    schemaHash: hash,
+    schemaDoc: schema
+  });
+}
+async function rollbackSchema(backend, graphId, targetVersion) {
+  const activeRow = await backend.getActiveSchema(graphId);
+  if (activeRow === void 0) {
+    throw new MigrationError(
+      `Cannot rollback graph "${graphId}": no active schema version exists.`,
+      { graphId, fromVersion: 0, toVersion: targetVersion }
+    );
+  }
+  await backend.setActiveVersion({
+    graphId,
+    expected: { kind: "active", version: activeRow.version },
+    version: targetVersion
+  });
+}
+async function getActiveSchema(backend, graphId) {
+  const row = await backend.getActiveSchema(graphId);
+  if (row === void 0) return void 0;
+  return parseSerializedSchema(row.schema_doc);
+}
+async function isSchemaInitialized(backend, graphId) {
+  const row = await backend.getActiveSchema(graphId);
+  return row !== void 0;
+}
+async function getSchemaChanges(backend, graph) {
+  const activeSchema = await backend.getActiveSchema(graph.id);
+  if (activeSchema === void 0) return void 0;
+  const storedSchema = parseSerializedSchema(activeSchema.schema_doc);
+  const currentSchema = serializeSchema(graph, activeSchema.version + 1);
+  return computeSchemaDiff(storedSchema, currentSchema);
+}
+
+// src/errors/validation.ts
+function zodIssuesToValidationIssues(error) {
+  return error.issues.map((issue) => ({
+    path: issue.path.join("."),
+    message: issue.message,
+    code: issue.code
+  }));
+}
+function buildLocationString(context) {
+  if (context.id) {
+    return `${context.kind}/${context.id}`;
+  }
+  return `new ${context.kind}`;
+}
+function validateProps(schema, props, context) {
+  const result = schema.safeParse(props);
+  if (result.success) {
+    return result.data;
+  }
+  const issues = zodIssuesToValidationIssues(result.error);
+  const location = buildLocationString(context);
+  throw new ValidationError(
+    `Invalid ${context.entityType} props for ${location}: ${result.error.message}`,
+    {
+      entityType: context.entityType,
+      kind: context.kind,
+      operation: context.operation,
+      ...context.id !== void 0 && { id: context.id },
+      issues
+    },
+    { cause: result.error }
+  );
+}
+function validateNodeProps(schema, props, context) {
+  return validateProps(schema, props, {
+    entityType: "node",
+    ...context
+  });
+}
+function validateEdgeProps(schema, props, context) {
+  return validateProps(schema, props, {
+    entityType: "edge",
+    ...context
+  });
+}
+function wrapZodError(error, context) {
+  const issues = zodIssuesToValidationIssues(error);
+  const location = buildLocationString(context);
+  return new ValidationError(
+    `Validation failed for ${context.entityType} ${location}: ${error.message}`,
+    {
+      entityType: context.entityType,
+      kind: context.kind,
+      operation: context.operation,
+      ...context.id !== void 0 && { id: context.id },
+      issues
+    },
+    { cause: error }
+  );
+}
+function createValidationError(message, issues, context) {
+  return new ValidationError(message, {
+    ...context?.entityType !== void 0 && {
+      entityType: context.entityType
+    },
+    ...context?.kind !== void 0 && { kind: context.kind },
+    ...context?.operation !== void 0 && { operation: context.operation },
+    ...context?.id !== void 0 && { id: context.id },
+    issues
+  });
+}
+
+export { KindRegistry, META_EDGE_BRAND, applyDeprecatedKinds, broader, buildGraphExtensionOntologyKeySet, canonicalEqual, commitNewSchemaVersion, compileTimeOntologyKey, computeClosuresFromOntology, computeSchemaDiff, computeSchemaHash, core, createEmptyClosures, createValidationError, defineEdge, defineNode, deserializeWherePredicate, differentFrom, disjointWith, ensureSchema, equivalentTo, extensionKindNames, getActiveSchema, getMigrationActions, getSchemaChanges, getTypeName, hasPart, implies, initializeSchema, inverseOf, isBackwardsCompatible, isMetaEdge, isSchemaInitialized, loadActiveSchemaWithBootstrap, loadAndMergeGraphExtensionDocument, mergeGraphExtension, migrateSchema, narrower, parseSerializedSchema, partOf, relatedTo, rollbackSchema, sameAs, serializeSchema, serializeSchemaProperties, sortedReplacer, subClassOf, validateEdgeProps, validateNodeProps, validateProps, wrapZodError };
+//# sourceMappingURL=chunk-AAA2CR3P.js.map
+//# sourceMappingURL=chunk-AAA2CR3P.js.map