@nicia-ai/typegraph 0.44.0 → 0.46.0

package/dist/{chunk-IJTLXNGJ.js → chunk-T4XNKYXB.js}

@@ -1,9 +1,8 @@
-import { ALL_META_EDGE_NAMES } from './chunk-GYA4JRP5.js';
-import { assertJsonValue } from './chunk-2WDD2NO3.js';
-import { isPlainObject, compactUndefined, freezeDeep } from './chunk-ITE4IXAK.js';
-import { RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS } from './chunk-TVLKA4AY.js';
-import { TypeGraphError, ConfigurationError } from './chunk-4MB3AQAQ.js';
-import { encodeJsonPointerSegment } from './chunk-G6Q5UM7U.js';
+import { ALL_META_EDGE_NAMES, META_EDGE_DISJOINT_WITH, META_EDGE_INVERSE_OF, META_EDGE_IMPLIES, META_EDGE_HAS_PART, META_EDGE_PART_OF, META_EDGE_RELATED_TO, META_EDGE_SAME_AS, META_EDGE_EQUIVALENT_TO, META_EDGE_NARROWER, META_EDGE_BROADER, META_EDGE_SUB_CLASS_OF } from './chunk-JXXDZTMN.js';
+import { RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS, assertJsonValue, isUnstorablePropertyName, UNSTORABLE_PROPERTY_NAME_REASON } from './chunk-K5ELX2GT.js';
+import { TypeGraphError, ConfigurationError } from './chunk-J3WZ3FA2.js';
+import { encodeJsonPointerSegment } from './chunk-FWJKWH6U.js';
+import { requireDefined, isPlainObject, createDataKeyedBag, compactUndefined, hasOwnKey, freezeDeep } from './chunk-DYATYRY4.js';
 
 // src/ontology/closures.ts
 function computeTransitiveClosure(relations) {
@@ -76,6 +75,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",
@@ -196,6 +196,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;
@@ -276,6 +291,723 @@ 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 = requireDefined(parts[0]);
+      const secondKind = requireDefined(parts[1]);
+      if (firstKind === kind) result.push(secondKind);
+      else if (secondKind === kind) result.push(firstKind);
+    }
+    return result;
+  }
+  // === Composition Methods ===
+  /**
+   * Checks if part is part of whole (directly or transitively).
+   */
+  isPartOf(part, whole) {
+    return isReachable(this.partOfClosure, part, whole);
+  }
+  /**
+   * Gets all wholes that contain this part.
+   */
+  getWholes(part) {
+    const wholes = this.partOfClosure.get(part);
+    return wholes ? [...wholes] : [];
+  }
+  /**
+   * Gets all parts of this whole.
+   */
+  getParts(whole) {
+    const parts = this.hasPartClosure.get(whole);
+    return parts ? [...parts] : [];
+  }
+  // === Edge Relationship Methods ===
+  /**
+   * Gets the inverse edge kind for a given edge kind.
+   * If edgeA inverseOf edgeB, then getInverseEdge("edgeA") returns "edgeB".
+   */
+  getInverseEdge(edgeKind) {
+    return this.edgeInverses.get(edgeKind);
+  }
+  /**
+   * Gets all edges implied by a given edge (transitively).
+   * If A implies B and B implies C, then getImpliedEdges("A") returns ["B", "C"].
+   */
+  getImpliedEdges(edgeKind) {
+    const implied = this.edgeImplicationsClosure.get(edgeKind);
+    return implied ? [...implied] : [];
+  }
+  /**
+   * Gets all edges that imply a given edge (transitively).
+   * If A implies B and B implies C, then getImplyingEdges("C") returns ["A", "B"].
+   * Used for query-time expansion: when querying for C, also include A and B edges.
+   */
+  getImplyingEdges(edgeKind) {
+    const implying = this.edgeImplyingClosure.get(edgeKind);
+    return implying ? [...implying] : [];
+  }
+  /**
+   * Expands an edge kind to include all edges that imply it.
+   * Returns [edgeKind, ...implyingEdges].
+   */
+  expandImplyingEdges(edgeKind) {
+    const implying = this.edgeImplyingClosure.get(edgeKind) ?? /* @__PURE__ */ new Set();
+    return [edgeKind, ...implying];
+  }
+  // === Edge Endpoint Validation ===
+  /**
+   * Checks if a concrete kind is assignable to a target kind.
+   * Uses subsumption: Company is assignable to Organization if Company subClassOf Organization.
+   */
+  isAssignableTo(concreteKind, targetKind) {
+    if (concreteKind === targetKind) return true;
+    return this.isSubClassOf(concreteKind, targetKind);
+  }
+  /**
+   * Checks if a concrete kind is assignable to at least one of the given
+   * target kinds. Shared by every "is this kind usable where one of these
+   * kinds is expected" check (edge endpoint validation, ontology relation
+   * endpoint compatibility) so they can't independently drift.
+   */
+  isAssignableToAny(concreteKind, targetKinds) {
+    return targetKinds.some(
+      (targetKind) => this.isAssignableTo(concreteKind, targetKind)
+    );
+  }
+  /**
+   * Validates that a kind exists in the registry.
+   */
+  hasNodeType(name) {
+    return this.nodeKinds.has(name);
+  }
+  /**
+   * Validates that an edge kind exists in the registry.
+   */
+  hasEdgeType(name) {
+    return this.edgeKinds.has(name);
+  }
+  /**
+   * Gets a node kind by name.
+   */
+  getNodeType(name) {
+    return this.nodeKinds.get(name);
+  }
+  /**
+   * Gets an edge kind by name.
+   */
+  getEdgeType(name) {
+    return this.edgeKinds.get(name);
+  }
+};
+function createEmptyClosures() {
+  return {
+    subClassAncestors: /* @__PURE__ */ new Map(),
+    subClassDescendants: /* @__PURE__ */ new Map(),
+    broaderClosure: /* @__PURE__ */ new Map(),
+    narrowerClosure: /* @__PURE__ */ new Map(),
+    equivalenceSets: /* @__PURE__ */ new Map(),
+    iriToKind: /* @__PURE__ */ new Map(),
+    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 META_EDGE_SUB_CLASS_OF: {
+        subClass.push([fromName, toName]);
+        break;
+      }
+      case META_EDGE_BROADER: {
+        broader.push([fromName, toName]);
+        break;
+      }
+      case META_EDGE_NARROWER: {
+        broader.push([toName, fromName]);
+        break;
+      }
+      case META_EDGE_EQUIVALENT_TO:
+      case META_EDGE_SAME_AS: {
+        equivalent.push([fromName, toName]);
+        break;
+      }
+      case META_EDGE_RELATED_TO: {
+        related.push([fromName, toName]);
+        break;
+      }
+      case META_EDGE_DISJOINT_WITH: {
+        disjoint.push([fromName, toName]);
+        break;
+      }
+      case META_EDGE_PART_OF: {
+        partOf.push([fromName, toName]);
+        break;
+      }
+      case META_EDGE_HAS_PART: {
+        partOf.push([toName, fromName]);
+        break;
+      }
+      case META_EDGE_INVERSE_OF: {
+        inverseOf.push([fromName, toName]);
+        break;
+      }
+      case 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 (requireDefined(parent.get(root)) !== root) {
+      root = requireDefined(parent.get(root));
+    }
+    let cursor = x;
+    while (cursor !== root) {
+      const next = 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 = requireDefined(size.get(rootA));
+    const sizeB = 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 = 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([
+  META_EDGE_SUB_CLASS_OF,
+  META_EDGE_BROADER,
+  META_EDGE_NARROWER,
+  META_EDGE_PART_OF,
+  META_EDGE_HAS_PART
+]);
+var HIERARCHICAL_NORMALIZATION = /* @__PURE__ */ new Map([
+  [META_EDGE_SUB_CLASS_OF, { canonical: META_EDGE_SUB_CLASS_OF, flip: false }],
+  [META_EDGE_BROADER, { canonical: META_EDGE_BROADER, flip: false }],
+  [META_EDGE_NARROWER, { canonical: META_EDGE_BROADER, flip: true }],
+  [META_EDGE_PART_OF, { canonical: META_EDGE_PART_OF, flip: false }],
+  [META_EDGE_HAS_PART, { canonical: 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 === 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 !== 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 !== 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(ALL_META_EDGE_NAMES);
 var SUPPORTED_PROPERTY_TYPES = /* @__PURE__ */ new Set([
@@ -412,7 +1144,7 @@ function validateGraphExtension(input, options = {}) {
     strict
   );
   if (ontology !== void 0) {
-    validateOntology(ontology, nodes, issues);
+    validateOntology(ontology, issues);
   }
   const indexes = validateIndexesSection(
     documentRecord["indexes"],
@@ -452,7 +1184,7 @@ function validateNodesSection(rawNodes, issues, strict) {
     });
     return void 0;
   }
-  const result = {};
+  const result = createDataKeyedBag();
   const recorded = /* @__PURE__ */ new Set();
   for (const [kindName, rawNode] of Object.entries(rawNodes)) {
     const path = `/nodes/${encodeJsonPointerSegment(kindName)}`;
@@ -477,7 +1209,7 @@ function validateNodesSection(rawNodes, issues, strict) {
     result[kindName] = node;
     recorded.add(kindName);
   }
-  return result;
+  return { ...result };
 }
 function validateNodeDocument(kindName, raw, path, issues, strict) {
   if (!isPlainObject(raw)) {
@@ -546,7 +1278,7 @@ function validateEdgesSection(rawEdges, issues, strict) {
     });
     return void 0;
   }
-  const result = {};
+  const result = createDataKeyedBag();
   const recorded = /* @__PURE__ */ new Set();
   for (const [kindName, rawEdge] of Object.entries(rawEdges)) {
     const path = `/edges/${encodeJsonPointerSegment(kindName)}`;
@@ -571,7 +1303,7 @@ function validateEdgesSection(rawEdges, issues, strict) {
     result[kindName] = edge;
     recorded.add(kindName);
   }
-  return result;
+  return { ...result };
 }
 function validateEdgeDocument(kindName, raw, path, issues, strict) {
   if (!isPlainObject(raw)) {
@@ -719,113 +1451,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"];
@@ -1073,6 +1706,15 @@ function validateGraphExtensionIndexWhere(raw, path, issues, strict) {
     op: raw["op"]
   });
 }
+function refuseUnstorablePropertyName(propertyName, propertyPath, owner, issues) {
+  if (!isUnstorablePropertyName(propertyName)) return false;
+  issues.push({
+    path: propertyPath,
+    message: `Property name "${propertyName}" is not allowed for ${owner}: ${UNSTORABLE_PROPERTY_NAME_REASON}.`,
+    code: "RESERVED_PROPERTY_NAME"
+  });
+  return true;
+}
 function validatePropertiesMap(raw, path, ownerType, ownerName, issues, strict) {
   if (!isPlainObject(raw)) {
     issues.push({
@@ -1083,9 +1725,17 @@ function validatePropertiesMap(raw, path, ownerType, ownerName, issues, strict)
     return void 0;
   }
   const reserved = ownerType === "node" ? RESERVED_NODE_KEYS : RESERVED_EDGE_KEYS;
-  const result = {};
+  const result = createDataKeyedBag();
   for (const [propertyName, propertyValue] of Object.entries(raw)) {
     const propertyPath = `${path}/${encodeJsonPointerSegment(propertyName)}`;
+    if (refuseUnstorablePropertyName(
+      propertyName,
+      propertyPath,
+      `${ownerType} "${ownerName}"`,
+      issues
+    )) {
+      continue;
+    }
     if (reserved.has(propertyName)) {
       issues.push({
         path: propertyPath,
@@ -1112,7 +1762,7 @@ 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 (!isPlainObject(raw)) {
@@ -1408,9 +2058,12 @@ function validateObjectProperty(raw, path, depth, issues, strict) {
     });
     return void 0;
   }
-  const fields = {};
+  const fields = createDataKeyedBag();
   for (const [name, value] of propertiesEntries) {
     const fieldPath = `${path}/properties/${encodeJsonPointerSegment(name)}`;
+    if (refuseUnstorablePropertyName(name, fieldPath, "a nested object", issues)) {
+      continue;
+    }
     if (!isPlainObject(value)) {
       issues.push({
         path: fieldPath,
@@ -1436,7 +2089,7 @@ function validateObjectProperty(raw, path, depth, issues, strict) {
   if (modifiers === void 0) return void 0;
   return finalizeProperty(
     "object",
-    { properties: fields },
+    { properties: { ...fields } },
     modifiers
   );
 }
@@ -1642,7 +2295,7 @@ function validateUniqueConstraints(raw, path, properties, issues, strict) {
         fieldsValid = false;
         break;
       }
-      if (!(field in properties)) {
+      if (!hasOwnKey(properties, field)) {
         issues.push({
           path: `${constraintPath}/fields/${fieldIndex}`,
           message: `Unique constraint field "${field}" is not declared on this kind.`,
@@ -1724,7 +2377,7 @@ function validateUniqueWhere(raw, path, properties, issues, strict) {
     });
     return void 0;
   }
-  if (!(field in properties)) {
+  if (!hasOwnKey(properties, field)) {
     issues.push({
       path: `${path}/field`,
       message: `Unique \`where.field\` "${field}" is not declared on this kind.`,
@@ -1842,6 +2495,6 @@ function freezeDocument(input) {
   );
 }
 
-export { CURRENT_GRAPH_EXTENSION_VERSION, GRAPH_EXTENSION_ISSUE_CODES, GRAPH_EXTENSION_TOP_LEVEL_KEYS, GraphExtensionError, GraphExtensionUnresolvedEndpointError, GraphExtensionValidationError, GraphExtensionVersionUnsupportedError, INCOMPATIBLE_CHANGE_TYPES, IncompatibleChangeError, KindCollisionError, KindHasReferentsError, LEGACY_GRAPH_EXTENSION_VERSION, RemoveCompileTimeKindError, computeTransitiveClosure, err, invertClosure, isErr, isOk, isReachable, ok, unwrap, validateGraphExtension };
-//# sourceMappingURL=chunk-IJTLXNGJ.js.map
-//# sourceMappingURL=chunk-IJTLXNGJ.js.map
+export { CURRENT_GRAPH_EXTENSION_VERSION, GRAPH_EXTENSION_ISSUE_CODES, GRAPH_EXTENSION_TOP_LEVEL_KEYS, GraphExtensionError, GraphExtensionUnresolvedEndpointError, GraphExtensionUnresolvedOntologyEndpointError, GraphExtensionValidationError, GraphExtensionVersionUnsupportedError, INCOMPATIBLE_CHANGE_TYPES, IncompatibleChangeError, KindCollisionError, KindHasReferentsError, KindRegistry, LEGACY_GRAPH_EXTENSION_VERSION, RemoveCompileTimeKindError, computeClosuresFromNamedOntology, computeClosuresFromOntology, computeTransitiveClosure, createEmptyClosures, err, invertClosure, isErr, isExternalIri, isOk, isReachable, ok, unwrap, validateGraphExtension, validateOntologyRelations };
+//# sourceMappingURL=chunk-T4XNKYXB.js.map
+//# sourceMappingURL=chunk-T4XNKYXB.js.map