@nicia-ai/typegraph 0.45.0 → 0.46.1

package/dist/{chunk-J2ICGNHO.cjs → chunk-7BQXPCGN.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunkSVJ5GEXW_cjs = require('./chunk-SVJ5GEXW.cjs');
-var chunkD54WH24V_cjs = require('./chunk-D54WH24V.cjs');
-var chunkDI74SMXS_cjs = require('./chunk-DI74SMXS.cjs');
-var chunkC4F7VJ5D_cjs = require('./chunk-C4F7VJ5D.cjs');
-var chunkTDXIBCGY_cjs = require('./chunk-TDXIBCGY.cjs');
+var chunkXUO3KQFO_cjs = require('./chunk-XUO3KQFO.cjs');
+var chunkLBJKZXDE_cjs = require('./chunk-LBJKZXDE.cjs');
+var chunkNI72YOJB_cjs = require('./chunk-NI72YOJB.cjs');
+var chunkA7J2YDDI_cjs = require('./chunk-A7J2YDDI.cjs');
+var chunkN66HCGCY_cjs = require('./chunk-N66HCGCY.cjs');
 
 // src/ontology/closures.ts
 function computeTransitiveClosure(relations) {
@@ -77,6 +77,7 @@ var GRAPH_EXTENSION_ISSUE_CODES = [
   "ONTOLOGY_CYCLE",
   "ONTOLOGY_SELF_LOOP",
   "ONTOLOGY_DISJOINT_CONFLICT",
+  "ONTOLOGY_INVERSE_MULTIPLE_PARTNERS",
   "DUPLICATE_ONTOLOGY_RELATION",
   "INVALID_DOCUMENT_SHAPE",
   "UNKNOWN_DOCUMENT_KEY",
@@ -86,7 +87,7 @@ var GRAPH_EXTENSION_ISSUE_CODES = [
   "EMPTY_INDEX_FIELDS",
   "UNKNOWN_PROPERTY_KEY"
 ];
-var GraphExtensionError = class extends chunkC4F7VJ5D_cjs.TypeGraphError {
+var GraphExtensionError = class extends chunkNI72YOJB_cjs.TypeGraphError {
   constructor(spec) {
     super(spec.message, spec.code, {
       details: spec.details,
@@ -197,6 +198,21 @@ var GraphExtensionUnresolvedEndpointError = class extends GraphExtensionError {
     this.endpoint = endpoint;
   }
 };
+var GraphExtensionUnresolvedOntologyEndpointError = class extends GraphExtensionError {
+  code = "GRAPH_EXTENSION_UNRESOLVED_ONTOLOGY_ENDPOINT";
+  metaEdge;
+  endpoint;
+  constructor(metaEdge, endpoint, graphId) {
+    super({
+      message: `Graph-extension ${metaEdge} endpoint "${endpoint}" does not resolve to a registered edge kind on graph "${graphId}".`,
+      code: "GRAPH_EXTENSION_UNRESOLVED_ONTOLOGY_ENDPOINT",
+      details: { metaEdge, endpoint, graphId },
+      suggestion: "Correct the local edge-kind name, register that edge, or use an absolute http:// or https:// IRI for a deliberate inert external reference."
+    });
+    this.metaEdge = metaEdge;
+    this.endpoint = endpoint;
+  }
+};
 var RemoveCompileTimeKindError = class extends GraphExtensionError {
   code = "REMOVE_COMPILE_TIME_KIND";
   kindName;
@@ -277,8 +293,725 @@ var GRAPH_EXTENSION_TOP_LEVEL_KEYS = [
   "indexes"
 ];
 
+// src/ontology/external-iri.ts
+function isExternalIri(value) {
+  return value.startsWith("http://") || value.startsWith("https://");
+}
+
+// src/registry/kind-registry.ts
+var KindRegistry = class {
+  // === Node & Edge Kinds ===
+  nodeKinds;
+  edgeKinds;
+  /**
+   * Durable graph identity capability; supplies the identity defaults for
+   * every query builder built from this registry (compile-only and
+   * store-bound).
+   */
+  identity;
+  // === Subsumption (subClassOf) ===
+  // Transitive closure for inheritance
+  subClassAncestors;
+  subClassDescendants;
+  // === Hierarchy (broader/narrower) ===
+  // Transitive closure for concept hierarchy (separate from subClassOf!)
+  broaderClosure;
+  narrowerClosure;
+  // === Equivalence ===
+  equivalenceSets;
+  iriToKind;
+  relatedKinds;
+  // === Constraints ===
+  disjointPairs;
+  // Normalized pairs: "Organization|Person"
+  // === Composition ===
+  partOfClosure;
+  hasPartClosure;
+  // === Edge Relationships ===
+  edgeInverses;
+  edgeImplicationsClosure;
+  edgeImplyingClosure;
+  constructor(nodeKinds, edgeKinds, closures, identity) {
+    this.nodeKinds = nodeKinds;
+    this.edgeKinds = edgeKinds;
+    this.identity = identity;
+    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.relatedKinds = closures.relatedKinds;
+    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);
+  }
+  /** Gets directly associated kinds declared through symmetric `relatedTo`. */
+  getRelatedKinds(kind) {
+    const related = this.relatedKinds.get(kind);
+    return related === void 0 ? [] : [...related];
+  }
+  // === 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 = chunkN66HCGCY_cjs.requireDefined(parts[0]);
+      const secondKind = chunkN66HCGCY_cjs.requireDefined(parts[1]);
+      if (firstKind === kind) result.push(secondKind);
+      else if (secondKind === kind) result.push(firstKind);
+    }
+    return result;
+  }
+  // === Composition Methods ===
+  /**
+   * Checks if part is part of whole (directly or transitively).
+   */
+  isPartOf(part, whole) {
+    return isReachable(this.partOfClosure, part, whole);
+  }
+  /**
+   * Gets all wholes that contain this part.
+   */
+  getWholes(part) {
+    const wholes = this.partOfClosure.get(part);
+    return wholes ? [...wholes] : [];
+  }
+  /**
+   * Gets all parts of this whole.
+   */
+  getParts(whole) {
+    const parts = this.hasPartClosure.get(whole);
+    return parts ? [...parts] : [];
+  }
+  // === Edge Relationship Methods ===
+  /**
+   * Gets the inverse edge kind for a given edge kind.
+   * If edgeA inverseOf edgeB, then getInverseEdge("edgeA") returns "edgeB".
+   */
+  getInverseEdge(edgeKind) {
+    return this.edgeInverses.get(edgeKind);
+  }
+  /**
+   * Gets all edges implied by a given edge (transitively).
+   * If A implies B and B implies C, then getImpliedEdges("A") returns ["B", "C"].
+   */
+  getImpliedEdges(edgeKind) {
+    const implied = this.edgeImplicationsClosure.get(edgeKind);
+    return implied ? [...implied] : [];
+  }
+  /**
+   * Gets all edges that imply a given edge (transitively).
+   * If A implies B and B implies C, then getImplyingEdges("C") returns ["A", "B"].
+   * Used for query-time expansion: when querying for C, also include A and B edges.
+   */
+  getImplyingEdges(edgeKind) {
+    const implying = this.edgeImplyingClosure.get(edgeKind);
+    return implying ? [...implying] : [];
+  }
+  /**
+   * Expands an edge kind to include all edges that imply it.
+   * Returns [edgeKind, ...implyingEdges].
+   */
+  expandImplyingEdges(edgeKind) {
+    const implying = this.edgeImplyingClosure.get(edgeKind) ?? /* @__PURE__ */ new Set();
+    return [edgeKind, ...implying];
+  }
+  // === Edge Endpoint Validation ===
+  /**
+   * Checks if a concrete kind is assignable to a target kind.
+   * Uses subsumption: Company is assignable to Organization if Company subClassOf Organization.
+   */
+  isAssignableTo(concreteKind, targetKind) {
+    if (concreteKind === targetKind) return true;
+    return this.isSubClassOf(concreteKind, targetKind);
+  }
+  /**
+   * Checks if a concrete kind is assignable to at least one of the given
+   * target kinds. Shared by every "is this kind usable where one of these
+   * kinds is expected" check (edge endpoint validation, ontology relation
+   * endpoint compatibility) so they can't independently drift.
+   */
+  isAssignableToAny(concreteKind, targetKinds) {
+    return targetKinds.some(
+      (targetKind) => this.isAssignableTo(concreteKind, targetKind)
+    );
+  }
+  /**
+   * Validates that a kind exists in the registry.
+   */
+  hasNodeType(name) {
+    return this.nodeKinds.has(name);
+  }
+  /**
+   * Validates that an edge kind exists in the registry.
+   */
+  hasEdgeType(name) {
+    return this.edgeKinds.has(name);
+  }
+  /**
+   * Gets a node kind by name.
+   */
+  getNodeType(name) {
+    return this.nodeKinds.get(name);
+  }
+  /**
+   * Gets an edge kind by name.
+   */
+  getEdgeType(name) {
+    return this.edgeKinds.get(name);
+  }
+};
+function createEmptyClosures() {
+  return {
+    subClassAncestors: /* @__PURE__ */ new Map(),
+    subClassDescendants: /* @__PURE__ */ new Map(),
+    broaderClosure: /* @__PURE__ */ new Map(),
+    narrowerClosure: /* @__PURE__ */ new Map(),
+    equivalenceSets: /* @__PURE__ */ new Map(),
+    iriToKind: /* @__PURE__ */ new Map(),
+    relatedKinds: /* @__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) {
+  return computeClosuresFromNamedOntology(
+    ontology.map((relation) => ({
+      metaEdge: relation.metaEdge.name,
+      from: getKindName(relation.from),
+      to: getKindName(relation.to)
+    }))
+  );
+}
+function collectOntologyRelations(ontology) {
+  const subClass = [];
+  const broader = [];
+  const equivalent = [];
+  const related = [];
+  const disjoint = [];
+  const partOf = [];
+  const inverseOf = [];
+  const implies = [];
+  for (const relation of ontology) {
+    const fromName = relation.from;
+    const toName = relation.to;
+    switch (relation.metaEdge) {
+      case chunkXUO3KQFO_cjs.META_EDGE_SUB_CLASS_OF: {
+        subClass.push([fromName, toName]);
+        break;
+      }
+      case chunkXUO3KQFO_cjs.META_EDGE_BROADER: {
+        broader.push([fromName, toName]);
+        break;
+      }
+      case chunkXUO3KQFO_cjs.META_EDGE_NARROWER: {
+        broader.push([toName, fromName]);
+        break;
+      }
+      case chunkXUO3KQFO_cjs.META_EDGE_EQUIVALENT_TO:
+      case chunkXUO3KQFO_cjs.META_EDGE_SAME_AS: {
+        equivalent.push([fromName, toName]);
+        break;
+      }
+      case chunkXUO3KQFO_cjs.META_EDGE_RELATED_TO: {
+        related.push([fromName, toName]);
+        break;
+      }
+      case chunkXUO3KQFO_cjs.META_EDGE_DISJOINT_WITH: {
+        disjoint.push([fromName, toName]);
+        break;
+      }
+      case chunkXUO3KQFO_cjs.META_EDGE_PART_OF: {
+        partOf.push([fromName, toName]);
+        break;
+      }
+      case chunkXUO3KQFO_cjs.META_EDGE_HAS_PART: {
+        partOf.push([toName, fromName]);
+        break;
+      }
+      case chunkXUO3KQFO_cjs.META_EDGE_INVERSE_OF: {
+        inverseOf.push([fromName, toName]);
+        break;
+      }
+      case chunkXUO3KQFO_cjs.META_EDGE_IMPLIES: {
+        implies.push([fromName, toName]);
+        break;
+      }
+    }
+  }
+  return {
+    subClass,
+    broader,
+    equivalent,
+    related,
+    disjoint,
+    partOf,
+    inverseOf,
+    implies
+  };
+}
+function computeSubsumptionAndEquivalenceClosures(collected) {
+  const subClassAncestors = computeTransitiveClosure(collected.subClass);
+  return {
+    subClassAncestors,
+    subClassDescendants: invertClosure(subClassAncestors),
+    equivalenceSets: computeEquivalenceSets(collected.equivalent)
+  };
+}
+function computeDisjointExpansionClosures(ontology) {
+  return computeSubsumptionAndEquivalenceClosures(
+    collectOntologyRelations(ontology)
+  );
+}
+function computeClosuresFromNamedOntology(ontology) {
+  const collected = collectOntologyRelations(ontology);
+  const { subClassAncestors, subClassDescendants, equivalenceSets } = computeSubsumptionAndEquivalenceClosures(collected);
+  const broaderClosure = computeTransitiveClosure(collected.broader);
+  const narrowerClosure = invertClosure(broaderClosure);
+  const iriToKind = computeIriMapping(collected.equivalent);
+  const relatedKinds = computeSymmetricRelations(collected.related);
+  const disjointPairs = computeDisjointPairs(collected.disjoint, {
+    subClassDescendants,
+    equivalenceSets
+  });
+  const partOfClosure = computeTransitiveClosure(collected.partOf);
+  const hasPartClosure = invertClosure(partOfClosure);
+  const edgeInverses = computeEdgeInverses(collected.inverseOf);
+  const edgeImplicationsClosure = computeTransitiveClosure(collected.implies);
+  const edgeImplyingClosure = invertClosure(edgeImplicationsClosure);
+  return {
+    subClassAncestors,
+    subClassDescendants,
+    broaderClosure,
+    narrowerClosure,
+    equivalenceSets,
+    iriToKind,
+    relatedKinds,
+    disjointPairs,
+    partOfClosure,
+    hasPartClosure,
+    edgeInverses,
+    edgeImplicationsClosure,
+    edgeImplyingClosure
+  };
+}
+function getKindName(kindOrIri) {
+  if (typeof kindOrIri === "string") {
+    return kindOrIri;
+  }
+  return kindOrIri.kind;
+}
+function computeEquivalenceSets(relations) {
+  const parent = /* @__PURE__ */ new Map();
+  const size = /* @__PURE__ */ new Map();
+  function find(x) {
+    if (!parent.has(x)) {
+      parent.set(x, x);
+      size.set(x, 1);
+      return x;
+    }
+    let root = x;
+    while (chunkN66HCGCY_cjs.requireDefined(parent.get(root)) !== root) {
+      root = chunkN66HCGCY_cjs.requireDefined(parent.get(root));
+    }
+    let cursor = x;
+    while (cursor !== root) {
+      const next = chunkN66HCGCY_cjs.requireDefined(parent.get(cursor));
+      parent.set(cursor, root);
+      cursor = next;
+    }
+    return root;
+  }
+  function union(a, b) {
+    const rootA = find(a);
+    const rootB = find(b);
+    if (rootA === rootB) return;
+    const sizeA = chunkN66HCGCY_cjs.requireDefined(size.get(rootA));
+    const sizeB = chunkN66HCGCY_cjs.requireDefined(size.get(rootB));
+    const [root, child] = sizeA >= sizeB ? [rootA, rootB] : [rootB, rootA];
+    parent.set(child, root);
+    size.set(root, sizeA + sizeB);
+  }
+  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) {
+      result.set(member, new ExcludingReadonlySet(members, member));
+    }
+  }
+  return result;
+}
+var ExcludingReadonlySet = class {
+  #members;
+  #excludedMember;
+  [Symbol.toStringTag] = "Set";
+  constructor(members, excludedMember) {
+    this.#members = members;
+    this.#excludedMember = excludedMember;
+  }
+  get size() {
+    return this.#members.size - (this.#members.has(this.#excludedMember) ? 1 : 0);
+  }
+  has(value) {
+    return value !== this.#excludedMember && this.#members.has(value);
+  }
+  *entries() {
+    for (const value of this) yield [value, value];
+  }
+  keys() {
+    return this.values();
+  }
+  *values() {
+    for (const value of this.#members) {
+      if (value !== this.#excludedMember) yield value;
+    }
+  }
+  forEach(callbackFunction, thisArgument) {
+    for (const value of this) {
+      callbackFunction.call(thisArgument, value, value, this);
+    }
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  union(other) {
+    return this.materialize().union(other);
+  }
+  intersection(other) {
+    return this.materialize().intersection(other);
+  }
+  difference(other) {
+    return this.materialize().difference(other);
+  }
+  symmetricDifference(other) {
+    return this.materialize().symmetricDifference(other);
+  }
+  isSubsetOf(other) {
+    return this.materialize().isSubsetOf(other);
+  }
+  isSupersetOf(other) {
+    return this.materialize().isSupersetOf(other);
+  }
+  isDisjointFrom(other) {
+    return this.materialize().isDisjointFrom(other);
+  }
+  materialize() {
+    return new Set(this);
+  }
+};
+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, closures) {
+  const result = /* @__PURE__ */ new Set();
+  for (const [a, b] of relations) {
+    const leftKinds = expandDisjointSide(a, closures);
+    const rightKinds = expandDisjointSide(b, closures);
+    for (const left of leftKinds) {
+      for (const right of rightKinds) {
+        if (left === right) continue;
+        const normalized = left < right ? `${left}|${right}` : `${right}|${left}`;
+        result.add(normalized);
+      }
+    }
+  }
+  return result;
+}
+function expandDisjointSide(kind, closures) {
+  const expanded = /* @__PURE__ */ new Set();
+  const consumedEquivalenceClasses = /* @__PURE__ */ new Set();
+  const pending = [kind];
+  while (pending.length > 0) {
+    const current = chunkN66HCGCY_cjs.requireDefined(pending.pop());
+    if (expanded.has(current) || isExternalIri(current)) continue;
+    expanded.add(current);
+    if (!consumedEquivalenceClasses.has(current)) {
+      consumedEquivalenceClasses.add(current);
+      for (const equivalent of closures.equivalenceSets.get(current) ?? []) {
+        consumedEquivalenceClasses.add(equivalent);
+        pending.push(equivalent);
+      }
+    }
+    for (const descendant of closures.subClassDescendants.get(current) ?? []) {
+      pending.push(descendant);
+    }
+  }
+  return [...expanded];
+}
+function computeSymmetricRelations(relations) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [a, b] of relations) {
+    const relatedToA = result.get(a) ?? /* @__PURE__ */ new Set();
+    relatedToA.add(b);
+    result.set(a, relatedToA);
+    const relatedToB = result.get(b) ?? /* @__PURE__ */ new Set();
+    relatedToB.add(a);
+    result.set(b, relatedToB);
+  }
+  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/ontology/validation.ts
+var STRICTLY_HIERARCHICAL = /* @__PURE__ */ new Set([
+  chunkXUO3KQFO_cjs.META_EDGE_SUB_CLASS_OF,
+  chunkXUO3KQFO_cjs.META_EDGE_BROADER,
+  chunkXUO3KQFO_cjs.META_EDGE_NARROWER,
+  chunkXUO3KQFO_cjs.META_EDGE_PART_OF,
+  chunkXUO3KQFO_cjs.META_EDGE_HAS_PART
+]);
+var HIERARCHICAL_NORMALIZATION = /* @__PURE__ */ new Map([
+  [chunkXUO3KQFO_cjs.META_EDGE_SUB_CLASS_OF, { canonical: chunkXUO3KQFO_cjs.META_EDGE_SUB_CLASS_OF, flip: false }],
+  [chunkXUO3KQFO_cjs.META_EDGE_BROADER, { canonical: chunkXUO3KQFO_cjs.META_EDGE_BROADER, flip: false }],
+  [chunkXUO3KQFO_cjs.META_EDGE_NARROWER, { canonical: chunkXUO3KQFO_cjs.META_EDGE_BROADER, flip: true }],
+  [chunkXUO3KQFO_cjs.META_EDGE_PART_OF, { canonical: chunkXUO3KQFO_cjs.META_EDGE_PART_OF, flip: false }],
+  [chunkXUO3KQFO_cjs.META_EDGE_HAS_PART, { canonical: chunkXUO3KQFO_cjs.META_EDGE_PART_OF, flip: true }]
+]);
+function validateOntologyRelations(ontology) {
+  const issues = [];
+  validateSelfLoopsAndDuplicates(ontology, issues);
+  detectHierarchicalCycles(ontology, issues);
+  detectDisjointExpansionConflicts(ontology, issues);
+  detectMultipleInversePartners(ontology, issues);
+  return issues;
+}
+function validateSelfLoopsAndDuplicates(ontology, issues) {
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const [index, relation] of ontology.entries()) {
+    if (relation.from === relation.to) {
+      if (STRICTLY_HIERARCHICAL.has(relation.metaEdge)) {
+        issues.push({
+          relationIndex: index,
+          message: `Hierarchical meta-edge "${relation.metaEdge}" cannot be a self-loop ("${relation.from}" \u2192 "${relation.to}").`,
+          code: "ONTOLOGY_SELF_LOOP",
+          details: { metaEdge: relation.metaEdge, kind: relation.from }
+        });
+      } else if (relation.metaEdge === chunkXUO3KQFO_cjs.META_EDGE_DISJOINT_WITH) {
+        issues.push({
+          relationIndex: index,
+          message: `Contradiction: kind "${relation.from}" cannot be declared disjointWith itself.`,
+          code: "ONTOLOGY_DISJOINT_CONFLICT",
+          details: { from: relation.from, to: relation.to }
+        });
+      }
+    }
+    const key = `${relation.metaEdge}::${relation.from}->${relation.to}`;
+    if (seenKeys.has(key)) {
+      issues.push({
+        relationIndex: index,
+        message: `Duplicate ontology relation "${relation.metaEdge}" (${relation.from} \u2192 ${relation.to}).`,
+        code: "DUPLICATE_ONTOLOGY_RELATION",
+        details: { ...relation }
+      });
+      continue;
+    }
+    seenKeys.add(key);
+  }
+}
+function buildHierarchicalGroups(ontology) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [index, relation] of ontology.entries()) {
+    const normalization = HIERARCHICAL_NORMALIZATION.get(relation.metaEdge);
+    if (normalization === void 0) continue;
+    if (relation.from === relation.to) continue;
+    const from = normalization.flip ? relation.to : relation.from;
+    const to = normalization.flip ? relation.from : relation.to;
+    const edges = groups.get(normalization.canonical) ?? [];
+    edges.push({ from, to, originalIndex: index });
+    groups.set(normalization.canonical, edges);
+  }
+  return groups;
+}
+function detectHierarchicalCycles(ontology, issues) {
+  const groups = buildHierarchicalGroups(ontology);
+  for (const [name, edges] of groups) {
+    const closure = computeTransitiveClosure(
+      edges.map((edge) => [edge.from, edge.to])
+    );
+    const reportedNodes = /* @__PURE__ */ new Set();
+    for (const [from, reachable] of closure) {
+      if (!reachable.has(from) || reportedNodes.has(from)) continue;
+      reportedNodes.add(from);
+      const offendingEdge = edges.find((edge) => edge.from === from);
+      issues.push({
+        ...offendingEdge === void 0 ? {} : { relationIndex: offendingEdge.originalIndex },
+        message: `Cycle detected in "${name}" relations involving "${from}".`,
+        code: "ONTOLOGY_CYCLE",
+        details: { metaEdge: name, kind: from }
+      });
+    }
+  }
+}
+function collectDisjointDeclarations(ontology) {
+  const declarations = [];
+  for (const [index, relation] of ontology.entries()) {
+    if (relation.metaEdge !== chunkXUO3KQFO_cjs.META_EDGE_DISJOINT_WITH) continue;
+    if (relation.from === relation.to) continue;
+    declarations.push({ a: relation.from, b: relation.to, index });
+  }
+  return declarations;
+}
+function detectDisjointExpansionConflicts(ontology, issues) {
+  const declarations = collectDisjointDeclarations(ontology);
+  if (declarations.length === 0) return;
+  const closures = computeDisjointExpansionClosures(ontology);
+  for (const { a, b, index } of declarations) {
+    const left = expandDisjointSide(a, closures);
+    const right = new Set(expandDisjointSide(b, closures));
+    const overlappingKind = [...left].filter((kind) => right.has(kind)).toSorted()[0];
+    if (overlappingKind === void 0) continue;
+    issues.push({
+      relationIndex: index,
+      message: `Contradiction: the propagated disjointWith sides "${a}" and "${b}" both contain kind "${overlappingKind}".`,
+      code: "ONTOLOGY_DISJOINT_CONFLICT",
+      details: { kind: overlappingKind, from: a, to: b }
+    });
+  }
+}
+function detectMultipleInversePartners(ontology, issues) {
+  const partners = /* @__PURE__ */ new Map();
+  for (const [index, relation] of ontology.entries()) {
+    if (relation.metaEdge !== chunkXUO3KQFO_cjs.META_EDGE_INVERSE_OF) continue;
+    recordInversePartner(relation.from, relation.to, index, partners, issues);
+    if (relation.from !== relation.to) {
+      recordInversePartner(relation.to, relation.from, index, partners, issues);
+    }
+  }
+}
+function recordInversePartner(edgeKind, partnerKind, relationIndex, partners, issues) {
+  const existingPartner = partners.get(edgeKind);
+  if (existingPartner === void 0) {
+    partners.set(edgeKind, partnerKind);
+    return;
+  }
+  if (existingPartner === partnerKind) return;
+  issues.push({
+    relationIndex,
+    message: `Edge kind "${edgeKind}" has multiple distinct inverseOf partners ("${existingPartner}" and "${partnerKind}").`,
+    code: "ONTOLOGY_INVERSE_MULTIPLE_PARTNERS",
+    details: { edgeKind, existingPartner, conflictingPartner: partnerKind }
+  });
+}
+
 // src/graph-extension/validation.ts
-var META_EDGE_NAME_SET = new Set(chunkSVJ5GEXW_cjs.ALL_META_EDGE_NAMES);
+var META_EDGE_NAME_SET = new Set(chunkXUO3KQFO_cjs.ALL_META_EDGE_NAMES);
 var SUPPORTED_PROPERTY_TYPES = /* @__PURE__ */ new Set([
   "string",
   "number",
@@ -315,7 +1048,7 @@ function rejectUnknownPropertyKeys(raw, type, path, issues) {
   for (const key of Object.keys(raw)) {
     if (COMMON_PROPERTY_KEYS.has(key) || typeKeys.has(key)) continue;
     issues.push({
-      path: `${path}/${chunkTDXIBCGY_cjs.encodeJsonPointerSegment(key)}`,
+      path: `${path}/${chunkA7J2YDDI_cjs.encodeJsonPointerSegment(key)}`,
       message: `Unknown property key "${key}" for type "${type}". Recognized keys: ${recognized.join(", ")}.`,
       code: "UNKNOWN_PROPERTY_KEY"
     });
@@ -325,7 +1058,7 @@ function rejectUnknownObjectKeys(raw, allowed, label, path, code, issues) {
   for (const key of Object.keys(raw)) {
     if (allowed.has(key)) continue;
     issues.push({
-      path: `${path}/${chunkTDXIBCGY_cjs.encodeJsonPointerSegment(key)}`,
+      path: `${path}/${chunkA7J2YDDI_cjs.encodeJsonPointerSegment(key)}`,
       message: `Unknown ${label} key "${key}". Allowed: ${[...allowed].join(", ")}.`,
       code
     });
@@ -384,7 +1117,7 @@ var EDGE_INDEX_KEYS = /* @__PURE__ */ new Set([
 function validateGraphExtension(input, options = {}) {
   const issues = [];
   const strict = options.strict === true;
-  if (!chunkDI74SMXS_cjs.isPlainObject(input)) {
+  if (!chunkN66HCGCY_cjs.isPlainObject(input)) {
     issues.push({
       path: "",
       message: "Document must be a plain object.",
@@ -397,7 +1130,7 @@ function validateGraphExtension(input, options = {}) {
     for (const key of Object.keys(documentRecord)) {
       if (!KNOWN_DOCUMENT_KEYS.has(key)) {
         issues.push({
-          path: `/${chunkTDXIBCGY_cjs.encodeJsonPointerSegment(key)}`,
+          path: `/${chunkA7J2YDDI_cjs.encodeJsonPointerSegment(key)}`,
           message: `Unknown top-level key "${key}". Did you mean one of: ${[...KNOWN_DOCUMENT_KEYS].join(", ")}?`,
           code: "UNKNOWN_DOCUMENT_KEY"
         });
@@ -413,7 +1146,7 @@ function validateGraphExtension(input, options = {}) {
     strict
   );
   if (ontology !== void 0) {
-    validateOntology(ontology, nodes, issues);
+    validateOntology(ontology, issues);
   }
   const indexes = validateIndexesSection(
     documentRecord["indexes"],
@@ -445,7 +1178,7 @@ function validateVersion(raw, issues) {
 }
 function validateNodesSection(rawNodes, issues, strict) {
   if (rawNodes === void 0) return void 0;
-  if (!chunkDI74SMXS_cjs.isPlainObject(rawNodes)) {
+  if (!chunkN66HCGCY_cjs.isPlainObject(rawNodes)) {
     issues.push({
       path: "/nodes",
       message: "`nodes` must be a plain object keyed by node-kind name.",
@@ -453,10 +1186,10 @@ function validateNodesSection(rawNodes, issues, strict) {
     });
     return void 0;
   }
-  const result = {};
+  const result = chunkN66HCGCY_cjs.createDataKeyedBag();
   const recorded = /* @__PURE__ */ new Set();
   for (const [kindName, rawNode] of Object.entries(rawNodes)) {
-    const path = `/nodes/${chunkTDXIBCGY_cjs.encodeJsonPointerSegment(kindName)}`;
+    const path = `/nodes/${chunkA7J2YDDI_cjs.encodeJsonPointerSegment(kindName)}`;
     if (!isValidKindName(kindName)) {
       issues.push({
         path,
@@ -478,10 +1211,10 @@ function validateNodesSection(rawNodes, issues, strict) {
     result[kindName] = node;
     recorded.add(kindName);
   }
-  return result;
+  return { ...result };
 }
 function validateNodeDocument(kindName, raw, path, issues, strict) {
-  if (!chunkDI74SMXS_cjs.isPlainObject(raw)) {
+  if (!chunkN66HCGCY_cjs.isPlainObject(raw)) {
     issues.push({
       path,
       message: `Node "${kindName}" must be a plain object.`,
@@ -530,7 +1263,7 @@ function validateNodeDocument(kindName, raw, path, issues, strict) {
     issues,
     strict
   );
-  return chunkDI74SMXS_cjs.compactUndefined({
+  return chunkN66HCGCY_cjs.compactUndefined({
     description,
     annotations,
     properties,
@@ -539,7 +1272,7 @@ function validateNodeDocument(kindName, raw, path, issues, strict) {
 }
 function validateEdgesSection(rawEdges, issues, strict) {
   if (rawEdges === void 0) return void 0;
-  if (!chunkDI74SMXS_cjs.isPlainObject(rawEdges)) {
+  if (!chunkN66HCGCY_cjs.isPlainObject(rawEdges)) {
     issues.push({
       path: "/edges",
       message: "`edges` must be a plain object keyed by edge-kind name.",
@@ -547,10 +1280,10 @@ function validateEdgesSection(rawEdges, issues, strict) {
     });
     return void 0;
   }
-  const result = {};
+  const result = chunkN66HCGCY_cjs.createDataKeyedBag();
   const recorded = /* @__PURE__ */ new Set();
   for (const [kindName, rawEdge] of Object.entries(rawEdges)) {
-    const path = `/edges/${chunkTDXIBCGY_cjs.encodeJsonPointerSegment(kindName)}`;
+    const path = `/edges/${chunkA7J2YDDI_cjs.encodeJsonPointerSegment(kindName)}`;
     if (!isValidKindName(kindName)) {
       issues.push({
         path,
@@ -572,10 +1305,10 @@ function validateEdgesSection(rawEdges, issues, strict) {
     result[kindName] = edge;
     recorded.add(kindName);
   }
-  return result;
+  return { ...result };
 }
 function validateEdgeDocument(kindName, raw, path, issues, strict) {
-  if (!chunkDI74SMXS_cjs.isPlainObject(raw)) {
+  if (!chunkN66HCGCY_cjs.isPlainObject(raw)) {
     issues.push({
       path,
       message: `Edge "${kindName}" must be a plain object.`,
@@ -619,7 +1352,7 @@ function validateEdgeDocument(kindName, raw, path, issues, strict) {
     strict
   );
   if (properties === void 0) return void 0;
-  return chunkDI74SMXS_cjs.compactUndefined({
+  return chunkN66HCGCY_cjs.compactUndefined({
     description,
     annotations,
     from,
@@ -671,7 +1404,7 @@ function validateOntologySection(raw, issues, strict) {
   const result = [];
   for (const [index, entry] of raw.entries()) {
     const path = `/ontology/${index}`;
-    if (!chunkDI74SMXS_cjs.isPlainObject(entry)) {
+    if (!chunkN66HCGCY_cjs.isPlainObject(entry)) {
       issues.push({
         path,
         message: "Ontology entry must be a plain object.",
@@ -695,7 +1428,7 @@ function validateOntologySection(raw, issues, strict) {
     if (typeof metaEdge !== "string" || !META_EDGE_NAME_SET.has(metaEdge)) {
       issues.push({
         path: `${path}/metaEdge`,
-        message: `Unknown meta-edge ${describeUnknownValue(metaEdge)}. Allowed: ${[...chunkSVJ5GEXW_cjs.ALL_META_EDGE_NAMES].join(", ")}.`,
+        message: `Unknown meta-edge ${describeUnknownValue(metaEdge)}. Allowed: ${[...chunkXUO3KQFO_cjs.ALL_META_EDGE_NAMES].join(", ")}.`,
         code: "UNKNOWN_META_EDGE"
       });
       continue;
@@ -720,113 +1453,14 @@ function validateOntologySection(raw, issues, strict) {
   }
   return result;
 }
-function validateOntology(ontology, _nodes, issues) {
-  const seenKey = /* @__PURE__ */ new Set();
-  for (const [index, relation] of ontology.entries()) {
-    const path = `/ontology/${index}`;
-    if (relation.from === relation.to && isStrictlyHierarchicalMetaEdge(relation.metaEdge)) {
-      issues.push({
-        path,
-        message: `Hierarchical meta-edge "${relation.metaEdge}" cannot be a self-loop ("${relation.from}" \u2192 "${relation.to}").`,
-        code: "ONTOLOGY_SELF_LOOP"
-      });
-    }
-    const key = `${relation.metaEdge}::${relation.from}->${relation.to}`;
-    if (seenKey.has(key)) {
-      issues.push({
-        path,
-        message: `Duplicate ontology relation "${relation.metaEdge}" (${relation.from} \u2192 ${relation.to}).`,
-        code: "DUPLICATE_ONTOLOGY_RELATION"
-      });
-      continue;
-    }
-    seenKey.add(key);
-  }
-  detectHierarchicalCycles(ontology, issues);
-  detectDisjointHierarchyContradictions(ontology, issues);
-}
-var STRICTLY_HIERARCHICAL = /* @__PURE__ */ new Set([
-  "subClassOf",
-  "broader",
-  "narrower",
-  "partOf",
-  "hasPart"
-]);
-function isStrictlyHierarchicalMetaEdge(name) {
-  return STRICTLY_HIERARCHICAL.has(name);
-}
-var HIERARCHICAL_NORMALIZATION = /* @__PURE__ */ new Map([
-  ["subClassOf", { canonical: "subClassOf", flip: false }],
-  ["broader", { canonical: "broader", flip: false }],
-  ["narrower", { canonical: "broader", flip: true }],
-  ["partOf", { canonical: "partOf", flip: false }],
-  ["hasPart", { canonical: "partOf", flip: true }]
-]);
-function buildHierarchicalGroups(ontology, options) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const [index, relation] of ontology.entries()) {
-    const normalization = HIERARCHICAL_NORMALIZATION.get(relation.metaEdge);
-    if (normalization === void 0) continue;
-    if (options.skipSelfLoops && relation.from === relation.to) continue;
-    const from = normalization.flip ? relation.to : relation.from;
-    const to = normalization.flip ? relation.from : relation.to;
-    const list = groups.get(normalization.canonical) ?? [];
-    list.push({ from, to, originalIndex: index });
-    groups.set(normalization.canonical, list);
-  }
-  return groups;
-}
-function detectHierarchicalCycles(ontology, issues) {
-  const groups = buildHierarchicalGroups(ontology, { skipSelfLoops: true });
-  for (const [name, edges] of groups) {
-    const closure = computeTransitiveClosure(
-      edges.map((edge) => [edge.from, edge.to])
-    );
-    const reportedNodes = /* @__PURE__ */ new Set();
-    for (const [from, reachable] of closure) {
-      if (!reachable.has(from) || reportedNodes.has(from)) continue;
-      reportedNodes.add(from);
-      const offendingEdge = edges.find((edge) => edge.from === from);
-      const path = offendingEdge === void 0 ? "/ontology" : `/ontology/${offendingEdge.originalIndex}`;
-      issues.push({
-        path,
-        message: `Cycle detected in "${name}" relations involving "${from}".`,
-        code: "ONTOLOGY_CYCLE"
-      });
-    }
-  }
-}
-function detectDisjointHierarchyContradictions(ontology, issues) {
-  const disjointPairs = /* @__PURE__ */ new Set();
-  const disjointPath = /* @__PURE__ */ new Map();
-  for (const [index, relation] of ontology.entries()) {
-    if (relation.metaEdge !== "disjointWith") continue;
-    disjointPairs.add(`${relation.from}|${relation.to}`);
-    disjointPairs.add(`${relation.to}|${relation.from}`);
-    disjointPath.set(`${relation.from}|${relation.to}`, `/ontology/${index}`);
-    disjointPath.set(`${relation.to}|${relation.from}`, `/ontology/${index}`);
-  }
-  if (disjointPairs.size === 0) return;
-  const groups = buildHierarchicalGroups(ontology, { skipSelfLoops: false });
-  const reported = /* @__PURE__ */ new Set();
-  for (const [name, edges] of groups) {
-    const closure = computeTransitiveClosure(
-      edges.map((edge) => [edge.from, edge.to])
-    );
-    for (const [from, reachable] of closure) {
-      for (const to of reachable) {
-        const pairKey = `${from}|${to}`;
-        if (!disjointPairs.has(pairKey)) continue;
-        if (reported.has(pairKey)) continue;
-        reported.add(pairKey);
-        issues.push({
-          path: disjointPath.get(pairKey) ?? "/ontology",
-          message: `Contradiction: "${from}" and "${to}" are declared disjointWith but also related by "${name}" (directly or transitively).`,
-          code: "ONTOLOGY_DISJOINT_CONFLICT"
-        });
-      }
-    }
-  }
+function validateOntology(ontology, issues) {
+  issues.push(
+    ...validateOntologyRelations(ontology).map((issue) => ({
+      path: issue.relationIndex === void 0 ? "/ontology" : `/ontology/${issue.relationIndex}`,
+      message: issue.message,
+      code: issue.code
+    }))
+  );
 }
 var INDEX_SCOPE_VALUES = ["graphAndKind", "graph", "none"];
 var EDGE_INDEX_DIRECTION_VALUES = ["out", "in", "none"];
@@ -866,7 +1500,7 @@ function validateIndexesSection(rawIndexes, issues, strict) {
   return result;
 }
 function validateIndexEntry(raw, path, issues, strict) {
-  if (!chunkDI74SMXS_cjs.isPlainObject(raw)) {
+  if (!chunkN66HCGCY_cjs.isPlainObject(raw)) {
     issues.push({
       path,
       message: "Index entry must be a plain object.",
@@ -950,7 +1584,7 @@ function validateIndexEntry(raw, path, issues, strict) {
     strict
   );
   if (entity === "node") {
-    return chunkDI74SMXS_cjs.compactUndefined({
+    return chunkN66HCGCY_cjs.compactUndefined({
       entity: "node",
       kind: raw["kind"],
       name,
@@ -971,7 +1605,7 @@ function validateIndexEntry(raw, path, issues, strict) {
   );
   if (!directionResult.ok) return void 0;
   const direction = directionResult.value;
-  return chunkDI74SMXS_cjs.compactUndefined({
+  return chunkN66HCGCY_cjs.compactUndefined({
     entity: "edge",
     kind: raw["kind"],
     name,
@@ -1035,7 +1669,7 @@ function validateStringList(raw, path, issues, options) {
 }
 function validateGraphExtensionIndexWhere(raw, path, issues, strict) {
   if (raw === void 0) return void 0;
-  if (!chunkDI74SMXS_cjs.isPlainObject(raw)) {
+  if (!chunkN66HCGCY_cjs.isPlainObject(raw)) {
     issues.push({
       path,
       message: "Index `where` must be a plain object.",
@@ -1074,8 +1708,17 @@ function validateGraphExtensionIndexWhere(raw, path, issues, strict) {
     op: raw["op"]
   });
 }
+function refuseUnstorablePropertyName(propertyName, propertyPath, owner, issues) {
+  if (!chunkLBJKZXDE_cjs.isUnstorablePropertyName(propertyName)) return false;
+  issues.push({
+    path: propertyPath,
+    message: `Property name "${propertyName}" is not allowed for ${owner}: ${chunkLBJKZXDE_cjs.UNSTORABLE_PROPERTY_NAME_REASON}.`,
+    code: "RESERVED_PROPERTY_NAME"
+  });
+  return true;
+}
 function validatePropertiesMap(raw, path, ownerType, ownerName, issues, strict) {
-  if (!chunkDI74SMXS_cjs.isPlainObject(raw)) {
+  if (!chunkN66HCGCY_cjs.isPlainObject(raw)) {
     issues.push({
       path,
       message: `\`properties\` must be a plain object.`,
@@ -1083,10 +1726,18 @@ function validatePropertiesMap(raw, path, ownerType, ownerName, issues, strict)
     });
     return void 0;
   }
-  const reserved = ownerType === "node" ? chunkD54WH24V_cjs.RESERVED_NODE_KEYS : chunkD54WH24V_cjs.RESERVED_EDGE_KEYS;
-  const result = {};
+  const reserved = ownerType === "node" ? chunkLBJKZXDE_cjs.RESERVED_NODE_KEYS : chunkLBJKZXDE_cjs.RESERVED_EDGE_KEYS;
+  const result = chunkN66HCGCY_cjs.createDataKeyedBag();
   for (const [propertyName, propertyValue] of Object.entries(raw)) {
-    const propertyPath = `${path}/${chunkTDXIBCGY_cjs.encodeJsonPointerSegment(propertyName)}`;
+    const propertyPath = `${path}/${chunkA7J2YDDI_cjs.encodeJsonPointerSegment(propertyName)}`;
+    if (refuseUnstorablePropertyName(
+      propertyName,
+      propertyPath,
+      `${ownerType} "${ownerName}"`,
+      issues
+    )) {
+      continue;
+    }
     if (reserved.has(propertyName)) {
       issues.push({
         path: propertyPath,
@@ -1113,10 +1764,10 @@ function validatePropertiesMap(raw, path, ownerType, ownerName, issues, strict)
     if (validated === void 0) continue;
     result[propertyName] = validated;
   }
-  return result;
+  return { ...result };
 }
 function validateProperty(raw, path, depth, issues, strict) {
-  if (!chunkDI74SMXS_cjs.isPlainObject(raw)) {
+  if (!chunkN66HCGCY_cjs.isPlainObject(raw)) {
     issues.push({
       path,
       message: "Property descriptor must be a plain object with a `type` field.",
@@ -1346,7 +1997,7 @@ function validateArrayProperty(raw, path, depth, issues, strict) {
     });
     return void 0;
   }
-  if (!chunkDI74SMXS_cjs.isPlainObject(itemsRaw)) {
+  if (!chunkN66HCGCY_cjs.isPlainObject(itemsRaw)) {
     issues.push({
       path: `${path}/items`,
       message: "`array.items` must be a plain property descriptor.",
@@ -1392,7 +2043,7 @@ function validateObjectProperty(raw, path, depth, issues, strict) {
     return void 0;
   }
   const propertiesRaw = raw["properties"];
-  if (!chunkDI74SMXS_cjs.isPlainObject(propertiesRaw)) {
+  if (!chunkN66HCGCY_cjs.isPlainObject(propertiesRaw)) {
     issues.push({
       path: `${path}/properties`,
       message: "`object.properties` must be a plain object.",
@@ -1409,10 +2060,13 @@ function validateObjectProperty(raw, path, depth, issues, strict) {
     });
     return void 0;
   }
-  const fields = {};
+  const fields = chunkN66HCGCY_cjs.createDataKeyedBag();
   for (const [name, value] of propertiesEntries) {
-    const fieldPath = `${path}/properties/${chunkTDXIBCGY_cjs.encodeJsonPointerSegment(name)}`;
-    if (!chunkDI74SMXS_cjs.isPlainObject(value)) {
+    const fieldPath = `${path}/properties/${chunkA7J2YDDI_cjs.encodeJsonPointerSegment(name)}`;
+    if (refuseUnstorablePropertyName(name, fieldPath, "a nested object", issues)) {
+      continue;
+    }
+    if (!chunkN66HCGCY_cjs.isPlainObject(value)) {
       issues.push({
         path: fieldPath,
         message: "Object field descriptor must be a plain object.",
@@ -1437,12 +2091,12 @@ function validateObjectProperty(raw, path, depth, issues, strict) {
   if (modifiers === void 0) return void 0;
   return finalizeProperty(
     "object",
-    { properties: fields },
+    { properties: { ...fields } },
     modifiers
   );
 }
 function finalizeProperty(type, specific, modifiers) {
-  return chunkDI74SMXS_cjs.compactUndefined({
+  return chunkN66HCGCY_cjs.compactUndefined({
     type,
     ...specific,
     optional: modifiers.optional,
@@ -1468,7 +2122,7 @@ function validatePropertyModifiers(raw, path, propertyType, issues) {
         message: `\`searchable\` is only valid on string properties (got "${propertyType}").`,
         code: "INVALID_MODIFIER_TARGET"
       });
-    } else if (chunkDI74SMXS_cjs.isPlainObject(raw["searchable"])) {
+    } else if (chunkN66HCGCY_cjs.isPlainObject(raw["searchable"])) {
       const searchableRaw = raw["searchable"];
       const language = searchableRaw["language"];
       if (language === void 0) {
@@ -1496,14 +2150,14 @@ function validatePropertyModifiers(raw, path, propertyType, issues) {
   if (raw["embedding"] !== void 0) {
     if (propertyType === "array") {
       const itemsRaw = raw["items"];
-      const itemType = chunkDI74SMXS_cjs.isPlainObject(itemsRaw) ? itemsRaw["type"] : void 0;
+      const itemType = chunkN66HCGCY_cjs.isPlainObject(itemsRaw) ? itemsRaw["type"] : void 0;
       if (itemType !== "number") {
         issues.push({
           path: `${path}/embedding`,
           message: '`embedding` requires `array.items.type === "number"`.',
           code: "INVALID_MODIFIER_TARGET"
         });
-      } else if (chunkDI74SMXS_cjs.isPlainObject(raw["embedding"])) {
+      } else if (chunkN66HCGCY_cjs.isPlainObject(raw["embedding"])) {
         const dim = raw["embedding"]["dimensions"];
         if (typeof dim !== "number" || !Number.isInteger(dim) || dim <= 0) {
           issues.push({
@@ -1512,7 +2166,7 @@ function validatePropertyModifiers(raw, path, propertyType, issues) {
             code: "INVALID_EMBEDDING_DIMENSIONS"
           });
         } else {
-          const itemsObject = chunkDI74SMXS_cjs.isPlainObject(itemsRaw) ? itemsRaw : {};
+          const itemsObject = chunkN66HCGCY_cjs.isPlainObject(itemsRaw) ? itemsRaw : {};
           const extraneous = Object.keys(itemsObject).filter(
             (key) => key !== "type"
           );
@@ -1554,7 +2208,7 @@ function validatePropertyModifiers(raw, path, propertyType, issues) {
     }
   }
   if (issues.length > issuesAtEntry) return void 0;
-  return chunkDI74SMXS_cjs.compactUndefined({
+  return chunkN66HCGCY_cjs.compactUndefined({
     optional,
     searchable,
     embedding,
@@ -1575,7 +2229,7 @@ function validateUniqueConstraints(raw, path, properties, issues, strict) {
   const names = /* @__PURE__ */ new Set();
   for (const [index, entry] of raw.entries()) {
     const constraintPath = `${path}/${index}`;
-    if (!chunkDI74SMXS_cjs.isPlainObject(entry)) {
+    if (!chunkN66HCGCY_cjs.isPlainObject(entry)) {
       issues.push({
         path: constraintPath,
         message: "Unique constraint must be a plain object.",
@@ -1643,7 +2297,7 @@ function validateUniqueConstraints(raw, path, properties, issues, strict) {
         fieldsValid = false;
         break;
       }
-      if (!(field in properties)) {
+      if (!chunkN66HCGCY_cjs.hasOwnKey(properties, field)) {
         issues.push({
           path: `${constraintPath}/fields/${fieldIndex}`,
           message: `Unique constraint field "${field}" is not declared on this kind.`,
@@ -1685,7 +2339,7 @@ function validateUniqueConstraints(raw, path, properties, issues, strict) {
     );
     if (constraint["where"] !== void 0 && where === void 0) continue;
     result.push(
-      chunkDI74SMXS_cjs.compactUndefined({
+      chunkN66HCGCY_cjs.compactUndefined({
         name,
         fields,
         scope,
@@ -1697,7 +2351,7 @@ function validateUniqueConstraints(raw, path, properties, issues, strict) {
   return result;
 }
 function validateUniqueWhere(raw, path, properties, issues, strict) {
-  if (!chunkDI74SMXS_cjs.isPlainObject(raw)) {
+  if (!chunkN66HCGCY_cjs.isPlainObject(raw)) {
     issues.push({
       path,
       message: "Unique constraint `where` must be `{ field, op }`.",
@@ -1725,7 +2379,7 @@ function validateUniqueWhere(raw, path, properties, issues, strict) {
     });
     return void 0;
   }
-  if (!(field in properties)) {
+  if (!chunkN66HCGCY_cjs.hasOwnKey(properties, field)) {
     issues.push({
       path: `${path}/field`,
       message: `Unique \`where.field\` "${field}" is not declared on this kind.`,
@@ -1745,7 +2399,7 @@ function validateUniqueWhere(raw, path, properties, issues, strict) {
 }
 function validateAnnotations(raw, path, ownerLabel, issues) {
   if (raw === void 0) return void 0;
-  if (!chunkDI74SMXS_cjs.isPlainObject(raw)) {
+  if (!chunkN66HCGCY_cjs.isPlainObject(raw)) {
     issues.push({
       path,
       message: `Annotations must be a plain JSON object.`,
@@ -1754,9 +2408,9 @@ function validateAnnotations(raw, path, ownerLabel, issues) {
     return void 0;
   }
   try {
-    chunkD54WH24V_cjs.assertJsonValue(raw, "annotations", ownerLabel);
+    chunkLBJKZXDE_cjs.assertJsonValue(raw, "annotations", ownerLabel);
   } catch (error) {
-    if (error instanceof chunkC4F7VJ5D_cjs.ConfigurationError) {
+    if (error instanceof chunkNI72YOJB_cjs.ConfigurationError) {
       const detailPath = error.details["path"];
       const annotationPath = typeof detailPath === "string" ? `${path}/${detailPath.replace(/^annotations\.?/, "").replaceAll(".", "/")}` : path;
       issues.push({
@@ -1831,14 +2485,14 @@ function describeUnknownValue(value) {
 }
 function freezeDocument(input) {
   return Object.freeze(
-    chunkDI74SMXS_cjs.compactUndefined({
+    chunkN66HCGCY_cjs.compactUndefined({
       version: input.version,
-      nodes: input.nodes === void 0 ? void 0 : chunkDI74SMXS_cjs.freezeDeep(input.nodes),
-      edges: input.edges === void 0 ? void 0 : chunkDI74SMXS_cjs.freezeDeep(input.edges),
+      nodes: input.nodes === void 0 ? void 0 : chunkN66HCGCY_cjs.freezeDeep(input.nodes),
+      edges: input.edges === void 0 ? void 0 : chunkN66HCGCY_cjs.freezeDeep(input.edges),
       ontology: input.ontology === void 0 ? void 0 : Object.freeze(
         input.ontology.map((entry) => Object.freeze({ ...entry }))
       ),
-      indexes: input.indexes === void 0 ? void 0 : Object.freeze(input.indexes.map((entry) => chunkDI74SMXS_cjs.freezeDeep({ ...entry })))
+      indexes: input.indexes === void 0 ? void 0 : Object.freeze(input.indexes.map((entry) => chunkN66HCGCY_cjs.freezeDeep({ ...entry })))
     })
   );
 }
@@ -1848,22 +2502,29 @@ exports.GRAPH_EXTENSION_ISSUE_CODES = GRAPH_EXTENSION_ISSUE_CODES;
 exports.GRAPH_EXTENSION_TOP_LEVEL_KEYS = GRAPH_EXTENSION_TOP_LEVEL_KEYS;
 exports.GraphExtensionError = GraphExtensionError;
 exports.GraphExtensionUnresolvedEndpointError = GraphExtensionUnresolvedEndpointError;
+exports.GraphExtensionUnresolvedOntologyEndpointError = GraphExtensionUnresolvedOntologyEndpointError;
 exports.GraphExtensionValidationError = GraphExtensionValidationError;
 exports.GraphExtensionVersionUnsupportedError = GraphExtensionVersionUnsupportedError;
 exports.INCOMPATIBLE_CHANGE_TYPES = INCOMPATIBLE_CHANGE_TYPES;
 exports.IncompatibleChangeError = IncompatibleChangeError;
 exports.KindCollisionError = KindCollisionError;
 exports.KindHasReferentsError = KindHasReferentsError;
+exports.KindRegistry = KindRegistry;
 exports.LEGACY_GRAPH_EXTENSION_VERSION = LEGACY_GRAPH_EXTENSION_VERSION;
 exports.RemoveCompileTimeKindError = RemoveCompileTimeKindError;
+exports.computeClosuresFromNamedOntology = computeClosuresFromNamedOntology;
+exports.computeClosuresFromOntology = computeClosuresFromOntology;
 exports.computeTransitiveClosure = computeTransitiveClosure;
+exports.createEmptyClosures = createEmptyClosures;
 exports.err = err;
 exports.invertClosure = invertClosure;
 exports.isErr = isErr;
+exports.isExternalIri = isExternalIri;
 exports.isOk = isOk;
 exports.isReachable = isReachable;
 exports.ok = ok;
 exports.unwrap = unwrap;
 exports.validateGraphExtension = validateGraphExtension;
-//# sourceMappingURL=chunk-J2ICGNHO.cjs.map
-//# sourceMappingURL=chunk-J2ICGNHO.cjs.map
+exports.validateOntologyRelations = validateOntologyRelations;
+//# sourceMappingURL=chunk-7BQXPCGN.cjs.map
+//# sourceMappingURL=chunk-7BQXPCGN.cjs.map