@nicia-ai/typegraph 0.2.0 → 0.3.0

package/dist/chunk-DD6ONEBN.cjs

@@ -0,0 +1,1264 @@
+'use strict';
+
+var chunkZJHQZZT2_cjs = require('./chunk-ZJHQZZT2.cjs');
+var chunkOYL2SGBD_cjs = require('./chunk-OYL2SGBD.cjs');
+var zod = require('zod');
+
+// 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/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 chunkOYL2SGBD_cjs.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 chunkOYL2SGBD_cjs.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 chunkOYL2SGBD_cjs.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
+  });
+}
+
+// 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 allChanges = [...nodeChanges, ...edgeChanges, ...ontologyChanges];
+  const hasBreakingChanges = allChanges.some(
+    (change) => change.severity === "breaking"
+  );
+  const hasChanges = allChanges.length > 0;
+  const summary = generateSummary(nodeChanges, edgeChanges, ontologyChanges);
+  return {
+    fromVersion: before.version,
+    toVersion: after.version,
+    nodes: nodeChanges,
+    edges: edgeChanges,
+    ontology: ontologyChanges,
+    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 = [];
+  const propsBefore = JSON.stringify(before.properties);
+  const propsAfter = JSON.stringify(after.properties);
+  if (propsBefore !== propsAfter) {
+    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
+    });
+  }
+  const constraintsBefore = JSON.stringify(before.uniqueConstraints);
+  const constraintsAfter = JSON.stringify(after.uniqueConstraints);
+  if (constraintsBefore !== constraintsAfter) {
+    changes.push({
+      type: "modified",
+      kind: name,
+      severity: "warning",
+      details: `Unique constraints 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 = [];
+  const fromBefore = JSON.stringify(before.fromKinds);
+  const fromAfter = JSON.stringify(after.fromKinds);
+  if (fromBefore !== fromAfter) {
+    changes.push({
+      type: "modified",
+      kind: name,
+      severity: "warning",
+      details: `fromKinds changed for "${name}"`,
+      before,
+      after
+    });
+  }
+  const toBefore = JSON.stringify(before.toKinds);
+  const toAfter = JSON.stringify(after.toKinds);
+  if (toBefore !== toAfter) {
+    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
+    });
+  }
+  const propsBefore = JSON.stringify(before.properties);
+  const propsAfter = JSON.stringify(after.properties);
+  if (propsBefore !== propsAfter) {
+    changes.push({
+      type: "modified",
+      kind: name,
+      severity: "safe",
+      details: `Properties changed for "${name}"`,
+      before,
+      after
+    });
+  }
+  return changes;
+}
+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 generateSummary(nodeChanges, edgeChanges, ontologyChanges) {
+  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`);
+  }
+  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/ontology/closures.ts
+function computeTransitiveClosure(relations) {
+  const closure = /* @__PURE__ */ new Map();
+  const allNodes = /* @__PURE__ */ new Set();
+  for (const [from, to] of relations) {
+    allNodes.add(from);
+    allNodes.add(to);
+  }
+  for (const node of allNodes) {
+    closure.set(node, /* @__PURE__ */ new Set());
+  }
+  for (const [from, to] of relations) {
+    closure.get(from)?.add(to);
+  }
+  for (const k of allNodes) {
+    for (const index of allNodes) {
+      const indexReaches = closure.get(index);
+      if (!indexReaches?.has(k)) continue;
+      const kReaches = closure.get(k);
+      if (!kReaches) continue;
+      for (const index2 of kReaches) {
+        indexReaches.add(index2);
+      }
+    }
+  }
+  return closure;
+}
+function invertClosure(closure) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [from, tos] of closure) {
+    for (const to of tos) {
+      const existing = result.get(to) ?? /* @__PURE__ */ new Set();
+      existing.add(from);
+      result.set(to, existing);
+    }
+  }
+  return result;
+}
+function isReachable(closure, source, target) {
+  return closure.get(source)?.has(target) ?? false;
+}
+
+// src/ontology/constants.ts
+var META_EDGE_SUB_CLASS_OF = "subClassOf";
+var META_EDGE_BROADER = "broader";
+var META_EDGE_NARROWER = "narrower";
+var META_EDGE_RELATED_TO = "relatedTo";
+var META_EDGE_EQUIVALENT_TO = "equivalentTo";
+var META_EDGE_SAME_AS = "sameAs";
+var META_EDGE_DIFFERENT_FROM = "differentFrom";
+var META_EDGE_DISJOINT_WITH = "disjointWith";
+var META_EDGE_PART_OF = "partOf";
+var META_EDGE_HAS_PART = "hasPart";
+var META_EDGE_INVERSE_OF = "inverseOf";
+var META_EDGE_IMPLIES = "implies";
+
+// 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 narrower = this.narrowerClosure.get(kind) ?? /* @__PURE__ */ new Set();
+    return [kind, ...narrower];
+  }
+  /**
+   * Expands to include all broader concepts.
+   */
+  expandBroader(kind) {
+    const broader = this.broaderClosure.get(kind) ?? /* @__PURE__ */ new Set();
+    return [kind, ...broader];
+  }
+  // === 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 a = parts[0];
+      const b = parts[1];
+      if (a === kind) result.push(b);
+      else if (b === kind) result.push(a);
+    }
+    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 p = parent.get(x);
+    if (p === x) return x;
+    const root = find(p);
+    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);
+  return {
+    graphId: graph.id,
+    version,
+    generatedAt: chunkZJHQZZT2_cjs.nowIso(),
+    nodes,
+    edges,
+    ontology,
+    defaults: {
+      onNodeDelete: graph.defaults.onNodeDelete,
+      temporalMode: graph.defaults.temporalMode
+    }
+  };
+}
+function serializeNodes(graph) {
+  const result = {};
+  for (const kindName of chunkZJHQZZT2_cjs.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;
+  return {
+    kind: node.kind,
+    properties: serializeZodSchema(node.schema),
+    uniqueConstraints: serializeUniqueConstraints(registration.unique ?? []),
+    onDelete: registration.onDelete ?? "restrict",
+    description: node.description
+  };
+}
+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 chunkZJHQZZT2_cjs.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;
+  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
+  };
+}
+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;
+}
+function serializeZodSchema(schema) {
+  try {
+    const jsonSchema = zod.z.toJSONSchema(schema);
+    return jsonSchema;
+  } catch {
+    return { type: "object" };
+  }
+}
+async function computeSchemaHash(schema) {
+  const hashable = {
+    graphId: schema.graphId,
+    nodes: schema.nodes,
+    edges: schema.edges,
+    ontology: schema.ontology,
+    defaults: schema.defaults
+  };
+  const json = JSON.stringify(hashable, sortedReplacer);
+  return sha256Hash(json);
+}
+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;
+}
+async function sha256Hash(input) {
+  const encoded = new TextEncoder().encode(input);
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", encoded);
+  const bytes = new Uint8Array(digest);
+  let hex = "";
+  for (let index = 0; index < 8; index++) {
+    const byte = bytes[index];
+    if (byte === void 0) break;
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+
+// src/schema/manager.ts
+async function ensureSchema(backend, graph, options) {
+  const autoMigrate = options?.autoMigrate ?? true;
+  const throwOnBreaking = options?.throwOnBreaking ?? true;
+  const activeSchema = await backend.getActiveSchema(graph.id);
+  if (!activeSchema) {
+    const result = await initializeSchema(backend, graph);
+    return { status: "initialized", version: result.version };
+  }
+  const storedSchema = JSON.parse(activeSchema.schema_doc);
+  const currentSchema = serializeSchema(graph, activeSchema.version + 1);
+  const storedHash = activeSchema.schema_hash;
+  const currentHash = await computeSchemaHash(currentSchema);
+  if (storedHash === currentHash) {
+    return { status: "unchanged", version: activeSchema.version };
+  }
+  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 newVersion = await migrateSchema(
+        backend,
+        graph,
+        activeSchema.version
+      );
+      await options?.onAfterMigrate?.(hookContext);
+      return {
+        status: "migrated",
+        fromVersion: activeSchema.version,
+        toVersion: newVersion,
+        diff
+      };
+    }
+    return {
+      status: "pending",
+      version: activeSchema.version,
+      diff
+    };
+  }
+  const actions = getMigrationActions(diff);
+  if (throwOnBreaking) {
+    throw new chunkOYL2SGBD_cjs.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.insertSchema({
+    graphId: graph.id,
+    version: 1,
+    schemaHash: hash,
+    schemaDoc: schema,
+    isActive: true
+  });
+}
+async function migrateSchema(backend, graph, currentVersion) {
+  const newVersion = currentVersion + 1;
+  const schema = serializeSchema(graph, newVersion);
+  const hash = await computeSchemaHash(schema);
+  await backend.insertSchema({
+    graphId: graph.id,
+    version: newVersion,
+    schemaHash: hash,
+    schemaDoc: schema,
+    isActive: false
+  });
+  await backend.setActiveSchema(graph.id, newVersion);
+  return newVersion;
+}
+async function rollbackSchema(backend, graphId, targetVersion) {
+  const row = await backend.getSchemaVersion(graphId, targetVersion);
+  if (!row) {
+    throw new chunkOYL2SGBD_cjs.MigrationError(
+      `Cannot rollback to version ${targetVersion}: version does not exist.`,
+      { graphId, fromVersion: targetVersion, toVersion: targetVersion }
+    );
+  }
+  await backend.setActiveSchema(graphId, targetVersion);
+}
+async function getActiveSchema(backend, graphId) {
+  const row = await backend.getActiveSchema(graphId);
+  if (!row) return void 0;
+  return JSON.parse(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) return void 0;
+  const storedSchema = JSON.parse(activeSchema.schema_doc);
+  const currentSchema = serializeSchema(graph, activeSchema.version + 1);
+  return computeSchemaDiff(storedSchema, currentSchema);
+}
+
+exports.KindRegistry = KindRegistry;
+exports.META_EDGE_BRAND = META_EDGE_BRAND;
+exports.META_EDGE_BROADER = META_EDGE_BROADER;
+exports.META_EDGE_DIFFERENT_FROM = META_EDGE_DIFFERENT_FROM;
+exports.META_EDGE_DISJOINT_WITH = META_EDGE_DISJOINT_WITH;
+exports.META_EDGE_EQUIVALENT_TO = META_EDGE_EQUIVALENT_TO;
+exports.META_EDGE_HAS_PART = META_EDGE_HAS_PART;
+exports.META_EDGE_IMPLIES = META_EDGE_IMPLIES;
+exports.META_EDGE_INVERSE_OF = META_EDGE_INVERSE_OF;
+exports.META_EDGE_NARROWER = META_EDGE_NARROWER;
+exports.META_EDGE_PART_OF = META_EDGE_PART_OF;
+exports.META_EDGE_RELATED_TO = META_EDGE_RELATED_TO;
+exports.META_EDGE_SAME_AS = META_EDGE_SAME_AS;
+exports.META_EDGE_SUB_CLASS_OF = META_EDGE_SUB_CLASS_OF;
+exports.computeClosuresFromOntology = computeClosuresFromOntology;
+exports.computeSchemaDiff = computeSchemaDiff;
+exports.computeSchemaHash = computeSchemaHash;
+exports.createEmptyClosures = createEmptyClosures;
+exports.createValidationError = createValidationError;
+exports.deserializeWherePredicate = deserializeWherePredicate;
+exports.ensureSchema = ensureSchema;
+exports.getActiveSchema = getActiveSchema;
+exports.getMigrationActions = getMigrationActions;
+exports.getSchemaChanges = getSchemaChanges;
+exports.initializeSchema = initializeSchema;
+exports.isBackwardsCompatible = isBackwardsCompatible;
+exports.isMetaEdge = isMetaEdge;
+exports.isSchemaInitialized = isSchemaInitialized;
+exports.migrateSchema = migrateSchema;
+exports.rollbackSchema = rollbackSchema;
+exports.serializeSchema = serializeSchema;
+exports.validateEdgeProps = validateEdgeProps;
+exports.validateNodeProps = validateNodeProps;
+exports.validateProps = validateProps;
+exports.wrapZodError = wrapZodError;
+//# sourceMappingURL=chunk-DD6ONEBN.cjs.map
+//# sourceMappingURL=chunk-DD6ONEBN.cjs.map