{"version":3,"sources":["../src/ontology/closures.ts","../src/graph-extension/errors.ts","../src/utils/result.ts","../src/graph-extension/extension-types.ts","../src/ontology/external-iri.ts","../src/registry/kind-registry.ts","../src/ontology/validation.ts","../src/graph-extension/validation.ts"],"names":["index","TypeGraphError","first","second","requireDefined","compareStrings","META_EDGE_SUB_CLASS_OF","META_EDGE_BROADER","META_EDGE_NARROWER","META_EDGE_EQUIVALENT_TO","META_EDGE_SAME_AS","META_EDGE_RELATED_TO","META_EDGE_DISJOINT_WITH","META_EDGE_PART_OF","META_EDGE_HAS_PART","META_EDGE_INVERSE_OF","META_EDGE_IMPLIES","ALL_META_EDGE_NAMES","encodeJsonPointerSegment","isPlainObject","createDataKeyedBag","compactUndefined","isUnstorablePropertyName","UNSTORABLE_PROPERTY_NAME_REASON","RESERVED_NODE_KEYS","RESERVED_EDGE_KEYS","hasOwnKey","assertJsonValue","ConfigurationError","cloneAndFreezeGraphAnnotations","freezeDeep"],"mappings":"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","file":"chunk-HQU2SE74.cjs","sourcesContent":["/**\n * Transitive closure computation for ontology relationships.\n *\n * Uses Warshall's algorithm for efficient closure computation.\n */\n\n/**\n * Computes the transitive closure of a set of directed relations.\n *\n * Given relations like [A→B, B→C], computes all transitive paths [A→B, A→C, B→C].\n *\n * @param relations - Array of [from, to] pairs representing direct relationships\n * @returns Map from each 'from' to the set of all reachable 'to' values\n */\nexport function computeTransitiveClosure(\n  relations: readonly (readonly [string, string])[],\n): ReadonlyMap<string, ReadonlySet<string>> {\n  // Build mutable map for computation\n  const closure = new Map<string, Set<string>>();\n\n  // Collect all nodes\n  const allNodes = new Set<string>();\n  for (const [from, to] of relations) {\n    allNodes.add(from);\n    allNodes.add(to);\n  }\n\n  // Initialize empty sets for all nodes\n  for (const node of allNodes) {\n    closure.set(node, new Set());\n  }\n\n  // Add direct relationships\n  for (const [from, to] of relations) {\n    closure.get(from)?.add(to);\n  }\n\n  // Warshall's algorithm for transitive closure\n  // For each intermediate node k, check if i→k and k→j implies i→j\n  for (const k of allNodes) {\n    for (const index of allNodes) {\n      const indexReaches = closure.get(index);\n      if (!indexReaches?.has(k)) continue;\n\n      const kReaches = closure.get(k);\n      if (!kReaches) continue;\n\n      for (const index of kReaches) {\n        indexReaches.add(index);\n      }\n    }\n  }\n\n  return closure;\n}\n\n/**\n * Computes the inverse of a transitive closure map.\n *\n * Given A→{B, C}, returns B→{A}, C→{A}.\n */\nexport function invertClosure(\n  closure: ReadonlyMap<string, ReadonlySet<string>>,\n): ReadonlyMap<string, ReadonlySet<string>> {\n  const result = new Map<string, Set<string>>();\n\n  for (const [from, tos] of closure) {\n    for (const to of tos) {\n      const existing = result.get(to) ?? new Set();\n      existing.add(from);\n      result.set(to, existing);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Checks if there's a path from source to target in the closure.\n */\nexport function isReachable(\n  closure: ReadonlyMap<string, ReadonlySet<string>>,\n  source: string,\n  target: string,\n): boolean {\n  return closure.get(source)?.has(target) ?? false;\n}\n","/**\n * Errors raised across the graph-extension surface.\n *\n * Two flavours:\n *\n * - **Validation issues** (`GraphExtensionValidationError` +\n *   `GraphExtensionIssue` / `GraphExtensionIssueCode`) — produced by\n *   `validateGraphExtension`. The issue list batches every failure\n *   with a JSON-pointer `path` so a UI can highlight every offending\n *   field at once.\n * - **Operation errors** (every other class in this file, all extending\n *   `GraphExtensionError`) — thrown one at a time from `evolve`,\n *   `removeKinds`, `materializeIndexes`, search, etc. Each carries a\n *   stable string `code` for logging / serialization PLUS a typed\n *   shape so consumers can `instanceof` for control flow.\n */\nimport type { KindEntity } from \"../core/types\";\nimport { type ErrorCategory, TypeGraphError } from \"../errors\";\n\n// ============================================================\n// Validation issues (multi-issue batch)\n// ============================================================\n\n/**\n * One specific issue raised during graph-extension validation.\n */\nexport type GraphExtensionIssue = Readonly<{\n  /**\n   * JSON-pointer path to the offending value, rooted at the document\n   * (e.g. `/nodes/Paper/properties/title/pattern`). The empty string\n   * `\"\"` means \"the document itself\".\n   */\n  path: string;\n  /** Human-readable explanation of the failure. */\n  message: string;\n  /**\n   * Stable machine-readable code so callers (and tests) can branch on\n   * specific failure modes without parsing messages. New codes are\n   * additive.\n   */\n  code: GraphExtensionIssueCode;\n}>;\n\n/**\n * Stable machine codes for every validation failure produced by the\n * document validator. New codes are additive — existing codes never\n * change meaning.\n *\n * Note: codes here describe per-field validation problems. Operation-\n * level errors (kind not found, version mismatch on persisted doc,\n * compile-time-kind removal, etc.) surface as typed Error subclasses\n * exported below — not as issue codes.\n */\n/**\n * Every issue code emitted by `validateGraphExtension`. Const-array form\n * so tests, codegen, and runtime introspection can iterate the full set\n * without restating it.\n */\nexport const GRAPH_EXTENSION_ISSUE_CODES = [\n  \"UNSUPPORTED_PROPERTY_TYPE\",\n  \"INVALID_PROPERTY_REFINEMENT\",\n  \"NESTED_ARRAY\",\n  \"NESTED_OBJECT_TOO_DEEP\",\n  \"INVALID_MODIFIER_TARGET\",\n  \"INVALID_ENUM_VALUES\",\n  \"INVALID_NUMBER_BOUNDS\",\n  \"INVALID_LENGTH_BOUNDS\",\n  \"INVALID_PATTERN\",\n  \"INVALID_EMBEDDING_DIMENSIONS\",\n  \"INVALID_SEARCHABLE_LANGUAGE\",\n  \"RESERVED_PROPERTY_NAME\",\n  \"INVALID_KIND_NAME\",\n  \"DUPLICATE_KIND_NAME\",\n  \"EMPTY_PROPERTIES\",\n  \"EMPTY_FROM_OR_TO\",\n  \"DUPLICATE_UNIQUE_CONSTRAINT\",\n  \"EMPTY_UNIQUE_FIELDS\",\n  \"DUPLICATE_UNIQUE_FIELD\",\n  \"UNKNOWN_UNIQUE_FIELD\",\n  \"INVALID_UNIQUE_WHERE_OP\",\n  \"UNKNOWN_UNIQUE_WHERE_FIELD\",\n  \"INVALID_ANNOTATION\",\n  \"UNKNOWN_META_EDGE\",\n  \"ONTOLOGY_CYCLE\",\n  \"ONTOLOGY_SELF_LOOP\",\n  \"ONTOLOGY_DISJOINT_CONFLICT\",\n  \"ONTOLOGY_INVERSE_MULTIPLE_PARTNERS\",\n  \"DUPLICATE_ONTOLOGY_RELATION\",\n  \"INVALID_DOCUMENT_SHAPE\",\n  \"UNKNOWN_DOCUMENT_KEY\",\n  \"UNSUPPORTED_STRING_FORMAT\",\n  \"INVALID_INDEX_DECLARATION\",\n  \"DUPLICATE_INDEX_NAME\",\n  \"EMPTY_INDEX_FIELDS\",\n  \"UNKNOWN_PROPERTY_KEY\",\n] as const;\n\nexport type GraphExtensionIssueCode =\n  (typeof GRAPH_EXTENSION_ISSUE_CODES)[number];\n\n// ============================================================\n// Operation errors (typed, single-error throws)\n// ============================================================\n\n/**\n * Base class for every graph-extension error. Consumers can catch\n * the family with one `instanceof GraphExtensionError` check and\n * branch on the concrete subclass beneath. Carries the same\n * `code` / `category` / `details` slots as `TypeGraphError` so existing\n * `isTypeGraphError` / `isUserRecoverable` helpers continue to apply.\n */\nexport abstract class GraphExtensionError extends TypeGraphError {\n  // The concrete `code` is set as a literal-typed property on each\n  // subclass so consumers can branch on it with full type narrowing.\n  declare readonly code: string;\n\n  protected constructor(spec: {\n    message: string;\n    code: string;\n    details: Readonly<Record<string, unknown>>;\n    suggestion: string;\n    category?: ErrorCategory;\n    cause?: unknown;\n  }) {\n    super(spec.message, spec.code, {\n      details: spec.details,\n      category: spec.category ?? \"user\",\n      suggestion: spec.suggestion,\n      ...(spec.cause === undefined ? {} : { cause: spec.cause }),\n    });\n    // `new.target.name` resolves to the concrete subclass at construction\n    // time, eliminating per-subclass `this.name = \"ClassName\"` repetition.\n    this.name = new.target.name;\n  }\n}\n\n/**\n * Thrown when `validateGraphExtension` (or `defineGraphExtension`)\n * rejects an input document for one or more shape/content reasons.\n *\n * The `issues` array carries every failure with a JSON-pointer\n * `path`, so callers presenting the document to a human reviewer can\n * highlight every offending field at once.\n */\nexport class GraphExtensionValidationError extends GraphExtensionError {\n  override readonly code = \"GRAPH_EXTENSION_INVALID\" as const;\n  readonly issues: readonly GraphExtensionIssue[];\n  declare readonly details: Readonly<{\n    issues: readonly GraphExtensionIssue[];\n  }>;\n\n  constructor(issues: readonly GraphExtensionIssue[], cause?: unknown) {\n    const frozenIssues = Object.freeze([...issues]);\n    super({\n      message: `Graph extension document is invalid (${issues.length} issue${\n        issues.length === 1 ? \"\" : \"s\"\n      }): ${summarizeIssues(issues)}`,\n      code: \"GRAPH_EXTENSION_INVALID\",\n      details: { issues: frozenIssues },\n      suggestion: `Inspect error.issues for per-field paths and codes; each issue's \"path\" is a JSON pointer into the source document.`,\n      cause,\n    });\n    this.issues = frozenIssues;\n  }\n}\n\n/**\n * Generic \"first N items + overflow tail\" summary for inclusion in an\n * Error message. Shared by `summarizeIssues` and `summarizeChanges`\n * because the overflow shape is identical; only the per-item\n * formatting differs.\n */\nfunction summarizeWithOverflow<T>(\n  items: readonly T[],\n  formatItem: (item: T) => string,\n  emptyMessage: string,\n): string {\n  if (items.length === 0) return emptyMessage;\n  const head = items\n    .slice(0, 3)\n    .map((item) => formatItem(item))\n    .join(\"; \");\n  const overflow = items.length > 3 ? ` (+${items.length - 3} more)` : \"\";\n  return `${head}${overflow}`;\n}\n\nfunction summarizeIssues(issues: readonly GraphExtensionIssue[]): string {\n  return summarizeWithOverflow(\n    issues,\n    (issue) => `${issue.path || \"(root)\"} — ${issue.message}`,\n    \"no specific issues recorded\",\n  );\n}\n\n/**\n * Thrown when an extension declares a kind whose name collides with an\n * existing compile-time kind. The graph-extension contract is\n * additive: graph-extension-declared kinds cannot shadow compile-time kinds.\n */\nexport class KindCollisionError extends GraphExtensionError {\n  override readonly code = \"KIND_COLLISION\" as const;\n  readonly kindName: string;\n  readonly entity: KindEntity;\n\n  constructor(kindName: string, entity: KindEntity, graphId: string) {\n    super({\n      message: `Graph extension declares ${entity} kind \"${kindName}\" which already exists as a compile-time kind on graph \"${graphId}\". Graph-extension-declared kinds cannot collide with compile-time kinds.`,\n      code: \"KIND_COLLISION\",\n      details: { kindName, entity, graphId },\n      suggestion:\n        \"Pick a different graph-extension-declared kind name, or remove the compile-time declaration.\",\n    });\n    this.kindName = kindName;\n    this.entity = entity;\n  }\n}\n\n/**\n * One classified delta in a `IncompatibleChangeError`.\n *\n * `field` is `undefined` for kind-level changes (e.g. tightening edge\n * endpoints, adding a unique constraint to a populated kind). `detail`\n * is human-readable and intended for surfaces showing the change to a\n * reviewer (e.g. `\"minLength: 5 → 10\"`).\n */\n/**\n * Every incompatible-change classification produced by `evolve`'s\n * delta classifier. Const-array form so tests and reviewer UIs can\n * enumerate the set without restating it.\n */\nexport const INCOMPATIBLE_CHANGE_TYPES = [\n  \"REMOVE_PROPERTY\",\n  \"ADD_REQUIRED_PROPERTY\",\n  \"TIGHTEN_OPTIONALITY\",\n  \"TIGHTEN_CONSTRAINT\",\n  \"ADD_PATTERN\",\n  \"CHANGE_PATTERN\",\n  \"ADD_FORMAT\",\n  \"CHANGE_FORMAT\",\n  \"TIGHTEN_INT\",\n  \"TIGHTEN_ENUM\",\n  \"TYPE_CHANGE\",\n  \"ADD_UNIQUE_ON_POPULATED\",\n  \"TIGHTEN_EDGE_ENDPOINTS\",\n] as const;\n\nexport type IncompatibleChangeType = (typeof INCOMPATIBLE_CHANGE_TYPES)[number];\n\nexport type IncompatibleChange = Readonly<{\n  kind: string;\n  field?: string;\n  type: IncompatibleChangeType;\n  detail?: string;\n}>;\n\n/**\n * Thrown when `evolve` rejects one or more deltas against an existing\n * extension kind. Carries a structured `changes` list so a reviewer\n * UI can show the incompatible deltas across every affected kind in\n * one shot.\n */\nexport class IncompatibleChangeError extends GraphExtensionError {\n  override readonly code = \"INCOMPATIBLE_CHANGE\" as const;\n  readonly changes: readonly IncompatibleChange[];\n\n  constructor(changes: readonly IncompatibleChange[], graphId: string) {\n    const frozenChanges = Object.freeze([...changes]);\n    super({\n      message: `Graph extension contains ${changes.length} incompatible change${\n        changes.length === 1 ? \"\" : \"s\"\n      } against existing graph-extension kinds on graph \"${graphId}\": ${summarizeChanges(changes)}`,\n      code: \"INCOMPATIBLE_CHANGE\",\n      details: { graphId, changes: frozenChanges },\n      suggestion:\n        \"Inspect error.changes for the per-field rejections. Compatible options: change the modification to an additive one (e.g. `optional: true`), or apply the change against an empty kind.\",\n    });\n    this.changes = frozenChanges;\n  }\n}\n\nfunction summarizeChanges(changes: readonly IncompatibleChange[]): string {\n  return summarizeWithOverflow(\n    changes,\n    (change) => {\n      const field = change.field === undefined ? \"\" : `.${change.field}`;\n      const detail = change.detail === undefined ? \"\" : ` (${change.detail})`;\n      return `${change.kind}${field}: ${change.type}${detail}`;\n    },\n    \"(no specific changes recorded)\",\n  );\n}\n\n/**\n * Thrown when an extension's edge or ontology endpoint references a\n * kind that exists in neither the extension nor the host graph.\n * Distinct from `KindNotFoundError` because the cause is a\n * stale persisted extension (a compile-time kind was removed from\n * source after the extension was committed) rather than a\n * call-site typo.\n */\nexport class GraphExtensionUnresolvedEndpointError extends GraphExtensionError {\n  override readonly code = \"GRAPH_EXTENSION_UNRESOLVED_ENDPOINT\" as const;\n  readonly edgeKind: string;\n  readonly side: \"from\" | \"to\";\n  readonly endpoint: string;\n\n  constructor(\n    edgeKind: string,\n    side: \"from\" | \"to\",\n    endpoint: string,\n    graphId: string,\n  ) {\n    super({\n      message: `Graph-extension edge \"${edgeKind}\" ${side}-endpoint \"${endpoint}\" does not resolve to any kind on graph \"${graphId}\". The compile-time kind may have been removed since the extension was committed.`,\n      code: \"GRAPH_EXTENSION_UNRESOLVED_ENDPOINT\",\n      details: { edgeKind, side, endpoint, graphId },\n      suggestion:\n        \"Restore the compile-time kind, or remove the graph-extension-declared kind via store.removeKinds before redeploying without it.\",\n    });\n    this.edgeKind = edgeKind;\n    this.side = side;\n    this.endpoint = endpoint;\n  }\n}\n\n/**\n * Thrown when `inverseOf` or `implies` uses an unresolved bare edge-kind\n * name. Absolute HTTP(S) IRIs remain deliberate inert external references.\n */\nexport class GraphExtensionUnresolvedOntologyEndpointError extends GraphExtensionError {\n  override readonly code =\n    \"GRAPH_EXTENSION_UNRESOLVED_ONTOLOGY_ENDPOINT\" as const;\n  readonly metaEdge: \"inverseOf\" | \"implies\";\n  readonly endpoint: string;\n\n  constructor(\n    metaEdge: \"inverseOf\" | \"implies\",\n    endpoint: string,\n    graphId: string,\n  ) {\n    super({\n      message: `Graph-extension ${metaEdge} endpoint \"${endpoint}\" does not resolve to a registered edge kind on graph \"${graphId}\".`,\n      code: \"GRAPH_EXTENSION_UNRESOLVED_ONTOLOGY_ENDPOINT\",\n      details: { metaEdge, endpoint, graphId },\n      suggestion:\n        \"Correct the local edge-kind name, register that edge, or use an absolute http:// or https:// IRI for a deliberate inert external reference.\",\n    });\n    this.metaEdge = metaEdge;\n    this.endpoint = endpoint;\n  }\n}\n\n/**\n * Thrown by `removeKinds` when the removal list contains a compile-\n * time kind. Compile-time kinds are removed by recompiling and\n * redeploying — persisting \"removed-compile-time-kind\" state in\n * `schema_doc` is incoherent because the kind would resurrect on the\n * next deploy.\n */\nexport class RemoveCompileTimeKindError extends GraphExtensionError {\n  override readonly code = \"REMOVE_COMPILE_TIME_KIND\" as const;\n  readonly kindName: string;\n  readonly entity: KindEntity;\n\n  constructor(kindName: string, entity: KindEntity, graphId: string) {\n    super({\n      message: `Cannot remove compile-time ${entity} kind \"${kindName}\" via store.removeKinds. Compile-time kinds are removed by recompiling and redeploying without them on graph \"${graphId}\".`,\n      code: \"REMOVE_COMPILE_TIME_KIND\",\n      details: { kindName, entity, graphId },\n      suggestion:\n        \"Drop the kind from your defineGraph call and redeploy. Only graph-extension kinds (added via store.evolve) are removable through removeKinds.\",\n    });\n    this.kindName = kindName;\n    this.entity = entity;\n  }\n}\n\n/**\n * Thrown by `removeKinds` when a compile-time edge or ontology\n * relation references the graph-extension kind being removed. Removing the\n * kind would orphan compile-time references — incoherent at the next\n * deploy.\n */\nexport class KindHasReferentsError extends GraphExtensionError {\n  override readonly code = \"KIND_HAS_REFERENTS\" as const;\n  readonly kindName: string;\n  readonly referents: readonly KindReferent[];\n\n  constructor(\n    kindName: string,\n    referents: readonly KindReferent[],\n    graphId: string,\n  ) {\n    const summary = referents\n      .map((referent) => `${referent.type}:${referent.name}`)\n      .join(\", \");\n    const frozenReferents = Object.freeze([...referents]);\n    super({\n      message: `Cannot remove graph-extension kind \"${kindName}\" on graph \"${graphId}\" — it is referenced by compile-time declarations: ${summary}.`,\n      code: \"KIND_HAS_REFERENTS\",\n      details: { kindName, graphId, referents: frozenReferents },\n      suggestion:\n        \"Remove the compile-time references first (drop the edge or ontology relation from defineGraph), or pick a different kind to remove.\",\n    });\n    this.kindName = kindName;\n    this.referents = frozenReferents;\n  }\n}\n\nexport type KindReferent = Readonly<{\n  type: \"compile-time-edge\" | \"compile-time-ontology\";\n  name: string;\n}>;\n\n/**\n * Thrown when a persisted graph extension was authored against a\n * higher major version of the graph-extension format than the\n * current library supports. The library refuses to load it rather\n * than risk silently misreading newer fields.\n */\nexport class GraphExtensionVersionUnsupportedError extends GraphExtensionError {\n  override readonly code = \"GRAPH_EXTENSION_VERSION_UNSUPPORTED\" as const;\n  readonly persistedVersion: number;\n  readonly currentVersion: number;\n\n  constructor(persistedVersion: number, currentVersion: number) {\n    super({\n      message: `Persisted extension was authored against graph-extension format v${persistedVersion}, but this library only supports up to v${currentVersion}. Upgrade @nicia-ai/typegraph.`,\n      code: \"GRAPH_EXTENSION_VERSION_UNSUPPORTED\",\n      details: { persistedVersion, currentVersion },\n      category: \"system\",\n      suggestion: `Upgrade @nicia-ai/typegraph to a version that supports graph-extension format v${persistedVersion}, or downgrade the writer.`,\n    });\n    this.persistedVersion = persistedVersion;\n    this.currentVersion = currentVersion;\n  }\n}\n","/**\n * Result type for error handling without exceptions.\n * Use at service boundaries and for operations that can fail.\n */\nexport type Result<T, E = Error> =\n  Readonly<{ success: true; data: T }> | Readonly<{ success: false; error: E }>;\n\n/**\n * Creates a successful result.\n */\nexport function ok<T = undefined>(data?: T): Result<T, never> {\n  return { success: true, data: data as T };\n}\n\n/**\n * Creates a failed result.\n */\nexport function err<E>(error: E): Result<never, E> {\n  return { success: false, error };\n}\n\n/**\n * Unwraps a result, throwing if it's an error.\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n  if (result.success) {\n    return result.data;\n  }\n  throw result.error;\n}\n\n/**\n * Unwraps a result or returns a default value.\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n  if (result.success) {\n    return result.data;\n  }\n  return defaultValue;\n}\n\n/**\n * Type guard to check if result is successful.\n *\n * Narrows to the `Readonly<{...}>` success arm so that an early-return on the\n * negative branch (`if (isErr(x)) return; x.data`) leaves the success arm\n * reachable — the union members are themselves `Readonly`, so a mutable\n * predicate target would subtract nothing and break narrowing for callers.\n */\nexport function isOk<T, E>(\n  result: Result<T, E>,\n): result is Readonly<{ success: true; data: T }> {\n  return result.success;\n}\n\n/**\n * Type guard to check if result is an error. See {@link isOk} for why the\n * predicate narrows to the `Readonly<{...}>` arm.\n */\nexport function isErr<T, E>(\n  result: Result<T, E>,\n): result is Readonly<{ success: false; error: E }> {\n  return !result.success;\n}\n\n/**\n * Transforms the success value of a result.\n */\nexport function map<T, U, E>(\n  result: Result<T, E>,\n  fn: (data: T) => U,\n): Result<U, E> {\n  if (result.success) return ok(fn(result.data));\n  return result;\n}\n\n/**\n * Transforms the error value of a result.\n */\nexport function mapErr<T, E, F>(\n  result: Result<T, E>,\n  fn: (error: E) => F,\n): Result<T, F> {\n  if (result.success) return result;\n  return err(fn(result.error));\n}\n\n/**\n * Chains an operation that returns a Result on the success value.\n */\nexport function flatMap<T, U, E>(\n  result: Result<T, E>,\n  fn: (data: T) => Result<U, E>,\n): Result<U, E> {\n  if (result.success) return fn(result.data);\n  return result;\n}\n\n/**\n * Recovers from an error by producing an alternative Result.\n */\nexport function orElse<T, E, F>(\n  result: Result<T, E>,\n  fn: (error: E) => Result<T, F>,\n): Result<T, F> {\n  if (result.success) return result;\n  return fn(result.error);\n}\n","/**\n * Pure-value document format for graph extensions.\n *\n * A `GraphExtension` is a plain JSON-serializable description of\n * additional node kinds, edge kinds, and ontology relations that should\n * be merged into a graph at runtime. The document is the canonical\n * artifact: every restart re-compiles it back to the same Zod-bearing\n * `NodeType` / `EdgeType` / `OntologyRelation` shapes.\n *\n * The supported property-type subset is intentionally narrower than full\n * JSON Schema — only what compiles cleanly to Zod and what real\n * agent-induced schemas use in practice. Anything outside this set fails\n * loudly at `defineGraphExtension(...)`.\n */\nimport { type z } from \"zod\";\n\nimport {\n  type GraphAnnotations,\n  type KindAnnotations,\n  type NullCheckOp,\n} from \"../core/types\";\nimport { type MetaEdgeName } from \"../ontology/constants\";\n\n// ============================================================\n// Property Types\n// ============================================================\n\n/**\n * Per-property modifier: tag the field as fulltext-searchable.\n *\n * Compiles to a `searchable({ language })`-wrapped Zod string when applied\n * to a `string` property. Rejected on any other property type at validation\n * time.\n */\nexport type ExtensionSearchableModifier = Readonly<{\n  language?: string;\n}>;\n\n/**\n * Per-property modifier: declare a vector embedding with the given\n * dimensionality. Compiles to `embedding(dimensions)` and is only valid on\n * `array` properties whose item type is `number`. Rejected elsewhere.\n */\nexport type ExtensionEmbeddingModifier = Readonly<{\n  dimensions: number;\n}>;\n\n/**\n * Modifiers shared by every graph-extension property type.\n *\n * `optional: true` flips the field from required-with-graph-extension-validation\n * to `.optional()` and removes it from the parent object's `required`\n * list. `searchable` and `embedding` only apply to specific underlying\n * types — see the per-modifier docs.\n */\nexport type ExtensionPropertyModifiers = Readonly<{\n  optional?: boolean;\n  searchable?: ExtensionSearchableModifier;\n  embedding?: ExtensionEmbeddingModifier;\n  description?: string;\n}>;\n\n/**\n * String property. Compiles to `z.string()` plus the requested refinements.\n * `format` accepts the two formats motivated by induced schemas in\n * practice — covers ISO datetimes, URIs, email addresses, UUIDs, and\n * date-only strings. Each format routes to the corresponding Zod\n * factory (`z.iso.datetime()`, `z.url()`, `z.email()`, `z.uuid()`,\n * `z.iso.date()`); other JSON-Schema formats are deliberately not\n * supported in v1.\n */\nexport type ExtensionStringProperty = Readonly<{\n  type: \"string\";\n  minLength?: number;\n  maxLength?: number;\n  pattern?: string;\n  format?: \"datetime\" | \"uri\" | \"email\" | \"uuid\" | \"date\";\n}> &\n  ExtensionPropertyModifiers;\n\n/**\n * Number property. `int: true` requires whole numbers; `min` / `max` are\n * inclusive bounds. Compiles to `z.number().int()?.min(...)?.max(...)`.\n */\nexport type ExtensionNumberProperty = Readonly<{\n  type: \"number\";\n  min?: number;\n  max?: number;\n  int?: boolean;\n}> &\n  ExtensionPropertyModifiers;\n\n/**\n * Boolean property. Compiles to `z.boolean()`.\n */\nexport type ExtensionBooleanProperty = Readonly<{\n  type: \"boolean\";\n}> &\n  ExtensionPropertyModifiers;\n\n/**\n * Closed-set string enum. Compiles to `z.enum([...values])`. Must contain\n * at least one value; duplicate values are rejected at validation time.\n */\nexport type ExtensionEnumProperty = Readonly<{\n  type: \"enum\";\n  values: readonly string[];\n}> &\n  ExtensionPropertyModifiers;\n\n/**\n * Array property. `items` is any of the scalar property types or an\n * object property — nested arrays are forbidden in v1. Compiles to\n * `z.array(<items>)`. The `embedding` modifier turns this into a\n * vector embedding instead of a generic array.\n */\nexport type ExtensionArrayProperty = Readonly<{\n  type: \"array\";\n  items: ExtensionArrayItemType;\n}> &\n  ExtensionPropertyModifiers;\n\n/**\n * Element types allowed inside an array — every leaf property type plus\n * single-level object. Nesting an array inside an array is rejected at\n * validation time so the v1 surface stays a flat tree.\n */\nexport type ExtensionArrayItemType =\n  | ExtensionStringProperty\n  | ExtensionNumberProperty\n  | ExtensionBooleanProperty\n  | ExtensionEnumProperty\n  | ExtensionObjectProperty;\n\n/**\n * Object property. `properties` is a single nesting level; deeper objects\n * are rejected at validation time so the v1 surface is auditable at a\n * glance.\n */\nexport type ExtensionObjectProperty = Readonly<{\n  type: \"object\";\n  properties: Readonly<Record<string, ExtensionObjectFieldProperty>>;\n}> &\n  ExtensionPropertyModifiers;\n\n/**\n * Property types allowed inside an `object`'s `properties` — leaf scalars\n * and arrays only. Nested objects are blocked here to enforce the\n * single-nesting-level rule.\n */\nexport type ExtensionObjectFieldProperty =\n  | ExtensionStringProperty\n  | ExtensionNumberProperty\n  | ExtensionBooleanProperty\n  | ExtensionEnumProperty\n  | ExtensionArrayProperty;\n\n/**\n * Top-level property descriptor for a node or edge field.\n *\n * The discriminated union covers every type in the v1 subset; arbitrary\n * `unknown` inputs are validated against this set at\n * `defineGraphExtension(...)` time.\n */\nexport type ExtensionPropertyType =\n  | ExtensionStringProperty\n  | ExtensionNumberProperty\n  | ExtensionBooleanProperty\n  | ExtensionEnumProperty\n  | ExtensionArrayProperty\n  | ExtensionObjectProperty;\n\ntype ExtensionDefinedOutput<P extends ExtensionPropertyType> =\n  P extends ExtensionStringProperty ? string\n  : P extends ExtensionNumberProperty ? number\n  : P extends ExtensionBooleanProperty ? boolean\n  : P extends ExtensionEnumProperty ? P[\"values\"][number]\n  : P extends ExtensionArrayProperty ?\n    readonly ExtensionPropertyOutput<P[\"items\"]>[]\n  : P extends ExtensionObjectProperty ? ExtensionObjectOutput<P[\"properties\"]>\n  : never;\n\n/** TypeScript value represented by one graph-extension property descriptor. */\nexport type ExtensionPropertyOutput<P extends ExtensionPropertyType> =\n  P extends { optional: true } ? ExtensionDefinedOutput<P> | undefined\n  : ExtensionDefinedOutput<P>;\n\n/** TypeScript object represented by a graph-extension property map. */\nexport type ExtensionObjectOutput<\n  P extends Readonly<Record<string, ExtensionPropertyType>>,\n> = Readonly<\n  {\n    [\n      K in keyof P as P[K] extends { optional: true } ? never : K\n    ]: ExtensionPropertyOutput<P[K]>;\n  } & {\n    [\n      K in keyof P as P[K] extends { optional: true } ? K : never\n    ]?: ExtensionPropertyOutput<P[K]>;\n  }\n>;\n\ntype ExtensionPropertySchema<P extends ExtensionPropertyType> =\n  P extends { optional: true } ?\n    z.ZodOptional<z.ZodType<ExtensionDefinedOutput<P>>>\n  : z.ZodType<ExtensionDefinedOutput<P>>;\n\n/** Phantom Zod object type used by sound runtime-kind evidence. */\nexport type ExtensionObjectSchema<\n  P extends Readonly<Record<string, ExtensionPropertyType>>,\n> = z.ZodObject<{\n  [K in keyof P]: ExtensionPropertySchema<P[K]>;\n}>;\n\n/** Property map represented by an edge definition, including the empty default. */\nexport type ExtensionEdgeProperties<D extends ExtensionEdgeDef> =\n  D extends (\n    Readonly<{\n      properties: infer P extends Readonly<\n        Record<string, ExtensionPropertyType>\n      >;\n    }>\n  ) ?\n    P\n  : Readonly<Record<never, never>>;\n\n// ============================================================\n// Unique Constraints\n// ============================================================\n\n/**\n * Document-side `where` clause for a unique constraint.\n *\n * Mirrors `serializeWherePredicate`'s capability — the only operations\n * round-trippable through the persisted form are `isNull` and `isNotNull`.\n * Anything richer (equality, `in`, etc.) is rejected at validation time.\n */\nexport type ExtensionUniqueWhere = Readonly<{\n  field: string;\n  op: NullCheckOp;\n}>;\n\n/**\n * Unique constraint declaration. `fields` must reference declared\n * properties on the kind. Defaults match the existing `UniqueConstraint`:\n * `scope: \"kind\"`, `collation: \"binary\"`.\n */\nexport type ExtensionUniqueConstraint = Readonly<{\n  name: string;\n  fields: readonly string[];\n  scope?: \"kind\" | \"kindWithSubClasses\";\n  collation?: \"binary\" | \"caseInsensitive\";\n  where?: ExtensionUniqueWhere;\n}>;\n\n// ============================================================\n// Node and Edge Documents\n// ============================================================\n\n/**\n * Graph-extension declaration of a node kind.\n *\n * Property names follow the same reserved-key rules as compile-time\n * `defineNode` (`id`, `kind`, `meta`, and the `$`-prefix accessor\n * namespace are forbidden). Annotation values must be JSON.\n */\nexport type ExtensionNodeDef = Readonly<{\n  description?: string;\n  annotations?: KindAnnotations;\n  properties: Readonly<Record<string, ExtensionPropertyType>>;\n  unique?: readonly ExtensionUniqueConstraint[];\n}>;\n\n/**\n * Graph-extension declaration of an edge kind.\n *\n * `from` / `to` reference node kind names — either kinds declared in this\n * same document or compile-time kinds the document is being merged into.\n * Endpoints that resolve to nothing within the document are flagged as\n * soft references at validation time but not rejected; the final\n * cross-graph check happens when the document is merged into a host\n * `GraphDef`.\n */\nexport type ExtensionEdgeDef = Readonly<{\n  description?: string;\n  annotations?: KindAnnotations;\n  from: readonly string[];\n  to: readonly string[] | Readonly<Record<string, readonly string[]>>;\n  properties?: Readonly<Record<string, ExtensionPropertyType>>;\n}>;\n\n// ============================================================\n// Indexes (relational)\n// ============================================================\n\n/**\n * Document-level analogue of compile-time `defineNodeIndex` /\n * `defineEdgeIndex`. Mirrors `serializeWherePredicate`'s persistence-\n * round-trippable subset: only `isNull` / `isNotNull` predicates are\n * supported in v1, matching `ExtensionUniqueWhere`.\n */\nexport type ExtensionIndexWhere = Readonly<{\n  field: string;\n  op: NullCheckOp;\n}>;\n\n/**\n * Graph-extension-declared node index. `kind` references either a kind\n * declared in this same document or a compile-time host kind resolved\n * at merge time. `fields` and `coveringFields` are top-level property\n * names — JSON-pointer paths are not supported in v1, matching the\n * `ExtensionUniqueConstraint` v1 surface.\n */\nexport type ExtensionNodeIndex = Readonly<{\n  entity: \"node\";\n  kind: string;\n  name?: string;\n  fields: readonly string[];\n  coveringFields?: readonly string[];\n  unique?: boolean;\n  scope?: \"graphAndKind\" | \"graph\" | \"none\";\n  where?: ExtensionIndexWhere;\n}>;\n\n/**\n * Graph-extension-declared edge index. `direction` mirrors\n * `EdgeIndexDirection`; `kind` references a graph-extension or compile-time\n * edge kind.\n */\nexport type ExtensionEdgeIndex = Readonly<{\n  entity: \"edge\";\n  kind: string;\n  name?: string;\n  direction?: \"out\" | \"in\" | \"none\";\n  fields: readonly string[];\n  coveringFields?: readonly string[];\n  unique?: boolean;\n  scope?: \"graphAndKind\" | \"graph\" | \"none\";\n  where?: ExtensionIndexWhere;\n}>;\n\nexport type ExtensionIndex = ExtensionNodeIndex | ExtensionEdgeIndex;\n\n// ============================================================\n// Ontology\n// ============================================================\n\n/**\n * Graph-extension ontology relation. `metaEdge` is one of the built-in\n * meta-edge names (subClassOf, broader, disjointWith, etc.).\n *\n * `from` / `to` are either node-kind names declared in this document or\n * external IRI strings. The pure-value document does not distinguish the\n * two — the compiler treats endpoints that match a declared kind as\n * `NodeType` references and falls back to passing the raw string for\n * IRIs (matching the existing `OntologyRelation` shape, where\n * `from`/`to` are `NodeType | EdgeType | string`).\n */\nexport type ExtensionOntologyRelation = Readonly<{\n  metaEdge: MetaEdgeName;\n  from: string;\n  to: string;\n}>;\n\n// ============================================================\n// Document\n// ============================================================\n\n/**\n * Stable default major used when a stored document omits `version`.\n *\n * Pinned to `1` permanently. Pre-versioning documents (those persisted\n * before the field existed) and documents that explicitly omit\n * `version` are interpreted as `1` regardless of which major the\n * library currently supports. Splitting this from\n * `CURRENT_GRAPH_EXTENSION_VERSION` is load-bearing for future major\n * bumps: when v2 ships, `CURRENT` becomes `2` but `LEGACY` stays at\n * `1`, so a v1-era stored document still parses as v1 (and the\n * version-mismatch path can route it through a migration) rather than\n * being silently misinterpreted as v2.\n */\nexport const LEGACY_GRAPH_EXTENSION_VERSION = 1 as const;\n\n/**\n * Current major version of the `GraphExtension` format.\n *\n * Documents with a higher major version than this constant are\n * rejected with `GRAPH_EXTENSION_VERSION_UNSUPPORTED` — there is no\n * automatic downgrade path. Minor / additive changes ride forward-\n * compat via `.loose()` on every nested object schema.\n */\nexport const CURRENT_GRAPH_EXTENSION_VERSION = 1 as const;\n\n/**\n * Type of the `GraphExtension.version` field. Stays `number`\n * rather than `typeof CURRENT_GRAPH_EXTENSION_VERSION` because the\n * field can carry any major across the library version range a\n * stored document might have been written by — the\n * document-vs-supported check happens in the validator, not at the\n * type level. Pinning to the current literal would prevent a v1\n * v1 library from typing a v2 document at all, which is the wrong\n * relationship: we WANT a v1 library to receive v2 documents and\n * report `GRAPH_EXTENSION_VERSION_UNSUPPORTED` cleanly.\n */\nexport type GraphExtensionVersion = number;\n\n/**\n * The canonical pure-value graph-extension document.\n *\n * Frozen at construction. Round-trips losslessly through `JSON.stringify`\n * / `JSON.parse`; the `GraphExtension → CompiledExtension` direction\n * is provided by `compileGraphExtension(...)`. There is no\n * `Zod → GraphExtension` direction because graph-extension kinds always\n * originate as documents.\n *\n * `version` is the major-version tag for the document format. The\n * compiler accepts documents whose version is equal to the current\n * supported major (today: 1) or absent (the canonical persisted form\n * omits `version` when it equals the legacy default — see\n * `serializer.ts` — so the round-trip default is \"absent means legacy\n * major\"). Higher majors surface as\n * `GRAPH_EXTENSION_VERSION_UNSUPPORTED` so a newer-version extension\n * committed by a future writer can't be silently misread by an older\n * runtime. See `graph-extensions.md` for the format-versioning policy.\n */\nexport type GraphExtension = Readonly<{\n  version?: GraphExtensionVersion;\n  /** Graph-scoped annotations shallow-merged into the host graph by key. */\n  annotations?: GraphAnnotations;\n  nodes?: Readonly<Record<string, ExtensionNodeDef>>;\n  edges?: Readonly<Record<string, ExtensionEdgeDef>>;\n  ontology?: readonly ExtensionOntologyRelation[];\n  /**\n   * Graph-extension-declared relational indexes. Each entry references a\n   * node or edge kind by name — either declared in this document or\n   * a compile-time host kind that the document is being merged into.\n   * Vector indexes auto-derive from `embedding()` modifiers on\n   * graph-extension kinds; this slot is for explicit relational indexes\n   * (analogue of compile-time `defineGraph({ indexes: [...] })`).\n   */\n  indexes?: readonly ExtensionIndex[];\n}>;\n\n/**\n * Top-level v1 slots a `GraphExtension` document may carry. Single\n * source of truth for both the strict-authoring validator (typo rejection\n * via `defineGraphExtension`) and the persistence Zod schema (which\n * leaves the field set loose for forward compatibility but uses this\n * list to drive the Zod object shape).\n */\nexport const GRAPH_EXTENSION_TOP_LEVEL_KEYS = [\n  \"version\",\n  \"annotations\",\n  \"nodes\",\n  \"edges\",\n  \"ontology\",\n  \"indexes\",\n] as const;\n\nexport type GraphExtensionTopLevelKey =\n  (typeof GRAPH_EXTENSION_TOP_LEVEL_KEYS)[number];\n","/**\n * Returns whether a string is an absolute external HTTP(S) IRI.\n *\n * Ontology relations deliberately keep these references inert when the\n * referenced kind is not registered locally. Bare names are local kind\n * references and must resolve at the graph-extension merge boundary.\n */\nexport function isExternalIri(value: string): boolean {\n  return value.startsWith(\"http://\") || value.startsWith(\"https://\");\n}\n","import { type GraphIdentityConfig } from \"../core/define-graph\";\nimport { type AnyEdgeType, type NodeType } from \"../core/types\";\nimport {\n  computeTransitiveClosure,\n  invertClosure,\n  isReachable,\n} from \"../ontology/closures\";\nimport {\n  META_EDGE_BROADER,\n  META_EDGE_DISJOINT_WITH,\n  META_EDGE_EQUIVALENT_TO,\n  META_EDGE_HAS_PART,\n  META_EDGE_IMPLIES,\n  META_EDGE_INVERSE_OF,\n  META_EDGE_NARROWER,\n  META_EDGE_PART_OF,\n  META_EDGE_RELATED_TO,\n  META_EDGE_SAME_AS,\n  META_EDGE_SUB_CLASS_OF,\n} from \"../ontology/constants\";\nimport { isExternalIri } from \"../ontology/external-iri\";\nimport { type OntologyRelation } from \"../ontology/types\";\nimport { type NamedOntologyRelation } from \"../ontology/validation\";\nimport { compareStrings } from \"../utils/compare\";\nimport { requireDefined } from \"../utils/presence\";\n\nconst DISJOINT_PAIR_SEPARATOR = \"|\";\nconst ENCODED_DISJOINT_PAIR_PREFIX = \"\\u001Epair\\u001E\";\n\n/**\n * Encodes one string with its UTF-16 length, so adjacent values retain their\n * boundary even when either value contains punctuation used by older labels.\n */\nfunction encodeLengthPrefixed(value: string): string {\n  return `${value.length}:${value}`;\n}\n\n/**\n * Builds the canonical label of an unordered pair of kinds: the two names in\n * code-point order. Existing unambiguous pairs retain their historical\n * separator-joined form; pairs containing that separator use length prefixes.\n *\n * Order-independence is the whole point — `A⊥B` and `B⊥A` are one fact, so\n * they must be one string. {@link KindRegistry.disjointPairLabel} exposes it,\n * {@link computeDisjointPairs} writes the set with it, and the disjointness\n * claim axis folds it.\n */\nfunction disjointPairLabel(leftKind: string, rightKind: string): string {\n  const [first, second] =\n    leftKind < rightKind ? [leftKind, rightKind] : [rightKind, leftKind];\n  if (\n    !first.includes(DISJOINT_PAIR_SEPARATOR) &&\n    !second.includes(DISJOINT_PAIR_SEPARATOR)\n  ) {\n    // Preserve the historical form — and therefore existing serialized\n    // closure documents and schema hashes — wherever it is already injective.\n    return `${first}${DISJOINT_PAIR_SEPARATOR}${second}`;\n  }\n  return `${ENCODED_DISJOINT_PAIR_PREFIX}${encodeLengthPrefixed(first)}${encodeLengthPrefixed(second)}`;\n}\n\n/** Reads one value produced by {@link encodeLengthPrefixed}. */\nfunction readLengthPrefixed(\n  label: string,\n  offset: number,\n): Readonly<{ value: string; nextOffset: number }> {\n  const lengthSeparator = label.indexOf(\":\", offset);\n  const lengthText = label.slice(offset, lengthSeparator);\n  if (lengthSeparator === -1 || !/^\\d+$/u.test(lengthText)) {\n    throw new Error(`Invalid disjoint-pair label ${JSON.stringify(label)}.`);\n  }\n  const start = lengthSeparator + 1;\n  const end = start + Number(lengthText);\n  if (end > label.length) {\n    throw new Error(`Invalid disjoint-pair label ${JSON.stringify(label)}.`);\n  }\n  return { value: label.slice(start, end), nextOffset: end };\n}\n\n/** The inverse of {@link disjointPairLabel}, so only one place knows the form. */\nfunction disjointPairMembers(label: string): readonly [string, string] {\n  if (!label.startsWith(ENCODED_DISJOINT_PAIR_PREFIX)) {\n    const [first, second] = label.split(DISJOINT_PAIR_SEPARATOR);\n    return [requireDefined(first), requireDefined(second)];\n  }\n  const first = readLengthPrefixed(label, ENCODED_DISJOINT_PAIR_PREFIX.length);\n  const second = readLengthPrefixed(label, first.nextOffset);\n  if (second.nextOffset !== label.length) {\n    throw new Error(`Invalid disjoint-pair label ${JSON.stringify(label)}.`);\n  }\n  return [first.value, second.value];\n}\n\n/**\n * Precomputes each undirected `subClassOf` component once per registry.\n *\n * The transitive closures are a sound adjacency: every direct edge is present,\n * and every closure edge joins members of the same component. Assigning the\n * same frozen array to every member makes later axis/probe resolution O(1) and\n * guarantees every member observes byte-identical ordering.\n */\nfunction computeSubClassComponents(\n  nodeKinds: ReadonlyMap<string, NodeType>,\n  ancestors: ReadonlyMap<string, ReadonlySet<string>>,\n  descendants: ReadonlyMap<string, ReadonlySet<string>>,\n): ReadonlyMap<string, readonly string[]> {\n  const components = new Map<string, readonly string[]>();\n  const knownKinds = new Set([\n    ...nodeKinds.keys(),\n    ...ancestors.keys(),\n    ...descendants.keys(),\n  ]);\n  for (const kind of knownKinds) {\n    if (components.has(kind)) continue;\n    const members = new Set<string>([kind]);\n    const pending = [kind];\n    while (pending.length > 0) {\n      const current = requireDefined(pending.pop());\n      const neighbors = [\n        ...(ancestors.get(current) ?? []),\n        ...(descendants.get(current) ?? []),\n      ];\n      for (const neighbor of neighbors) {\n        if (members.has(neighbor)) continue;\n        members.add(neighbor);\n        pending.push(neighbor);\n      }\n    }\n    const component = Object.freeze(\n      [...members].toSorted((left, right) => compareStrings(left, right)),\n    );\n    for (const member of members) components.set(member, component);\n  }\n  return components;\n}\n\n/**\n * KindRegistry holds precomputed closures for ontological reasoning.\n *\n * Computed at store initialization and cached for fast query-time lookups.\n */\nexport class KindRegistry {\n  // === Node & Edge Kinds ===\n  readonly nodeKinds: ReadonlyMap<string, NodeType>;\n  readonly edgeKinds: ReadonlyMap<string, AnyEdgeType>;\n  /**\n   * Durable graph identity capability; supplies the identity defaults for\n   * every query builder built from this registry (compile-only and\n   * store-bound).\n   */\n  readonly identity: GraphIdentityConfig | undefined;\n\n  // === Subsumption (subClassOf) ===\n  // Transitive closure for inheritance\n  readonly subClassAncestors: ReadonlyMap<string, ReadonlySet<string>>;\n  readonly subClassDescendants: ReadonlyMap<string, ReadonlySet<string>>;\n  readonly #subClassComponents: ReadonlyMap<string, readonly string[]>;\n\n  // === Hierarchy (broader/narrower) ===\n  // Transitive closure for concept hierarchy (separate from subClassOf!)\n  readonly broaderClosure: ReadonlyMap<string, ReadonlySet<string>>;\n  readonly narrowerClosure: ReadonlyMap<string, ReadonlySet<string>>;\n\n  // === Equivalence ===\n  readonly equivalenceSets: ReadonlyMap<string, ReadonlySet<string>>;\n  readonly iriToKind: ReadonlyMap<string, string>;\n  readonly relatedKinds: ReadonlyMap<string, ReadonlySet<string>>;\n\n  // === Constraints ===\n  readonly disjointPairs: ReadonlySet<string>; // Injectively encoded unordered pairs\n\n  // === Composition ===\n  readonly partOfClosure: ReadonlyMap<string, ReadonlySet<string>>;\n  readonly hasPartClosure: ReadonlyMap<string, ReadonlySet<string>>;\n\n  // === Edge Relationships ===\n  readonly edgeInverses: ReadonlyMap<string, string>;\n  readonly edgeImplicationsClosure: ReadonlyMap<string, ReadonlySet<string>>;\n  readonly edgeImplyingClosure: ReadonlyMap<string, ReadonlySet<string>>;\n\n  constructor(\n    nodeKinds: ReadonlyMap<string, NodeType>,\n    edgeKinds: ReadonlyMap<string, AnyEdgeType>,\n    closures: {\n      subClassAncestors: ReadonlyMap<string, ReadonlySet<string>>;\n      subClassDescendants: ReadonlyMap<string, ReadonlySet<string>>;\n      broaderClosure: ReadonlyMap<string, ReadonlySet<string>>;\n      narrowerClosure: ReadonlyMap<string, ReadonlySet<string>>;\n      equivalenceSets: ReadonlyMap<string, ReadonlySet<string>>;\n      iriToKind: ReadonlyMap<string, string>;\n      relatedKinds: ReadonlyMap<string, ReadonlySet<string>>;\n      disjointPairs: ReadonlySet<string>;\n      partOfClosure: ReadonlyMap<string, ReadonlySet<string>>;\n      hasPartClosure: ReadonlyMap<string, ReadonlySet<string>>;\n      edgeInverses: ReadonlyMap<string, string>;\n      edgeImplicationsClosure: ReadonlyMap<string, ReadonlySet<string>>;\n      edgeImplyingClosure: ReadonlyMap<string, ReadonlySet<string>>;\n    },\n    identity?: GraphIdentityConfig,\n  ) {\n    this.nodeKinds = nodeKinds;\n    this.edgeKinds = edgeKinds;\n    this.identity = identity;\n    this.subClassAncestors = closures.subClassAncestors;\n    this.subClassDescendants = closures.subClassDescendants;\n    this.#subClassComponents = computeSubClassComponents(\n      nodeKinds,\n      closures.subClassAncestors,\n      closures.subClassDescendants,\n    );\n    this.broaderClosure = closures.broaderClosure;\n    this.narrowerClosure = closures.narrowerClosure;\n    this.equivalenceSets = closures.equivalenceSets;\n    this.iriToKind = closures.iriToKind;\n    this.relatedKinds = closures.relatedKinds;\n    this.disjointPairs = closures.disjointPairs;\n    this.partOfClosure = closures.partOfClosure;\n    this.hasPartClosure = closures.hasPartClosure;\n    this.edgeInverses = closures.edgeInverses;\n    this.edgeImplicationsClosure = closures.edgeImplicationsClosure;\n    this.edgeImplyingClosure = closures.edgeImplyingClosure;\n  }\n\n  // === Subsumption Methods ===\n\n  /**\n   * Checks if child is a subclass of parent (directly or transitively).\n   */\n  isSubClassOf(child: string, parent: string): boolean {\n    return isReachable(this.subClassAncestors, child, parent);\n  }\n\n  /**\n   * Expands a kind to include all its subclasses.\n   * Returns [kind, ...subclasses].\n   */\n  expandSubClasses(kind: string): readonly string[] {\n    const descendants = this.subClassDescendants.get(kind) ?? new Set();\n    return [kind, ...descendants];\n  }\n\n  /**\n   * Gets all ancestors of a kind (via subClassOf).\n   */\n  getAncestors(kind: string): ReadonlySet<string> {\n    return this.subClassAncestors.get(kind) ?? new Set();\n  }\n\n  /**\n   * Gets all descendants of a kind (via subClassOf).\n   */\n  getDescendants(kind: string): ReadonlySet<string> {\n    return this.subClassDescendants.get(kind) ?? new Set();\n  }\n\n  /**\n   * Returns the precomputed undirected `subClassOf` component containing kind,\n   * in code-point order. Every member of one component returns the same array.\n   */\n  getSubClassComponent(kind: string): readonly string[] {\n    return this.#subClassComponents.get(kind) ?? [kind];\n  }\n\n  // === Hierarchy Methods ===\n\n  /**\n   * Checks if narrowerConcept is narrower than broaderConcept.\n   */\n  isNarrowerThan(narrowerConcept: string, broaderConcept: string): boolean {\n    return isReachable(this.broaderClosure, narrowerConcept, broaderConcept);\n  }\n\n  /**\n   * Checks if broaderConcept is broader than narrowerConcept.\n   */\n  isBroaderThan(broaderConcept: string, narrowerConcept: string): boolean {\n    return isReachable(this.narrowerClosure, broaderConcept, narrowerConcept);\n  }\n\n  /**\n   * Expands to include all narrower concepts.\n   */\n  expandNarrower(kind: string): readonly string[] {\n    const narrower = this.narrowerClosure.get(kind) ?? new Set();\n    return [kind, ...narrower];\n  }\n\n  /**\n   * Expands to include all broader concepts.\n   */\n  expandBroader(kind: string): readonly string[] {\n    const broader = this.broaderClosure.get(kind) ?? new Set();\n    return [kind, ...broader];\n  }\n\n  // === Equivalence Methods ===\n\n  /**\n   * Checks if two kinds are equivalent.\n   */\n  areEquivalent(a: string, b: string): boolean {\n    const equivalents = this.equivalenceSets.get(a);\n    return equivalents?.has(b) ?? false;\n  }\n\n  /**\n   * Gets all equivalents of a kind (including external IRIs).\n   */\n  getEquivalents(kind: string): readonly string[] {\n    const equivalents = this.equivalenceSets.get(kind);\n    return equivalents ? [...equivalents] : [];\n  }\n\n  /**\n   * Resolves an external IRI to an internal kind name.\n   */\n  resolveIri(iri: string): string | undefined {\n    return this.iriToKind.get(iri);\n  }\n\n  /** Gets directly associated kinds declared through symmetric `relatedTo`. */\n  getRelatedKinds(kind: string): readonly string[] {\n    const related = this.relatedKinds.get(kind);\n    return related === undefined ? [] : [...related];\n  }\n\n  // === Constraint Methods ===\n\n  /**\n   * THE canonical label of an unordered pair of kinds — the form\n   * {@link disjointPairs} stores, and the form a disjointness CLAIM AXIS is\n   * folded from.\n   *\n   * Exposed on the registry because the claim axis needs it: a fence keyed on\n   * a second spelling of this normalization would put the two kinds of one\n   * disjoint pair on two rows that can never collide, which is exactly the\n   * failure the fence exists to prevent. One expression, called by the\n   * membership test, by the pair computation, and by the axis.\n   */\n  disjointPairLabel(a: string, b: string): string {\n    return disjointPairLabel(a, b);\n  }\n\n  /**\n   * Checks if two kinds are disjoint.\n   */\n  areDisjoint(a: string, b: string): boolean {\n    return this.disjointPairs.has(disjointPairLabel(a, b));\n  }\n\n  /**\n   * Every declared disjoint pair, once each, as the two kinds it names.\n   *\n   * The inverse of {@link disjointPairLabel} lives in this module alone, so a\n   * caller enumerating the pairs — the fence audit is the one that needs them —\n   * never has to know how a label is spelled. Iterating the kinds and folding\n   * {@link getDisjointKinds} would be a second, order-dependent spelling of\n   * exactly this set.\n   */\n  disjointKindPairs(): readonly (readonly [string, string])[] {\n    return [...this.disjointPairs].map((pair) => disjointPairMembers(pair));\n  }\n\n  /**\n   * Gets all kinds that are disjoint with the given kind.\n   */\n  getDisjointKinds(kind: string): readonly string[] {\n    const result: string[] = [];\n    for (const pair of this.disjointPairs) {\n      const [firstKind, secondKind] = disjointPairMembers(pair);\n      if (firstKind === kind) result.push(secondKind);\n      else if (secondKind === kind) result.push(firstKind);\n    }\n    return result;\n  }\n\n  // === Composition Methods ===\n\n  /**\n   * Checks if part is part of whole (directly or transitively).\n   */\n  isPartOf(part: string, whole: string): boolean {\n    return isReachable(this.partOfClosure, part, whole);\n  }\n\n  /**\n   * Gets all wholes that contain this part.\n   */\n  getWholes(part: string): readonly string[] {\n    const wholes = this.partOfClosure.get(part);\n    return wholes ? [...wholes] : [];\n  }\n\n  /**\n   * Gets all parts of this whole.\n   */\n  getParts(whole: string): readonly string[] {\n    const parts = this.hasPartClosure.get(whole);\n    return parts ? [...parts] : [];\n  }\n\n  // === Edge Relationship Methods ===\n\n  /**\n   * Gets the inverse edge kind for a given edge kind.\n   * If edgeA inverseOf edgeB, then getInverseEdge(\"edgeA\") returns \"edgeB\".\n   */\n  getInverseEdge(edgeKind: string): string | undefined {\n    return this.edgeInverses.get(edgeKind);\n  }\n\n  /**\n   * Gets all edges implied by a given edge (transitively).\n   * If A implies B and B implies C, then getImpliedEdges(\"A\") returns [\"B\", \"C\"].\n   */\n  getImpliedEdges(edgeKind: string): readonly string[] {\n    const implied = this.edgeImplicationsClosure.get(edgeKind);\n    return implied ? [...implied] : [];\n  }\n\n  /**\n   * Gets all edges that imply a given edge (transitively).\n   * If A implies B and B implies C, then getImplyingEdges(\"C\") returns [\"A\", \"B\"].\n   * Used for query-time expansion: when querying for C, also include A and B edges.\n   */\n  getImplyingEdges(edgeKind: string): readonly string[] {\n    const implying = this.edgeImplyingClosure.get(edgeKind);\n    return implying ? [...implying] : [];\n  }\n\n  /**\n   * Expands an edge kind to include all edges that imply it.\n   * Returns [edgeKind, ...implyingEdges].\n   */\n  expandImplyingEdges(edgeKind: string): readonly string[] {\n    const implying = this.edgeImplyingClosure.get(edgeKind) ?? new Set();\n    return [edgeKind, ...implying];\n  }\n\n  // === Edge Endpoint Validation ===\n\n  /**\n   * Checks if a concrete kind is assignable to a target kind.\n   * Uses subsumption: Company is assignable to Organization if Company subClassOf Organization.\n   */\n  isAssignableTo(concreteKind: string, targetKind: string): boolean {\n    if (concreteKind === targetKind) return true;\n    return this.isSubClassOf(concreteKind, targetKind);\n  }\n\n  /**\n   * Checks if a concrete kind is assignable to at least one of the given\n   * target kinds. Shared by every \"is this kind usable where one of these\n   * kinds is expected\" check (edge endpoint validation, ontology relation\n   * endpoint compatibility) so they can't independently drift.\n   */\n  isAssignableToAny(\n    concreteKind: string,\n    targetKinds: readonly string[],\n  ): boolean {\n    return targetKinds.some((targetKind) =>\n      this.isAssignableTo(concreteKind, targetKind),\n    );\n  }\n\n  /**\n   * Validates that a kind exists in the registry.\n   */\n  hasNodeType(name: string): boolean {\n    return this.nodeKinds.has(name);\n  }\n\n  /**\n   * Validates that an edge kind exists in the registry.\n   */\n  hasEdgeType(name: string): boolean {\n    return this.edgeKinds.has(name);\n  }\n\n  /**\n   * Gets a node kind by name.\n   */\n  getNodeType(name: string): NodeType | undefined {\n    return this.nodeKinds.get(name);\n  }\n\n  /**\n   * Gets an edge kind by name.\n   */\n  getEdgeType(name: string): AnyEdgeType | undefined {\n    return this.edgeKinds.get(name);\n  }\n}\n\n/**\n * Builder function to create empty closures.\n */\nexport function createEmptyClosures(): {\n  subClassAncestors: ReadonlyMap<string, ReadonlySet<string>>;\n  subClassDescendants: ReadonlyMap<string, ReadonlySet<string>>;\n  broaderClosure: ReadonlyMap<string, ReadonlySet<string>>;\n  narrowerClosure: ReadonlyMap<string, ReadonlySet<string>>;\n  equivalenceSets: ReadonlyMap<string, ReadonlySet<string>>;\n  iriToKind: ReadonlyMap<string, string>;\n  relatedKinds: ReadonlyMap<string, ReadonlySet<string>>;\n  disjointPairs: ReadonlySet<string>;\n  partOfClosure: ReadonlyMap<string, ReadonlySet<string>>;\n  hasPartClosure: ReadonlyMap<string, ReadonlySet<string>>;\n  edgeInverses: ReadonlyMap<string, string>;\n  edgeImplicationsClosure: ReadonlyMap<string, ReadonlySet<string>>;\n  edgeImplyingClosure: ReadonlyMap<string, ReadonlySet<string>>;\n} {\n  return {\n    subClassAncestors: new Map(),\n    subClassDescendants: new Map(),\n    broaderClosure: new Map(),\n    narrowerClosure: new Map(),\n    equivalenceSets: new Map(),\n    iriToKind: new Map(),\n    relatedKinds: new Map(),\n    disjointPairs: new Set(),\n    partOfClosure: new Map(),\n    hasPartClosure: new Map(),\n    edgeInverses: new Map(),\n    edgeImplicationsClosure: new Map(),\n    edgeImplyingClosure: new Map(),\n  };\n}\n\n/**\n * Computes all closures from an ontology.\n */\nexport function computeClosuresFromOntology(\n  ontology: readonly OntologyRelation[],\n): ReturnType<typeof computeClosuresFromNamedOntology> {\n  return computeClosuresFromNamedOntology(\n    ontology.map((relation) => ({\n      metaEdge: relation.metaEdge.name,\n      from: getKindName(relation.from),\n      to: getKindName(relation.to),\n    })),\n  );\n}\n\ntype NamedRelationPair = readonly [string, string];\n\n/**\n * The per-meta-edge relation lists every closure is derived from. Collecting\n * them once keeps the mapping from meta-edge to closure input single-sourced:\n * `narrower` and `hasPart` are normalized into their canonical direction here\n * and nowhere else.\n */\ntype CollectedOntologyRelations = Readonly<{\n  subClass: readonly NamedRelationPair[];\n  broader: readonly NamedRelationPair[];\n  equivalent: readonly NamedRelationPair[];\n  related: readonly NamedRelationPair[];\n  disjoint: readonly NamedRelationPair[];\n  partOf: readonly NamedRelationPair[];\n  inverseOf: readonly NamedRelationPair[];\n  implies: readonly NamedRelationPair[];\n}>;\n\n/**\n * The closures disjointness expansion consumes. `validateOntologyRelations`\n * and the registry share this exact input so a declaration validation accepts\n * can never expand differently at runtime.\n */\nexport type DisjointExpansionClosures = Readonly<{\n  subClassDescendants: ReadonlyMap<string, ReadonlySet<string>>;\n  equivalenceSets: ReadonlyMap<string, ReadonlySet<string>>;\n}>;\n\nfunction collectOntologyRelations(\n  ontology: readonly NamedOntologyRelation[],\n): CollectedOntologyRelations {\n  const subClass: NamedRelationPair[] = [];\n  const broader: NamedRelationPair[] = [];\n  const equivalent: NamedRelationPair[] = [];\n  const related: NamedRelationPair[] = [];\n  const disjoint: NamedRelationPair[] = [];\n  const partOf: NamedRelationPair[] = [];\n  const inverseOf: NamedRelationPair[] = [];\n  const implies: NamedRelationPair[] = [];\n\n  for (const relation of ontology) {\n    const fromName = relation.from;\n    const toName = relation.to;\n\n    switch (relation.metaEdge) {\n      case META_EDGE_SUB_CLASS_OF: {\n        subClass.push([fromName, toName]);\n        break;\n      }\n      case META_EDGE_BROADER: {\n        broader.push([fromName, toName]);\n        break;\n      }\n      case META_EDGE_NARROWER: {\n        // narrower is inverse of broader\n        broader.push([toName, fromName]);\n        break;\n      }\n      case META_EDGE_EQUIVALENT_TO:\n      case META_EDGE_SAME_AS: {\n        equivalent.push([fromName, toName]);\n        break;\n      }\n      case META_EDGE_RELATED_TO: {\n        related.push([fromName, toName]);\n        break;\n      }\n      case META_EDGE_DISJOINT_WITH: {\n        disjoint.push([fromName, toName]);\n        break;\n      }\n      case META_EDGE_PART_OF: {\n        partOf.push([fromName, toName]);\n        break;\n      }\n      case META_EDGE_HAS_PART: {\n        // hasPart is inverse of partOf\n        partOf.push([toName, fromName]);\n        break;\n      }\n      case META_EDGE_INVERSE_OF: {\n        // inverseOf is symmetric: if A inverseOf B, then B inverseOf A\n        inverseOf.push([fromName, toName]);\n        break;\n      }\n      case META_EDGE_IMPLIES: {\n        implies.push([fromName, toName]);\n        break;\n      }\n    }\n  }\n\n  return {\n    subClass,\n    broader,\n    equivalent,\n    related,\n    disjoint,\n    partOf,\n    inverseOf,\n    implies,\n  };\n}\n\nfunction computeSubsumptionAndEquivalenceClosures(\n  collected: CollectedOntologyRelations,\n): DisjointExpansionClosures &\n  Readonly<{ subClassAncestors: ReadonlyMap<string, ReadonlySet<string>> }> {\n  const subClassAncestors = computeTransitiveClosure(collected.subClass);\n  return {\n    subClassAncestors,\n    subClassDescendants: invertClosure(subClassAncestors),\n    equivalenceSets: computeEquivalenceSets(collected.equivalent),\n  };\n}\n\n/**\n * Computes only the closures disjointness expansion needs.\n *\n * Load-time validation calls this instead of {@link\n * computeClosuresFromNamedOntology} so it never pays for the quadratic\n * disjoint-pair materialization it is trying to prove unnecessary, while still\n * expanding over byte-identical closures.\n */\nexport function computeDisjointExpansionClosures(\n  ontology: readonly NamedOntologyRelation[],\n): DisjointExpansionClosures {\n  return computeSubsumptionAndEquivalenceClosures(\n    collectOntologyRelations(ontology),\n  );\n}\n\n/** Computes all registry closures from already-normalized relation names. */\nexport function computeClosuresFromNamedOntology(\n  ontology: readonly NamedOntologyRelation[],\n): {\n  subClassAncestors: ReadonlyMap<string, ReadonlySet<string>>;\n  subClassDescendants: ReadonlyMap<string, ReadonlySet<string>>;\n  broaderClosure: ReadonlyMap<string, ReadonlySet<string>>;\n  narrowerClosure: ReadonlyMap<string, ReadonlySet<string>>;\n  equivalenceSets: ReadonlyMap<string, ReadonlySet<string>>;\n  iriToKind: ReadonlyMap<string, string>;\n  relatedKinds: ReadonlyMap<string, ReadonlySet<string>>;\n  disjointPairs: ReadonlySet<string>;\n  partOfClosure: ReadonlyMap<string, ReadonlySet<string>>;\n  hasPartClosure: ReadonlyMap<string, ReadonlySet<string>>;\n  edgeInverses: ReadonlyMap<string, string>;\n  edgeImplicationsClosure: ReadonlyMap<string, ReadonlySet<string>>;\n  edgeImplyingClosure: ReadonlyMap<string, ReadonlySet<string>>;\n} {\n  const collected = collectOntologyRelations(ontology);\n\n  const { subClassAncestors, subClassDescendants, equivalenceSets } =\n    computeSubsumptionAndEquivalenceClosures(collected);\n\n  // Compute broader/narrower closures\n  const broaderClosure = computeTransitiveClosure(collected.broader);\n  const narrowerClosure = invertClosure(broaderClosure);\n\n  const iriToKind = computeIriMapping(collected.equivalent);\n  const relatedKinds = computeSymmetricRelations(collected.related);\n\n  // Compute disjoint pairs (normalize for symmetric lookup)\n  const disjointPairs = computeDisjointPairs(collected.disjoint, {\n    subClassDescendants,\n    equivalenceSets,\n  });\n\n  // Compute partOf closures\n  const partOfClosure = computeTransitiveClosure(collected.partOf);\n  const hasPartClosure = invertClosure(partOfClosure);\n\n  // Compute edge inverses (symmetric: store both directions)\n  const edgeInverses = computeEdgeInverses(collected.inverseOf);\n\n  // Compute edge implications closure (transitive)\n  // edgeImplicationsClosure: A -> [B, C] means A implies B and C\n  // edgeImplyingClosure: C -> [A, B] means A and B imply C (inverse direction)\n  const edgeImplicationsClosure = computeTransitiveClosure(collected.implies);\n  const edgeImplyingClosure = invertClosure(edgeImplicationsClosure);\n\n  return {\n    subClassAncestors,\n    subClassDescendants,\n    broaderClosure,\n    narrowerClosure,\n    equivalenceSets,\n    iriToKind,\n    relatedKinds,\n    disjointPairs,\n    partOfClosure,\n    hasPartClosure,\n    edgeInverses,\n    edgeImplicationsClosure,\n    edgeImplyingClosure,\n  };\n}\n\n/**\n * Gets the name from a NodeType, EdgeType, or string.\n */\nfunction getKindName(kindOrIri: NodeType | AnyEdgeType | string): string {\n  if (typeof kindOrIri === \"string\") {\n    return kindOrIri;\n  }\n  return kindOrIri.kind;\n}\n\n/**\n * Computes equivalence sets (symmetric + transitive closure).\n */\nfunction computeEquivalenceSets(\n  relations: readonly (readonly [string, string])[],\n): ReadonlyMap<string, ReadonlySet<string>> {\n  const parent = new Map<string, string>();\n  const size = new Map<string, number>();\n\n  function find(x: string): string {\n    if (!parent.has(x)) {\n      parent.set(x, x);\n      size.set(x, 1);\n      return x;\n    }\n\n    let root = x;\n    while (requireDefined(parent.get(root)) !== root) {\n      root = requireDefined(parent.get(root));\n    }\n    let cursor = x;\n    while (cursor !== root) {\n      const next = requireDefined(parent.get(cursor));\n      parent.set(cursor, root);\n      cursor = next;\n    }\n    return root;\n  }\n\n  function union(a: string, b: string): void {\n    const rootA = find(a);\n    const rootB = find(b);\n    if (rootA === rootB) return;\n    const sizeA = requireDefined(size.get(rootA));\n    const sizeB = requireDefined(size.get(rootB));\n    const [root, child] = sizeA >= sizeB ? [rootA, rootB] : [rootB, rootA];\n    parent.set(child, root);\n    size.set(root, sizeA + sizeB);\n  }\n\n  // Build equivalence classes\n  for (const [a, b] of relations) {\n    union(a, b);\n  }\n\n  // Collect all members of each equivalence class\n  const classes = new Map<string, Set<string>>();\n  for (const key of parent.keys()) {\n    const root = find(key);\n    const existing = classes.get(root) ?? new Set();\n    existing.add(key);\n    classes.set(root, existing);\n  }\n\n  // Build result: each node maps to its equivalence set\n  const result = new Map<string, ReadonlySet<string>>();\n  for (const members of classes.values()) {\n    for (const member of members) {\n      result.set(member, new ExcludingReadonlySet(members, member));\n    }\n  }\n\n  return result;\n}\n\ntype SetLike<T> = Readonly<{\n  size: number;\n  has(value: T): boolean;\n  keys(): Iterator<T>;\n}>;\n\ntype SetComposition<T> = Readonly<{\n  union<U>(other: SetLike<U>): Set<T | U>;\n  intersection<U>(other: SetLike<U>): Set<T & U>;\n  difference<U>(other: SetLike<U>): Set<T>;\n  symmetricDifference<U>(other: SetLike<U>): Set<T | U>;\n  isSubsetOf(other: SetLike<unknown>): boolean;\n  isSupersetOf(other: SetLike<unknown>): boolean;\n  isDisjointFrom(other: SetLike<unknown>): boolean;\n}>;\n\ntype ComposableSet<T> = Set<T> & SetComposition<T>;\n\n/**\n * Presents one shared equivalence class as an immutable set that excludes the\n * member being queried. Copying the class once per member makes an N-member\n * class consume O(N²) storage even though every view differs by one value.\n *\n * The ES2024 set-composition methods materialize only the selected view. This\n * preserves the public `ReadonlySet` behavior without restoring quadratic\n * eager storage for callers that only iterate or perform membership checks.\n */\nclass ExcludingReadonlySet\n  implements ReadonlySet<string>, SetComposition<string>\n{\n  readonly #members: ReadonlySet<string>;\n  readonly #excludedMember: string;\n  readonly [Symbol.toStringTag] = \"Set\";\n\n  constructor(members: ReadonlySet<string>, excludedMember: string) {\n    this.#members = members;\n    this.#excludedMember = excludedMember;\n  }\n\n  get size(): number {\n    return (\n      this.#members.size - (this.#members.has(this.#excludedMember) ? 1 : 0)\n    );\n  }\n\n  has(value: string): boolean {\n    return value !== this.#excludedMember && this.#members.has(value);\n  }\n\n  *entries(): SetIterator<[string, string]> {\n    for (const value of this) yield [value, value];\n  }\n\n  keys(): SetIterator<string> {\n    return this.values();\n  }\n\n  *values(): SetIterator<string> {\n    for (const value of this.#members) {\n      if (value !== this.#excludedMember) yield value;\n    }\n  }\n\n  forEach(\n    callbackFunction: (\n      value: string,\n      value2: string,\n      set: ReadonlySet<string>,\n    ) => void,\n    thisArgument?: unknown,\n  ): void {\n    for (const value of this) {\n      callbackFunction.call(thisArgument, value, value, this);\n    }\n  }\n\n  [Symbol.iterator](): SetIterator<string> {\n    return this.values();\n  }\n\n  union<U>(other: SetLike<U>): Set<string | U> {\n    return this.materialize().union(other);\n  }\n\n  intersection<U>(other: SetLike<U>): Set<string & U> {\n    return this.materialize().intersection(other);\n  }\n\n  difference<U>(other: SetLike<U>): Set<string> {\n    return this.materialize().difference(other);\n  }\n\n  symmetricDifference<U>(other: SetLike<U>): Set<string | U> {\n    return this.materialize().symmetricDifference(other);\n  }\n\n  isSubsetOf(other: SetLike<unknown>): boolean {\n    return this.materialize().isSubsetOf(other);\n  }\n\n  isSupersetOf(other: SetLike<unknown>): boolean {\n    return this.materialize().isSupersetOf(other);\n  }\n\n  isDisjointFrom(other: SetLike<unknown>): boolean {\n    return this.materialize().isDisjointFrom(other);\n  }\n\n  private materialize(): ComposableSet<string> {\n    return new Set(this) as ComposableSet<string>;\n  }\n}\n\n/**\n * Computes mapping from external IRIs to internal kind names.\n */\nfunction computeIriMapping(\n  relations: readonly (readonly [string, string])[],\n): ReadonlyMap<string, string> {\n  const result = new Map<string, string>();\n\n  for (const [a, b] of relations) {\n    // If one is an IRI and other is a kind name, map IRI → kind\n    if (isExternalIri(a) && !isExternalIri(b)) {\n      result.set(a, b);\n    } else if (isExternalIri(b) && !isExternalIri(a)) {\n      result.set(b, a);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Computes normalized disjoint pairs.\n *\n * Disjointness lifts onto both subclass descendants and equivalence-set\n * members: if `A disjointWith B` and `A' equivalentTo A`, then `A'` is\n * disjoint with `B` too (a kind is disjoint with whatever its equivalent\n * is disjoint with). Equivalence sets can carry external IRIs, which are\n * inert references rather than local kinds — those are dropped so only\n * real kind names enter the pair set.\n *\n * The `left === right` guard is defense-in-depth: a coherent ontology\n * (one that passed `validateOntologyRelations`) never expands two disjoint\n * sides to a shared kind, but skipping self-pairs guarantees the load-\n * bearing `areDisjoint(kind, kind) === false` invariant regardless.\n */\nfunction computeDisjointPairs(\n  relations: readonly (readonly [string, string])[],\n  closures: DisjointExpansionClosures,\n): ReadonlySet<string> {\n  const result = new Set<string>();\n\n  for (const [a, b] of relations) {\n    const leftKinds = expandDisjointSide(a, closures);\n    const rightKinds = expandDisjointSide(b, closures);\n    for (const left of leftKinds) {\n      for (const right of rightKinds) {\n        if (left === right) continue;\n        result.add(disjointPairLabel(left, right));\n      }\n    }\n  }\n\n  return result;\n}\n\n/**\n * Expands one side of a disjoint pair to every kind that inherits its\n * disjointness: the kind itself, its subclass descendants, and its\n * equivalence-set members. External IRIs are excluded — they are inert\n * references, not local kinds that participate in identity folding.\n *\n * The IRI exclusion stops descent, so a subclass reached only *through* an\n * IRI does not inherit disjointness. Equivalence, by contrast, still crosses\n * IRIs because `computeEquivalenceSets` unions over them: a class containing\n * an IRI is already closed, and every member is one hop away.\n *\n * Both the registry and `validateOntologyRelations` expand through this\n * function. Re-implementing it against the declared relations instead of the\n * precomputed closures reintroduces exactly that IRI asymmetry as a\n * validation blind spot.\n */\nexport function expandDisjointSide(\n  kind: string,\n  closures: DisjointExpansionClosures,\n): readonly string[] {\n  const expanded = new Set<string>();\n  // Equivalence sets partition the kinds, so every member of a class sees the\n  // same class. Consuming a class once keeps expansion linear in the class\n  // size instead of quadratic.\n  const consumedEquivalenceClasses = new Set<string>();\n  const pending = [kind];\n  while (pending.length > 0) {\n    const current = requireDefined(pending.pop());\n    if (expanded.has(current) || isExternalIri(current)) continue;\n    expanded.add(current);\n    if (!consumedEquivalenceClasses.has(current)) {\n      consumedEquivalenceClasses.add(current);\n      for (const equivalent of closures.equivalenceSets.get(current) ?? []) {\n        consumedEquivalenceClasses.add(equivalent);\n        pending.push(equivalent);\n      }\n    }\n    for (const descendant of closures.subClassDescendants.get(current) ?? []) {\n      pending.push(descendant);\n    }\n  }\n  return [...expanded];\n}\n\nfunction computeSymmetricRelations(\n  relations: readonly (readonly [string, string])[],\n): ReadonlyMap<string, ReadonlySet<string>> {\n  const result = new Map<string, Set<string>>();\n  for (const [a, b] of relations) {\n    const relatedToA = result.get(a) ?? new Set<string>();\n    relatedToA.add(b);\n    result.set(a, relatedToA);\n    const relatedToB = result.get(b) ?? new Set<string>();\n    relatedToB.add(a);\n    result.set(b, relatedToB);\n  }\n  return result;\n}\n\n/**\n * Computes edge inverse mapping (symmetric: stores both directions).\n */\nfunction computeEdgeInverses(\n  relations: readonly (readonly [string, string])[],\n): ReadonlyMap<string, string> {\n  const result = new Map<string, string>();\n\n  for (const [a, b] of relations) {\n    // inverseOf is symmetric: A inverseOf B means B inverseOf A too\n    result.set(a, b);\n    result.set(b, a);\n  }\n\n  return result;\n}\n","import {\n  computeDisjointExpansionClosures,\n  expandDisjointSide,\n} from \"../registry/kind-registry\";\nimport { computeTransitiveClosure } from \"./closures\";\nimport {\n  META_EDGE_BROADER,\n  META_EDGE_DISJOINT_WITH,\n  META_EDGE_HAS_PART,\n  META_EDGE_INVERSE_OF,\n  META_EDGE_NARROWER,\n  META_EDGE_PART_OF,\n  META_EDGE_SUB_CLASS_OF,\n  type MetaEdgeName,\n} from \"./constants\";\n\nexport type NamedOntologyRelation = Readonly<{\n  metaEdge: string;\n  from: string;\n  to: string;\n}>;\n\ntype OntologyValidationIssueCode =\n  | \"ONTOLOGY_CYCLE\"\n  | \"ONTOLOGY_SELF_LOOP\"\n  | \"ONTOLOGY_DISJOINT_CONFLICT\"\n  | \"ONTOLOGY_INVERSE_MULTIPLE_PARTNERS\"\n  | \"DUPLICATE_ONTOLOGY_RELATION\";\n\nexport type OntologyValidationIssue = Readonly<{\n  relationIndex?: number;\n  message: string;\n  code: OntologyValidationIssueCode;\n  details: Readonly<Record<string, unknown>>;\n}>;\n\nconst STRICTLY_HIERARCHICAL: ReadonlySet<string> = new Set([\n  META_EDGE_SUB_CLASS_OF,\n  META_EDGE_BROADER,\n  META_EDGE_NARROWER,\n  META_EDGE_PART_OF,\n  META_EDGE_HAS_PART,\n]);\n\nconst HIERARCHICAL_NORMALIZATION: ReadonlyMap<\n  string,\n  Readonly<{ canonical: MetaEdgeName; flip: boolean }>\n> = new Map([\n  [META_EDGE_SUB_CLASS_OF, { canonical: META_EDGE_SUB_CLASS_OF, flip: false }],\n  [META_EDGE_BROADER, { canonical: META_EDGE_BROADER, flip: false }],\n  [META_EDGE_NARROWER, { canonical: META_EDGE_BROADER, flip: true }],\n  [META_EDGE_PART_OF, { canonical: META_EDGE_PART_OF, flip: false }],\n  [META_EDGE_HAS_PART, { canonical: META_EDGE_PART_OF, flip: true }],\n]);\n\ntype NormalizedHierarchicalEdge = Readonly<{\n  from: string;\n  to: string;\n  originalIndex: number;\n}>;\n\n/**\n * Validates the semantic coherence shared by authored extensions, live graph\n * registries, and serialized-schema registries.\n */\nexport function validateOntologyRelations(\n  ontology: readonly NamedOntologyRelation[],\n): readonly OntologyValidationIssue[] {\n  const issues: OntologyValidationIssue[] = [];\n  validateSelfLoopsAndDuplicates(ontology, issues);\n  detectHierarchicalCycles(ontology, issues);\n  detectDisjointExpansionConflicts(ontology, issues);\n  detectMultipleInversePartners(ontology, issues);\n  return issues;\n}\n\nfunction validateSelfLoopsAndDuplicates(\n  ontology: readonly NamedOntologyRelation[],\n  issues: OntologyValidationIssue[],\n): void {\n  const seenKeys = new Set<string>();\n  for (const [index, relation] of ontology.entries()) {\n    if (relation.from === relation.to) {\n      if (STRICTLY_HIERARCHICAL.has(relation.metaEdge)) {\n        issues.push({\n          relationIndex: index,\n          message: `Hierarchical meta-edge \"${relation.metaEdge}\" cannot be a self-loop (\"${relation.from}\" → \"${relation.to}\").`,\n          code: \"ONTOLOGY_SELF_LOOP\",\n          details: { metaEdge: relation.metaEdge, kind: relation.from },\n        });\n      } else if (relation.metaEdge === META_EDGE_DISJOINT_WITH) {\n        // A self disjointWith makes areSame(ref, ref) and areDifferent(ref,\n        // ref) both true and every same-kind identity fold fail at runtime.\n        // Reject it as a coherence contradiction at construction/load time.\n        issues.push({\n          relationIndex: index,\n          message: `Contradiction: kind \"${relation.from}\" cannot be declared disjointWith itself.`,\n          code: \"ONTOLOGY_DISJOINT_CONFLICT\",\n          details: { from: relation.from, to: relation.to },\n        });\n      }\n    }\n\n    const key = `${relation.metaEdge}::${relation.from}->${relation.to}`;\n    if (seenKeys.has(key)) {\n      issues.push({\n        relationIndex: index,\n        message: `Duplicate ontology relation \"${relation.metaEdge}\" (${relation.from} → ${relation.to}).`,\n        code: \"DUPLICATE_ONTOLOGY_RELATION\",\n        details: { ...relation },\n      });\n      continue;\n    }\n    seenKeys.add(key);\n  }\n}\n\nfunction buildHierarchicalGroups(\n  ontology: readonly NamedOntologyRelation[],\n): Map<MetaEdgeName, NormalizedHierarchicalEdge[]> {\n  const groups = new Map<MetaEdgeName, NormalizedHierarchicalEdge[]>();\n  for (const [index, relation] of ontology.entries()) {\n    const normalization = HIERARCHICAL_NORMALIZATION.get(relation.metaEdge);\n    if (normalization === undefined) continue;\n    // Self-loops are reported elsewhere; skip them for cycle detection.\n    if (relation.from === relation.to) continue;\n\n    const from = normalization.flip ? relation.to : relation.from;\n    const to = normalization.flip ? relation.from : relation.to;\n    const edges = groups.get(normalization.canonical) ?? [];\n    edges.push({ from, to, originalIndex: index });\n    groups.set(normalization.canonical, edges);\n  }\n  return groups;\n}\n\nfunction detectHierarchicalCycles(\n  ontology: readonly NamedOntologyRelation[],\n  issues: OntologyValidationIssue[],\n): void {\n  const groups = buildHierarchicalGroups(ontology);\n  for (const [name, edges] of groups) {\n    const closure = computeTransitiveClosure(\n      edges.map((edge) => [edge.from, edge.to] as const),\n    );\n    const reportedNodes = new Set<string>();\n    for (const [from, reachable] of closure) {\n      if (!reachable.has(from) || reportedNodes.has(from)) continue;\n      reportedNodes.add(from);\n      const offendingEdge = edges.find((edge) => edge.from === from);\n      issues.push({\n        ...(offendingEdge === undefined ?\n          {}\n        : { relationIndex: offendingEdge.originalIndex }),\n        message: `Cycle detected in \"${name}\" relations involving \"${from}\".`,\n        code: \"ONTOLOGY_CYCLE\",\n        details: { metaEdge: name, kind: from },\n      });\n    }\n  }\n}\n\ntype DisjointDeclaration = Readonly<{ a: string; b: string; index: number }>;\n\nfunction collectDisjointDeclarations(\n  ontology: readonly NamedOntologyRelation[],\n): readonly DisjointDeclaration[] {\n  const declarations: DisjointDeclaration[] = [];\n  for (const [index, relation] of ontology.entries()) {\n    if (relation.metaEdge !== META_EDGE_DISJOINT_WITH) continue;\n    // Self disjointWith is reported by validateSelfLoopsAndDuplicates; skip\n    // it here so the disjoint-expansion pass never double-reports the same\n    // relation.\n    if (relation.from === relation.to) continue;\n    declarations.push({ a: relation.from, b: relation.to, index });\n  }\n  return declarations;\n}\n\n/**\n * Rejects any disjoint declaration whose fully propagated sides overlap.\n *\n * The expansion runs over the registry's own closures through the registry's\n * own `expandDisjointSide`, so an accepted ontology cannot produce a runtime\n * state where two kinds are simultaneously equivalent and disjoint. A\n * validation-local re-implementation is what previously let an equivalence\n * chain routed through an external IRI load clean.\n *\n * Cyclic and self-looping ontologies reach this pass too, since the cycle\n * check only records issues rather than aborting. That is safe: closure\n * computation is Warshall over a fixed node set and expansion is a worklist\n * guarded by a visited set, so neither diverges on a cycle.\n */\nfunction detectDisjointExpansionConflicts(\n  ontology: readonly NamedOntologyRelation[],\n  issues: OntologyValidationIssue[],\n): void {\n  const declarations = collectDisjointDeclarations(ontology);\n  if (declarations.length === 0) return;\n\n  const closures = computeDisjointExpansionClosures(ontology);\n  for (const { a, b, index } of declarations) {\n    const left = expandDisjointSide(a, closures);\n    const right = new Set(expandDisjointSide(b, closures));\n    const overlappingKind = [...left]\n      .filter((kind) => right.has(kind))\n      .toSorted()[0];\n    if (overlappingKind === undefined) continue;\n    issues.push({\n      relationIndex: index,\n      message: `Contradiction: the propagated disjointWith sides \"${a}\" and \"${b}\" both contain kind \"${overlappingKind}\".`,\n      code: \"ONTOLOGY_DISJOINT_CONFLICT\",\n      details: { kind: overlappingKind, from: a, to: b },\n    });\n  }\n}\n\nfunction detectMultipleInversePartners(\n  ontology: readonly NamedOntologyRelation[],\n  issues: OntologyValidationIssue[],\n): void {\n  const partners = new Map<string, string>();\n  for (const [index, relation] of ontology.entries()) {\n    if (relation.metaEdge !== META_EDGE_INVERSE_OF) continue;\n    recordInversePartner(relation.from, relation.to, index, partners, issues);\n    if (relation.from !== relation.to) {\n      recordInversePartner(relation.to, relation.from, index, partners, issues);\n    }\n  }\n}\n\nfunction recordInversePartner(\n  edgeKind: string,\n  partnerKind: string,\n  relationIndex: number,\n  partners: Map<string, string>,\n  issues: OntologyValidationIssue[],\n): void {\n  const existingPartner = partners.get(edgeKind);\n  if (existingPartner === undefined) {\n    partners.set(edgeKind, partnerKind);\n    return;\n  }\n  if (existingPartner === partnerKind) return;\n\n  issues.push({\n    relationIndex,\n    message: `Edge kind \"${edgeKind}\" has multiple distinct inverseOf partners (\"${existingPartner}\" and \"${partnerKind}\").`,\n    code: \"ONTOLOGY_INVERSE_MULTIPLE_PARTNERS\",\n    details: { edgeKind, existingPartner, conflictingPartner: partnerKind },\n  });\n}\n","/**\n * Pure structural validation for `GraphExtension`.\n *\n * Walks the document and accumulates every issue (no fail-fast) so a\n * caller showing the document to a human reviewer can surface all\n * problems in one round. Cross-document references — edge endpoints,\n * ontology endpoints — resolve only against this document; resolution\n * against an existing compile-time graph happens later, when the\n * document is merged into a host `GraphDef`.\n */\nimport {\n  assertJsonValue,\n  cloneAndFreezeGraphAnnotations,\n} from \"../core/json-value\";\nimport {\n  type GraphAnnotations,\n  type KindAnnotations,\n  type KindEntity,\n  type NullCheckOp,\n} from \"../core/types\";\nimport { ConfigurationError } from \"../errors\";\nimport { ALL_META_EDGE_NAMES, type MetaEdgeName } from \"../ontology/constants\";\nimport { validateOntologyRelations } from \"../ontology/validation\";\nimport { encodeJsonPointerSegment } from \"../query/json-pointer\";\nimport {\n  isUnstorablePropertyName,\n  RESERVED_EDGE_KEYS,\n  RESERVED_NODE_KEYS,\n  UNSTORABLE_PROPERTY_NAME_REASON,\n} from \"../store/reserved-keys\";\nimport {\n  compactUndefined,\n  createDataKeyedBag,\n  freezeDeep,\n  hasOwnKey,\n  isPlainObject,\n} from \"../utils/object\";\nimport { err, ok, type Result } from \"../utils/result\";\nimport {\n  type GraphExtensionIssue,\n  type GraphExtensionIssueCode,\n  GraphExtensionValidationError,\n  GraphExtensionVersionUnsupportedError,\n} from \"./errors\";\nimport {\n  CURRENT_GRAPH_EXTENSION_VERSION,\n  type ExtensionArrayProperty,\n  type ExtensionBooleanProperty,\n  type ExtensionEdgeDef,\n  type ExtensionEnumProperty,\n  type ExtensionIndex,\n  type ExtensionNodeDef,\n  type ExtensionNumberProperty,\n  type ExtensionObjectFieldProperty,\n  type ExtensionObjectProperty,\n  type ExtensionOntologyRelation,\n  type ExtensionPropertyType,\n  type ExtensionStringProperty,\n  type ExtensionUniqueConstraint,\n  GRAPH_EXTENSION_TOP_LEVEL_KEYS,\n  type GraphExtension,\n  type GraphExtensionVersion,\n  LEGACY_GRAPH_EXTENSION_VERSION,\n} from \"./extension-types\";\n\nconst META_EDGE_NAME_SET: ReadonlySet<string> = new Set(ALL_META_EDGE_NAMES);\n\nconst SUPPORTED_PROPERTY_TYPES = new Set([\n  \"string\",\n  \"number\",\n  \"boolean\",\n  \"enum\",\n  \"array\",\n  \"object\",\n]);\n\n// Unknown per-property-type refinement keys are intentionally accepted\n// for forward compatibility: a future v1.x.y writer may emit additive\n// refinements an older v1 reader doesn't recognize. Recognized\n// refinements are read inline by the per-type validators\n// (e.g. `minLength` in `validateStringProperty`).\n\nconst SUPPORTED_STRING_FORMATS = new Set([\n  \"datetime\",\n  \"uri\",\n  \"email\",\n  \"uuid\",\n  \"date\",\n]);\n\n/**\n * Recognized keys shared by every property-type descriptor. The strict\n * authoring path rejects unknown sibling keys against the union of this\n * set and the per-type allowlist below; the loose persistence-load path\n * passes them through untouched (a future v1.x.y writer may emit\n * additive keys an older v1 reader doesn't recognize).\n */\nconst COMMON_PROPERTY_KEYS: ReadonlySet<string> = new Set([\n  \"type\",\n  \"optional\",\n  \"description\",\n  \"searchable\",\n  \"embedding\",\n]);\n\nconst PROPERTY_TYPE_KEYS: Readonly<Record<string, ReadonlySet<string>>> = {\n  string: new Set([\"minLength\", \"maxLength\", \"pattern\", \"format\"]),\n  number: new Set([\"min\", \"max\", \"int\"]),\n  boolean: new Set(),\n  enum: new Set([\"values\"]),\n  array: new Set([\"items\"]),\n  object: new Set([\"properties\"]),\n};\n\n/**\n * In strict mode, surface an `UNKNOWN_PROPERTY_KEY` issue for every\n * key on `raw` that's not in either allowlist. This is the LLM /\n * agent-trust-boundary check: a typo like `minLenght: 5` on a string\n * field, or a refinement key from a future v1.x that this library\n * doesn't recognize, would otherwise compile to a weaker schema with\n * no signal to the reviewer.\n */\nfunction rejectUnknownPropertyKeys(\n  raw: Record<string, unknown>,\n  type: string,\n  path: string,\n  issues: GraphExtensionIssue[],\n): void {\n  const typeKeys = PROPERTY_TYPE_KEYS[type] ?? new Set<string>();\n  const recognized = [...COMMON_PROPERTY_KEYS, ...typeKeys];\n  for (const key of Object.keys(raw)) {\n    if (COMMON_PROPERTY_KEYS.has(key) || typeKeys.has(key)) continue;\n    issues.push({\n      path: `${path}/${encodeJsonPointerSegment(key)}`,\n      message: `Unknown property key \"${key}\" for type \"${type}\". Recognized keys: ${recognized.join(\", \")}.`,\n      code: \"UNKNOWN_PROPERTY_KEY\",\n    });\n  }\n}\n\n/**\n * Sibling of `rejectUnknownPropertyKeys` for the non-property strict-mode\n * checks (top-level slots, node/edge/ontology body keys, unique constraint\n * body, where-clause body, …). Each call site previously open-coded the\n * same `for-key-of-Object.keys` walk — this helper consolidates them.\n */\nfunction rejectUnknownObjectKeys(\n  raw: Readonly<Record<string, unknown>>,\n  allowed: ReadonlySet<string>,\n  label: string,\n  path: string,\n  code: GraphExtensionIssueCode,\n  issues: GraphExtensionIssue[],\n): void {\n  for (const key of Object.keys(raw)) {\n    if (allowed.has(key)) continue;\n    issues.push({\n      path: `${path}/${encodeJsonPointerSegment(key)}`,\n      message: `Unknown ${label} key \"${key}\". Allowed: ${[...allowed].join(\", \")}.`,\n      code,\n    });\n  }\n}\n\n/**\n * Top-level slots accepted in v1 documents. Strict-authoring callers\n * reject unknown sibling keys to surface typos like `node` instead of\n * `nodes`; the loose persistence-load path leaves unknowns untouched\n * for forward compatibility.\n */\nconst KNOWN_DOCUMENT_KEYS: ReadonlySet<string> = new Set(\n  GRAPH_EXTENSION_TOP_LEVEL_KEYS,\n);\n\n/**\n * Recognized body-level key sets — one per document-shape that the\n * strict-authoring path validates. Drives both the per-shape allowlist\n * check (`rejectUnknownObjectKeys`) and the human-readable \"Allowed:\"\n * tail in the error messages.\n */\nconst NODE_BODY_KEYS: ReadonlySet<string> = new Set([\n  \"description\",\n  \"annotations\",\n  \"properties\",\n  \"unique\",\n]);\nconst EDGE_BODY_KEYS: ReadonlySet<string> = new Set([\n  \"description\",\n  \"annotations\",\n  \"from\",\n  \"to\",\n  \"properties\",\n]);\nconst ONTOLOGY_ENTRY_KEYS: ReadonlySet<string> = new Set([\n  \"metaEdge\",\n  \"from\",\n  \"to\",\n]);\nconst UNIQUE_CONSTRAINT_KEYS: ReadonlySet<string> = new Set([\n  \"name\",\n  \"fields\",\n  \"scope\",\n  \"collation\",\n  \"where\",\n]);\nconst WHERE_CLAUSE_KEYS: ReadonlySet<string> = new Set([\"field\", \"op\"]);\nconst NODE_INDEX_KEYS: ReadonlySet<string> = new Set([\n  \"entity\",\n  \"kind\",\n  \"name\",\n  \"fields\",\n  \"coveringFields\",\n  \"unique\",\n  \"scope\",\n  \"where\",\n]);\nconst EDGE_INDEX_KEYS: ReadonlySet<string> = new Set([\n  \"entity\",\n  \"kind\",\n  \"name\",\n  \"fields\",\n  \"coveringFields\",\n  \"unique\",\n  \"scope\",\n  \"direction\",\n  \"where\",\n]);\n\ntype ValidateGraphExtensionOptions = Readonly<{\n  /**\n   * Reject unknown top-level keys and unsupported string formats.\n   * Used by `defineGraphExtension`, where the document is being\n   * authored fresh against the current library version — typos in\n   * `nodes` / `format: \"date-time\"` etc. should fail loudly. The\n   * persistence-load path leaves this off so a document committed by\n   * a future v1.x writer with additive fields still parses on an\n   * older v1 reader.\n   */\n  strict?: boolean;\n}>;\n\n/**\n * Validates a graph extension.\n *\n * Returns the (frozen, deeply normalized) extension on success, or a\n * `GraphExtensionValidationError` carrying every issue on authoring\n * failure. Unsupported future major versions throw\n * `GraphExtensionVersionUnsupportedError` immediately because the\n * current library cannot safely decode the rest of the document.\n * Callers that prefer exceptions for validation failures wrap the\n * returned `Result` with `unwrap()`.\n */\nexport function validateGraphExtension(\n  input: unknown,\n  options: ValidateGraphExtensionOptions = {},\n): Result<GraphExtension, GraphExtensionValidationError> {\n  const issues: GraphExtensionIssue[] = [];\n  const strict = options.strict === true;\n\n  if (!isPlainObject(input)) {\n    issues.push({\n      path: \"\",\n      message: \"Document must be a plain object.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return err(new GraphExtensionValidationError(issues));\n  }\n\n  const documentRecord = input;\n\n  // Forward-compat: in non-strict (persistence-load) mode, unknown\n  // top-level keys are intentionally NOT rejected. The persistence-\n  // side zod schema is `.loose()` on every nested object, and the\n  // documented format-versioning policy promises that additive minor\n  // changes (a new top-level slice in a future v1.x.y) ride forward\n  // without bumping the major. In strict (authoring) mode, unknown\n  // keys surface as `UNKNOWN_DOCUMENT_KEY` so a typo like `node`\n  // instead of `nodes` fails loudly instead of silently producing an\n  // empty extension.\n  if (strict) {\n    for (const key of Object.keys(documentRecord)) {\n      if (!KNOWN_DOCUMENT_KEYS.has(key)) {\n        issues.push({\n          path: `/${encodeJsonPointerSegment(key)}`,\n          message: `Unknown top-level key \"${key}\". Did you mean one of: ${[...KNOWN_DOCUMENT_KEYS].join(\", \")}?`,\n          code: \"UNKNOWN_DOCUMENT_KEY\",\n        });\n      }\n    }\n  }\n\n  const version = validateVersion(documentRecord[\"version\"], issues);\n\n  const annotations = validateAnnotations<GraphAnnotations>(\n    documentRecord[\"annotations\"],\n    \"/annotations\",\n    \"Graph extension\",\n    issues,\n  );\n  const nodes = validateNodesSection(documentRecord[\"nodes\"], issues, strict);\n  const edges = validateEdgesSection(documentRecord[\"edges\"], issues, strict);\n\n  // Edge endpoints can reference (a) kinds declared in this same document,\n  // (b) compile-time host kinds resolved at merge time, or (c) external\n  // IRIs. The cross-graph resolution check happens at merge time, not\n  // here.\n\n  const ontology = validateOntologySection(\n    documentRecord[\"ontology\"],\n    issues,\n    strict,\n  );\n  if (ontology !== undefined) {\n    validateOntology(ontology, issues);\n  }\n\n  const indexes = validateIndexesSection(\n    documentRecord[\"indexes\"],\n    issues,\n    strict,\n  );\n\n  if (issues.length > 0) {\n    return err(new GraphExtensionValidationError(issues));\n  }\n\n  return ok(\n    freezeDocument({ version, annotations, nodes, edges, ontology, indexes }),\n  );\n}\n\n/**\n * Validates the `version` field against the current supported major.\n *\n * Absent → resolved to `LEGACY_GRAPH_EXTENSION_VERSION` (a stable\n * `1`). The serializer omits `version` from the canonical persisted\n * form when it equals the legacy default, so the on-disk shape is\n * always version-less for v1 documents — the validator's absent →\n * legacy mapping closes that round-trip. Splitting `LEGACY` from\n * `CURRENT` is forward-looking design for future major bumps: when\n * v2 ships, `CURRENT` becomes `2` but `LEGACY` stays `1`, so a v1-era\n * stored document still parses as v1.\n *\n * Equal to current → accepted. Higher major → rejected with\n * `GRAPH_EXTENSION_VERSION_UNSUPPORTED`. Non-integer / non-positive\n * → rejected with `INVALID_DOCUMENT_SHAPE`.\n */\nfunction validateVersion(\n  raw: unknown,\n  issues: GraphExtensionIssue[],\n): GraphExtensionVersion {\n  if (raw === undefined) return LEGACY_GRAPH_EXTENSION_VERSION;\n  if (typeof raw !== \"number\" || !Number.isInteger(raw) || raw < 1) {\n    issues.push({\n      path: \"/version\",\n      message: `Document version must be a positive integer; received ${JSON.stringify(raw)}.`,\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return LEGACY_GRAPH_EXTENSION_VERSION;\n  }\n  if (raw > CURRENT_GRAPH_EXTENSION_VERSION) {\n    // Version mismatch is unrecoverable — the rest of the document\n    // may use fields the current library can't decode. Throw the\n    // typed class directly rather than batching into the issue list,\n    // which is reserved for per-field validation problems a UI can\n    // surface alongside others.\n    throw new GraphExtensionVersionUnsupportedError(\n      raw,\n      CURRENT_GRAPH_EXTENSION_VERSION,\n    );\n  }\n  return raw;\n}\n\n// ============================================================\n// Section: nodes\n// ============================================================\n\nfunction validateNodesSection(\n  rawNodes: unknown,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): Record<string, ExtensionNodeDef> | undefined {\n  if (rawNodes === undefined) return undefined;\n\n  if (!isPlainObject(rawNodes)) {\n    issues.push({\n      path: \"/nodes\",\n      message: \"`nodes` must be a plain object keyed by node-kind name.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n\n  // Kind names are DATA: `isValidKindName` admits `__proto__`, so a `{}`\n  // accumulator would answer that write with the prototype setter and drop the\n  // kind — silently, since the document is otherwise valid.\n  const result = createDataKeyedBag<ExtensionNodeDef>();\n  const recorded = new Set<string>();\n\n  for (const [kindName, rawNode] of Object.entries(rawNodes)) {\n    const path = `/nodes/${encodeJsonPointerSegment(kindName)}`;\n\n    if (!isValidKindName(kindName)) {\n      issues.push({\n        path,\n        message: `Node kind name \"${kindName}\" must match /^[A-Za-z_][A-Za-z0-9_]*$/.`,\n        code: \"INVALID_KIND_NAME\",\n      });\n      continue;\n    }\n\n    if (recorded.has(kindName)) {\n      issues.push({\n        path,\n        message: `Duplicate node kind name \"${kindName}\".`,\n        code: \"DUPLICATE_KIND_NAME\",\n      });\n      continue;\n    }\n\n    const node = validateNodeDocument(kindName, rawNode, path, issues, strict);\n    if (node === undefined) continue;\n    result[kindName] = node;\n    recorded.add(kindName);\n  }\n\n  // Spread at the boundary: this becomes `GraphExtension.nodes`, which\n  // `validateGraphExtension` returns. See `createDataKeyedBag` in\n  // ../utils/object.ts.\n  return { ...result };\n}\n\nfunction validateNodeDocument(\n  kindName: string,\n  raw: unknown,\n  path: string,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): ExtensionNodeDef | undefined {\n  if (!isPlainObject(raw)) {\n    issues.push({\n      path,\n      message: `Node \"${kindName}\" must be a plain object.`,\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n\n  if (strict) {\n    rejectUnknownObjectKeys(\n      raw,\n      NODE_BODY_KEYS,\n      \"node-level\",\n      path,\n      \"INVALID_DOCUMENT_SHAPE\",\n      issues,\n    );\n  }\n\n  const description = validateOptionalString(\n    raw[\"description\"],\n    `${path}/description`,\n    \"`description`\",\n    \"INVALID_DOCUMENT_SHAPE\",\n    issues,\n  );\n\n  const annotations = validateAnnotations(\n    raw[\"annotations\"],\n    `${path}/annotations`,\n    `Node \"${kindName}\"`,\n    issues,\n  );\n\n  const propertiesRaw = raw[\"properties\"];\n  const properties = validatePropertiesMap(\n    propertiesRaw,\n    `${path}/properties`,\n    \"node\",\n    kindName,\n    issues,\n    strict,\n  );\n  if (properties === undefined) return undefined;\n\n  const uniqueRaw = raw[\"unique\"];\n  const unique = validateUniqueConstraints(\n    uniqueRaw,\n    `${path}/unique`,\n    properties,\n    issues,\n    strict,\n  );\n\n  return compactUndefined<ExtensionNodeDef>({\n    description,\n    annotations,\n    properties,\n    unique,\n  });\n}\n\n// ============================================================\n// Section: edges\n// ============================================================\n\nfunction validateEdgesSection(\n  rawEdges: unknown,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): Record<string, ExtensionEdgeDef> | undefined {\n  if (rawEdges === undefined) return undefined;\n\n  if (!isPlainObject(rawEdges)) {\n    issues.push({\n      path: \"/edges\",\n      message: \"`edges` must be a plain object keyed by edge-kind name.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n\n  // Kind names are DATA — see the node section for why `{}` loses `__proto__`.\n  const result = createDataKeyedBag<ExtensionEdgeDef>();\n  const recorded = new Set<string>();\n\n  for (const [kindName, rawEdge] of Object.entries(rawEdges)) {\n    const path = `/edges/${encodeJsonPointerSegment(kindName)}`;\n\n    if (!isValidKindName(kindName)) {\n      issues.push({\n        path,\n        message: `Edge kind name \"${kindName}\" must match /^[A-Za-z_][A-Za-z0-9_]*$/.`,\n        code: \"INVALID_KIND_NAME\",\n      });\n      continue;\n    }\n\n    if (recorded.has(kindName)) {\n      issues.push({\n        path,\n        message: `Duplicate edge kind name \"${kindName}\".`,\n        code: \"DUPLICATE_KIND_NAME\",\n      });\n      continue;\n    }\n\n    const edge = validateEdgeDocument(kindName, rawEdge, path, issues, strict);\n    if (edge === undefined) continue;\n    result[kindName] = edge;\n    recorded.add(kindName);\n  }\n\n  // Spread at the boundary: this becomes `GraphExtension.edges`.\n  return { ...result };\n}\n\nfunction validateEdgeDocument(\n  kindName: string,\n  raw: unknown,\n  path: string,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): ExtensionEdgeDef | undefined {\n  if (!isPlainObject(raw)) {\n    issues.push({\n      path,\n      message: `Edge \"${kindName}\" must be a plain object.`,\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n\n  if (strict) {\n    rejectUnknownObjectKeys(\n      raw,\n      EDGE_BODY_KEYS,\n      \"edge-level\",\n      path,\n      \"INVALID_DOCUMENT_SHAPE\",\n      issues,\n    );\n  }\n\n  const description = validateOptionalString(\n    raw[\"description\"],\n    `${path}/description`,\n    \"`description`\",\n    \"INVALID_DOCUMENT_SHAPE\",\n    issues,\n  );\n\n  const annotations = validateAnnotations(\n    raw[\"annotations\"],\n    `${path}/annotations`,\n    `Edge \"${kindName}\"`,\n    issues,\n  );\n\n  const from = validateEndpointList(raw[\"from\"], `${path}/from`, issues);\n  let to:\n    readonly string[] | Readonly<Record<string, readonly string[]>> | undefined;\n  if (Array.isArray(raw[\"to\"])) {\n    to = validateEndpointList(raw[\"to\"], `${path}/to`, issues);\n  } else if (isPlainObject(raw[\"to\"])) {\n    to = validateTargetMapping(raw[\"to\"], from, `${path}/to`, issues);\n  } else {\n    issues.push({\n      path: `${path}/to`,\n      message:\n        \"Edge 'to' must be an array of node-kind names or an object mapping source kinds to target kinds.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n  }\n  if (from === undefined || to === undefined) return undefined;\n\n  const propertiesRaw = raw[\"properties\"];\n  const properties =\n    propertiesRaw === undefined ?\n      {}\n    : validatePropertiesMap(\n        propertiesRaw,\n        `${path}/properties`,\n        \"edge\",\n        kindName,\n        issues,\n        strict,\n      );\n  if (properties === undefined) return undefined;\n\n  return compactUndefined<ExtensionEdgeDef>({\n    description,\n    annotations,\n    from,\n    to,\n    properties,\n  });\n}\n\nfunction validateEndpointList(\n  raw: unknown,\n  path: string,\n  issues: GraphExtensionIssue[],\n): readonly string[] | undefined {\n  if (!Array.isArray(raw)) {\n    issues.push({\n      path,\n      message: \"Edge endpoint list must be an array of node-kind names.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n  if (raw.length === 0) {\n    issues.push({\n      path,\n      message: \"Edge endpoint list must contain at least one node-kind name.\",\n      code: \"EMPTY_FROM_OR_TO\",\n    });\n    return undefined;\n  }\n  const names: string[] = [];\n  for (const [index, value] of raw.entries()) {\n    if (typeof value !== \"string\" || value.length === 0) {\n      issues.push({\n        path: `${path}/${index}`,\n        message: \"Edge endpoint must be a non-empty string node-kind name.\",\n        code: \"INVALID_DOCUMENT_SHAPE\",\n      });\n      return undefined;\n    }\n    names.push(value);\n  }\n  return names;\n}\n\nfunction validateTargetMapping(\n  raw: unknown,\n  from: readonly string[] | undefined,\n  path: string,\n  issues: GraphExtensionIssue[],\n): Readonly<Record<string, readonly string[]>> | undefined {\n  if (!isPlainObject(raw)) {\n    issues.push({\n      path,\n      message:\n        \"Edge 'to' mapping must be an object mapping source-kind names to target-kind name arrays.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n  if (from === undefined || from.length === 0) {\n    issues.push({\n      path,\n      message:\n        \"Edge declares source-dependent targets in 'to', but 'from' is missing or empty.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n  const fromSet = new Set(from);\n  const keys = Object.keys(raw);\n  for (const sourceKind of fromSet) {\n    if (!Object.hasOwn(raw, sourceKind)) {\n      issues.push({\n        path: `${path}/${sourceKind}`,\n        message: `Edge is missing target mapping for declared source kind \"${sourceKind}\".`,\n        code: \"INVALID_DOCUMENT_SHAPE\",\n      });\n      return undefined;\n    }\n  }\n  for (const key of keys) {\n    if (!fromSet.has(key)) {\n      issues.push({\n        path: `${path}/${key}`,\n        message: `Edge target mapping key \"${key}\" is not in declared 'from' kinds.`,\n        code: \"INVALID_DOCUMENT_SHAPE\",\n      });\n      return undefined;\n    }\n  }\n  const result = createDataKeyedBag<readonly string[]>();\n  for (const [key, value] of Object.entries(raw)) {\n    const targets = validateEndpointList(value, `${path}/${key}`, issues);\n    if (targets === undefined) return undefined;\n    result[key] = targets;\n  }\n  return { ...result };\n}\n\n// ============================================================\n// Section: ontology\n// ============================================================\n\nfunction validateOntologySection(\n  raw: unknown,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): ExtensionOntologyRelation[] | undefined {\n  if (raw === undefined) return undefined;\n  if (!Array.isArray(raw)) {\n    issues.push({\n      path: \"/ontology\",\n      message: \"`ontology` must be an array of relation objects.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n\n  const result: ExtensionOntologyRelation[] = [];\n  for (const [index, entry] of raw.entries()) {\n    const path = `/ontology/${index}`;\n    if (!isPlainObject(entry)) {\n      issues.push({\n        path,\n        message: \"Ontology entry must be a plain object.\",\n        code: \"INVALID_DOCUMENT_SHAPE\",\n      });\n      continue;\n    }\n    if (strict) {\n      rejectUnknownObjectKeys(\n        entry,\n        ONTOLOGY_ENTRY_KEYS,\n        \"ontology-entry\",\n        path,\n        \"INVALID_DOCUMENT_SHAPE\",\n        issues,\n      );\n    }\n\n    const metaEdge = entry[\"metaEdge\"];\n    const from = entry[\"from\"];\n    const to = entry[\"to\"];\n\n    if (typeof metaEdge !== \"string\" || !META_EDGE_NAME_SET.has(metaEdge)) {\n      issues.push({\n        path: `${path}/metaEdge`,\n        message: `Unknown meta-edge ${describeUnknownValue(metaEdge)}. Allowed: ${[...ALL_META_EDGE_NAMES].join(\", \")}.`,\n        code: \"UNKNOWN_META_EDGE\",\n      });\n      continue;\n    }\n    if (typeof from !== \"string\" || from.length === 0) {\n      issues.push({\n        path: `${path}/from`,\n        message: \"Ontology relation `from` must be a non-empty string.\",\n        code: \"INVALID_DOCUMENT_SHAPE\",\n      });\n      continue;\n    }\n    if (typeof to !== \"string\" || to.length === 0) {\n      issues.push({\n        path: `${path}/to`,\n        message: \"Ontology relation `to` must be a non-empty string.\",\n        code: \"INVALID_DOCUMENT_SHAPE\",\n      });\n      continue;\n    }\n\n    result.push({ metaEdge: metaEdge as MetaEdgeName, from, to });\n  }\n  return result;\n}\n\nfunction validateOntology(\n  ontology: readonly ExtensionOntologyRelation[],\n  issues: GraphExtensionIssue[],\n): void {\n  issues.push(\n    ...validateOntologyRelations(ontology).map((issue) => ({\n      path:\n        issue.relationIndex === undefined ?\n          \"/ontology\"\n        : `/ontology/${issue.relationIndex}`,\n      message: issue.message,\n      code: issue.code,\n    })),\n  );\n}\n\n// ============================================================\n// Section: indexes\n// ============================================================\n\nconst INDEX_SCOPE_VALUES = [\"graphAndKind\", \"graph\", \"none\"] as const;\nconst EDGE_INDEX_DIRECTION_VALUES = [\"out\", \"in\", \"none\"] as const;\n\nconst RUNTIME_INDEX_WHERE_OPS: ReadonlySet<string> = new Set([\n  \"isNull\",\n  \"isNotNull\",\n]);\n\nfunction validateIndexesSection(\n  rawIndexes: unknown,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): readonly ExtensionIndex[] | undefined {\n  if (rawIndexes === undefined) return undefined;\n  if (!Array.isArray(rawIndexes)) {\n    issues.push({\n      path: \"/indexes\",\n      message: \"`indexes` must be an array of index declarations.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n\n  const result: ExtensionIndex[] = [];\n  const seenNames = new Set<string>();\n\n  for (const [arrayIndex, entry] of rawIndexes.entries()) {\n    const path = `/indexes/${arrayIndex}`;\n    const validated = validateIndexEntry(entry, path, issues, strict);\n    if (validated === undefined) continue;\n\n    if (validated.name !== undefined) {\n      if (seenNames.has(validated.name)) {\n        issues.push({\n          path: `${path}/name`,\n          message: `Duplicate index name \"${validated.name}\".`,\n          code: \"DUPLICATE_INDEX_NAME\",\n        });\n        continue;\n      }\n      seenNames.add(validated.name);\n    }\n    result.push(validated);\n  }\n\n  return result;\n}\n\nfunction validateIndexEntry(\n  raw: unknown,\n  path: string,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): ExtensionIndex | undefined {\n  if (!isPlainObject(raw)) {\n    issues.push({\n      path,\n      message: \"Index entry must be a plain object.\",\n      code: \"INVALID_INDEX_DECLARATION\",\n    });\n    return undefined;\n  }\n\n  const entity = raw[\"entity\"];\n  if (entity !== \"node\" && entity !== \"edge\") {\n    issues.push({\n      path: `${path}/entity`,\n      message: `Index \\`entity\\` must be \"node\" or \"edge\"; received ${describeUnknownValue(entity)}.`,\n      code: \"INVALID_INDEX_DECLARATION\",\n    });\n    return undefined;\n  }\n\n  // Strict-authoring typo check: `coveringField` (singular), `wheres`,\n  // etc. would otherwise compile to a weaker index with no signal.\n  // Allowlist switches on `entity` so edge-only `direction` is valid\n  // on edges but flagged on nodes.\n  if (strict) {\n    rejectUnknownObjectKeys(\n      raw,\n      entity === \"node\" ? NODE_INDEX_KEYS : EDGE_INDEX_KEYS,\n      `${entity}-index`,\n      path,\n      \"INVALID_INDEX_DECLARATION\",\n      issues,\n    );\n  }\n\n  if (typeof raw[\"kind\"] !== \"string\" || !isValidKindName(raw[\"kind\"])) {\n    issues.push({\n      path: `${path}/kind`,\n      message:\n        \"Index `kind` must be a non-empty kind name matching /^[A-Za-z_][A-Za-z0-9_]*$/.\",\n      code: \"INVALID_INDEX_DECLARATION\",\n    });\n    return undefined;\n  }\n\n  const fields = validateStringList(raw[\"fields\"], `${path}/fields`, issues, {\n    allowEmpty: false,\n    label: \"fields\",\n    emptyCode: \"EMPTY_INDEX_FIELDS\",\n  });\n  if (fields === undefined) return undefined;\n\n  const coveringFields = validateStringList(\n    raw[\"coveringFields\"],\n    `${path}/coveringFields`,\n    issues,\n    { allowEmpty: true, label: \"coveringFields\" },\n  );\n\n  if (raw[\"unique\"] !== undefined && typeof raw[\"unique\"] !== \"boolean\") {\n    issues.push({\n      path: `${path}/unique`,\n      message: \"Index `unique` must be a boolean.\",\n      code: \"INVALID_INDEX_DECLARATION\",\n    });\n    return undefined;\n  }\n\n  let name: string | undefined;\n  if (raw[\"name\"] !== undefined) {\n    if (typeof raw[\"name\"] !== \"string\" || raw[\"name\"].length === 0) {\n      issues.push({\n        path: `${path}/name`,\n        message: \"Index `name` must be a non-empty string.\",\n        code: \"INVALID_INDEX_DECLARATION\",\n      });\n      return undefined;\n    }\n    name = raw[\"name\"];\n  }\n\n  const scopeResult = validateOptionalLiteral(\n    raw[\"scope\"],\n    INDEX_SCOPE_VALUES,\n    `${path}/scope`,\n    \"Index `scope`\",\n    \"INVALID_INDEX_DECLARATION\",\n    issues,\n  );\n  if (!scopeResult.ok) return undefined;\n  const scope = scopeResult.value;\n\n  const where = validateGraphExtensionIndexWhere(\n    raw[\"where\"],\n    `${path}/where`,\n    issues,\n    strict,\n  );\n\n  if (entity === \"node\") {\n    return compactUndefined<ExtensionIndex>({\n      entity: \"node\",\n      kind: raw[\"kind\"],\n      name,\n      fields,\n      coveringFields,\n      unique: raw[\"unique\"],\n      scope,\n      where,\n    });\n  }\n\n  const directionResult = validateOptionalLiteral(\n    raw[\"direction\"],\n    EDGE_INDEX_DIRECTION_VALUES,\n    `${path}/direction`,\n    \"Edge index `direction`\",\n    \"INVALID_INDEX_DECLARATION\",\n    issues,\n  );\n  if (!directionResult.ok) return undefined;\n  const direction = directionResult.value;\n\n  return compactUndefined<ExtensionIndex>({\n    entity: \"edge\",\n    kind: raw[\"kind\"],\n    name,\n    direction,\n    fields,\n    coveringFields,\n    unique: raw[\"unique\"],\n    scope,\n    where,\n  });\n}\n\nfunction validateStringList(\n  raw: unknown,\n  path: string,\n  issues: GraphExtensionIssue[],\n  options: Readonly<{\n    allowEmpty: boolean;\n    label: string;\n    emptyCode?: GraphExtensionIssueCode;\n  }>,\n): readonly string[] | undefined {\n  if (raw === undefined) {\n    if (options.allowEmpty) return undefined;\n    issues.push({\n      path,\n      message: `\\`${options.label}\\` is required and must contain at least one entry.`,\n      code: options.emptyCode ?? \"INVALID_INDEX_DECLARATION\",\n    });\n    return undefined;\n  }\n  if (!Array.isArray(raw)) {\n    issues.push({\n      path,\n      message: `\\`${options.label}\\` must be an array of strings.`,\n      code: \"INVALID_INDEX_DECLARATION\",\n    });\n    return undefined;\n  }\n  const seen = new Set<string>();\n  const result: string[] = [];\n  for (const [index, value] of raw.entries()) {\n    if (typeof value !== \"string\" || value.length === 0) {\n      issues.push({\n        path: `${path}/${index}`,\n        message: `\\`${options.label}[${index}]\\` must be a non-empty string.`,\n        code: \"INVALID_INDEX_DECLARATION\",\n      });\n      return undefined;\n    }\n    if (seen.has(value)) {\n      issues.push({\n        path: `${path}/${index}`,\n        message: `Duplicate ${options.label} entry \"${value}\".`,\n        code: \"INVALID_INDEX_DECLARATION\",\n      });\n      return undefined;\n    }\n    seen.add(value);\n    result.push(value);\n  }\n  if (!options.allowEmpty && result.length === 0) {\n    issues.push({\n      path,\n      message: `\\`${options.label}\\` must contain at least one entry.`,\n      code: options.emptyCode ?? \"INVALID_INDEX_DECLARATION\",\n    });\n    return undefined;\n  }\n  return result;\n}\n\nfunction validateGraphExtensionIndexWhere(\n  raw: unknown,\n  path: string,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): ExtensionIndex[\"where\"] {\n  if (raw === undefined) return undefined;\n  if (!isPlainObject(raw)) {\n    issues.push({\n      path,\n      message: \"Index `where` must be a plain object.\",\n      code: \"INVALID_INDEX_DECLARATION\",\n    });\n    return undefined;\n  }\n  if (strict) {\n    rejectUnknownObjectKeys(\n      raw,\n      WHERE_CLAUSE_KEYS,\n      \"where-clause\",\n      path,\n      \"INVALID_INDEX_DECLARATION\",\n      issues,\n    );\n  }\n  if (typeof raw[\"field\"] !== \"string\" || raw[\"field\"].length === 0) {\n    issues.push({\n      path: `${path}/field`,\n      message: \"`where.field` must be a non-empty string.\",\n      code: \"INVALID_INDEX_DECLARATION\",\n    });\n    return undefined;\n  }\n  if (\n    typeof raw[\"op\"] !== \"string\" ||\n    !RUNTIME_INDEX_WHERE_OPS.has(raw[\"op\"])\n  ) {\n    issues.push({\n      path: `${path}/op`,\n      message: '`where.op` must be \"isNull\" or \"isNotNull\" in v1.',\n      code: \"INVALID_INDEX_DECLARATION\",\n    });\n    return undefined;\n  }\n  return Object.freeze({\n    field: raw[\"field\"],\n    op: raw[\"op\"] as NullCheckOp,\n  });\n}\n\n// ============================================================\n// Properties and refinements\n// ============================================================\n\n/**\n * Refuses a property name the SCHEMA LAYER cannot carry, at any nesting level.\n *\n * Zod accepts `__proto__` in a shape but drops it from every parse result — and\n * reports success even when the field is required — so a value written to such\n * a field is silently lost. The declaration is refused rather than accepted as\n * a field the storage layer can never honor.\n *\n * This DOCUMENT walker and the Zod-schema walker behind `defineNode` /\n * `defineEdge` stay separate — one traverses JSON property descriptors, the\n * other Zod wrappers, and neither structure can be expressed in the other — but\n * the VERDICT is not duplicated: both ask\n * {@link isUnstorablePropertyName} and both quote\n * {@link UNSTORABLE_PROPERTY_NAME_REASON}, so the two refusals cannot drift into\n * disagreeing about the same field.\n *\n * Within this walker it is likewise the single owner. Both the top-level\n * `properties` map and a nested `object.properties` map ask here: the two maps\n * compile through the same `z.object(...)` (see `buildObjectSchema` in\n * ./compiler.ts), so a name unstorable at the top level is equally unstorable\n * one level down, and a refusal that fired on only one of them would let a\n * document declare a field that validates clean and then vanishes at parse.\n *\n * @returns `true` when the name was refused (an issue has been pushed).\n */\nfunction refuseUnstorablePropertyName(\n  propertyName: string,\n  propertyPath: string,\n  owner: string,\n  issues: GraphExtensionIssue[],\n): boolean {\n  if (!isUnstorablePropertyName(propertyName)) return false;\n  issues.push({\n    path: propertyPath,\n    message: `Property name \"${propertyName}\" is not allowed for ${owner}: ${UNSTORABLE_PROPERTY_NAME_REASON}.`,\n    code: \"RESERVED_PROPERTY_NAME\",\n  });\n  return true;\n}\n\nfunction validatePropertiesMap(\n  raw: unknown,\n  path: string,\n  ownerType: KindEntity,\n  ownerName: string,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): Record<string, ExtensionPropertyType> | undefined {\n  if (!isPlainObject(raw)) {\n    issues.push({\n      path,\n      message: `\\`properties\\` must be a plain object.`,\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n\n  const reserved =\n    ownerType === \"node\" ? RESERVED_NODE_KEYS : RESERVED_EDGE_KEYS;\n  // Property names are DATA, and unrestricted apart from the reserved list and\n  // the `$` prefix — `__proto__` reaches here from any JSON document.\n  const result = createDataKeyedBag<ExtensionPropertyType>();\n  for (const [propertyName, propertyValue] of Object.entries(raw)) {\n    const propertyPath = `${path}/${encodeJsonPointerSegment(propertyName)}`;\n    if (\n      refuseUnstorablePropertyName(\n        propertyName,\n        propertyPath,\n        `${ownerType} \"${ownerName}\"`,\n        issues,\n      )\n    ) {\n      continue;\n    }\n    if (reserved.has(propertyName)) {\n      issues.push({\n        path: propertyPath,\n        message: `Property name \"${propertyName}\" is reserved for ${ownerType} \"${ownerName}\".`,\n        code: \"RESERVED_PROPERTY_NAME\",\n      });\n      continue;\n    }\n    if (propertyName.startsWith(\"$\")) {\n      issues.push({\n        path: propertyPath,\n        message: `Property name \"${propertyName}\" uses the reserved \"$\" prefix.`,\n        code: \"RESERVED_PROPERTY_NAME\",\n      });\n      continue;\n    }\n    const validated = validateProperty(\n      propertyValue,\n      propertyPath,\n      0,\n      issues,\n      strict,\n    );\n    if (validated === undefined) continue;\n    result[propertyName] = validated;\n  }\n\n  // Spread at the boundary: this becomes `ExtensionNodeDef.properties` on the\n  // returned document.\n  return { ...result };\n}\n\nfunction validateProperty(\n  raw: unknown,\n  path: string,\n  depth: number,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): ExtensionPropertyType | undefined {\n  if (!isPlainObject(raw)) {\n    issues.push({\n      path,\n      message:\n        \"Property descriptor must be a plain object with a `type` field.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n  const property = raw;\n  const type = property[\"type\"];\n  if (typeof type !== \"string\" || !SUPPORTED_PROPERTY_TYPES.has(type)) {\n    issues.push({\n      path: `${path}/type`,\n      message: `Unsupported property type ${describeUnknownValue(type)}. Supported: ${[...SUPPORTED_PROPERTY_TYPES].join(\", \")}.`,\n      code: \"UNSUPPORTED_PROPERTY_TYPE\",\n    });\n    return undefined;\n  }\n\n  // Strict authoring mode: reject unknown sibling keys against the\n  // per-type allowlist BEFORE dispatch. A typo like `minLenght` on a\n  // string property would otherwise compile to a `z.string()` with no\n  // length constraint and ship through to ingest. Persistence-load\n  // mode skips this so a future v1.x.y writer's additive keys ride\n  // forward.\n  if (strict) rejectUnknownPropertyKeys(property, type, path, issues);\n\n  switch (type) {\n    case \"string\": {\n      return validateStringProperty(property, path, issues, strict);\n    }\n    case \"number\": {\n      return validateNumberProperty(property, path, issues);\n    }\n    case \"boolean\": {\n      return validateBooleanProperty(property, path, issues);\n    }\n    case \"enum\": {\n      return validateEnumProperty(property, path, issues);\n    }\n    case \"array\": {\n      return validateArrayProperty(property, path, depth, issues, strict);\n    }\n    case \"object\": {\n      return validateObjectProperty(property, path, depth, issues, strict);\n    }\n  }\n  return undefined;\n}\n\nfunction validateStringProperty(\n  raw: Record<string, unknown>,\n  path: string,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): ExtensionStringProperty | undefined {\n  const minLength = validateNonNegativeInteger(\n    raw[\"minLength\"],\n    `${path}/minLength`,\n    \"string.minLength\",\n    \"INVALID_LENGTH_BOUNDS\",\n    issues,\n  );\n  const maxLength = validateNonNegativeInteger(\n    raw[\"maxLength\"],\n    `${path}/maxLength`,\n    \"string.maxLength\",\n    \"INVALID_LENGTH_BOUNDS\",\n    issues,\n  );\n  if (\n    minLength !== undefined &&\n    maxLength !== undefined &&\n    minLength > maxLength\n  ) {\n    issues.push({\n      path,\n      message: `string.minLength (${minLength}) cannot exceed string.maxLength (${maxLength}).`,\n      code: \"INVALID_LENGTH_BOUNDS\",\n    });\n  }\n\n  let pattern: string | undefined;\n  if (raw[\"pattern\"] !== undefined) {\n    if (typeof raw[\"pattern\"] === \"string\") {\n      try {\n        new RegExp(raw[\"pattern\"]);\n        pattern = raw[\"pattern\"];\n      } catch (error) {\n        issues.push({\n          path: `${path}/pattern`,\n          message: `Pattern is not a valid regular expression: ${\n            error instanceof Error ? error.message : String(error)\n          }`,\n          code: \"INVALID_PATTERN\",\n        });\n      }\n    } else {\n      issues.push({\n        path: `${path}/pattern`,\n        message: \"`pattern` must be a string regular expression.\",\n        code: \"INVALID_PATTERN\",\n      });\n    }\n  }\n\n  let format: ExtensionStringProperty[\"format\"];\n  if (raw[\"format\"] !== undefined) {\n    if (typeof raw[\"format\"] !== \"string\") {\n      issues.push({\n        path: `${path}/format`,\n        message: `String format must be a string; received ${describeUnknownValue(raw[\"format\"])}.`,\n        code: \"INVALID_PROPERTY_REFINEMENT\",\n      });\n    } else if (SUPPORTED_STRING_FORMATS.has(raw[\"format\"])) {\n      format = raw[\"format\"] as ExtensionStringProperty[\"format\"];\n    } else if (strict) {\n      // Authoring-mode reject. A typo like `\"date-time\"` (no\n      // hyphen) silently compiled to a plain `z.string()` in earlier\n      // versions, so `safeParse(\"not-a-date\")` succeeded — surfacing\n      // the typo here is the contract.\n      issues.push({\n        path: `${path}/format`,\n        message: `Unsupported string format \"${raw[\"format\"]}\". Supported: ${[...SUPPORTED_STRING_FORMATS].join(\", \")}.`,\n        code: \"UNSUPPORTED_STRING_FORMAT\",\n      });\n    }\n    // Non-strict (persistence-load) path: unknown format silently\n    // drops to a plain `z.string()`. A future v1.x.y writer may\n    // introduce a new format identifier; an older v1 reader still\n    // parses the document, just without the new format's behaviour.\n  }\n\n  const modifiers = validatePropertyModifiers(raw, path, \"string\", issues);\n  if (modifiers === undefined) return undefined;\n\n  if (format !== undefined && modifiers.searchable !== undefined) {\n    issues.push({\n      path,\n      message:\n        \"`searchable` cannot be combined with `format` on a string property — the format-specific schema cannot carry the searchable brand. Drop one, or split into two fields.\",\n      code: \"INVALID_PROPERTY_REFINEMENT\",\n    });\n    return undefined;\n  }\n\n  if (\n    format !== undefined &&\n    (minLength !== undefined ||\n      maxLength !== undefined ||\n      pattern !== undefined)\n  ) {\n    issues.push({\n      path,\n      message:\n        \"`format` cannot be combined with `minLength`, `maxLength`, or `pattern` on a string property — the format-routed schema (`z.iso.datetime` / `z.url`) is not a `z.ZodString` and cannot carry length or pattern refinements. Drop the refinement, or drop the format and validate the shape with `pattern`.\",\n      code: \"INVALID_PROPERTY_REFINEMENT\",\n    });\n    return undefined;\n  }\n\n  return finalizeProperty<ExtensionStringProperty>(\n    \"string\",\n    { minLength, maxLength, pattern, format },\n    modifiers,\n  );\n}\n\nfunction validateNumberProperty(\n  raw: Record<string, unknown>,\n  path: string,\n  issues: GraphExtensionIssue[],\n): ExtensionNumberProperty | undefined {\n  // Forward-compat: unknown refinement keys are silently accepted.\n  const min = validateOptionalFiniteNumber(\n    raw[\"min\"],\n    `${path}/min`,\n    \"`min`\",\n    \"INVALID_NUMBER_BOUNDS\",\n    issues,\n  );\n  const max = validateOptionalFiniteNumber(\n    raw[\"max\"],\n    `${path}/max`,\n    \"`max`\",\n    \"INVALID_NUMBER_BOUNDS\",\n    issues,\n  );\n  if (min !== undefined && max !== undefined && min > max) {\n    issues.push({\n      path,\n      message: `number.min (${min}) cannot exceed number.max (${max}).`,\n      code: \"INVALID_NUMBER_BOUNDS\",\n    });\n  }\n\n  const int = validateOptionalBoolean(\n    raw[\"int\"],\n    `${path}/int`,\n    \"`int`\",\n    \"INVALID_PROPERTY_REFINEMENT\",\n    issues,\n  );\n\n  // Integer + non-integer bounds: reject early so the compiled Zod schema\n  // doesn't silently swallow values like `min: 1.5, int: true`.\n  if (int === true) {\n    if (min !== undefined && !Number.isInteger(min)) {\n      issues.push({\n        path: `${path}/min`,\n        message: \"`min` must be an integer when `int: true`.\",\n        code: \"INVALID_NUMBER_BOUNDS\",\n      });\n    }\n    if (max !== undefined && !Number.isInteger(max)) {\n      issues.push({\n        path: `${path}/max`,\n        message: \"`max` must be an integer when `int: true`.\",\n        code: \"INVALID_NUMBER_BOUNDS\",\n      });\n    }\n  }\n\n  const modifiers = validatePropertyModifiers(raw, path, \"number\", issues);\n  if (modifiers === undefined) return undefined;\n\n  return finalizeProperty<ExtensionNumberProperty>(\n    \"number\",\n    { min, max, int },\n    modifiers,\n  );\n}\n\nfunction validateBooleanProperty(\n  raw: Record<string, unknown>,\n  path: string,\n  issues: GraphExtensionIssue[],\n): ExtensionBooleanProperty | undefined {\n  const modifiers = validatePropertyModifiers(raw, path, \"boolean\", issues);\n  if (modifiers === undefined) return undefined;\n  return finalizeProperty<ExtensionBooleanProperty>(\"boolean\", {}, modifiers);\n}\n\nfunction validateEnumProperty(\n  raw: Record<string, unknown>,\n  path: string,\n  issues: GraphExtensionIssue[],\n): ExtensionEnumProperty | undefined {\n  // Forward-compat: unknown refinement keys are silently accepted.\n  const valuesRaw = raw[\"values\"];\n  if (!Array.isArray(valuesRaw) || valuesRaw.length === 0) {\n    issues.push({\n      path: `${path}/values`,\n      message: \"`enum.values` must be a non-empty array of strings.\",\n      code: \"INVALID_ENUM_VALUES\",\n    });\n    return undefined;\n  }\n\n  const values: string[] = [];\n  const seen = new Set<string>();\n  for (const [index, value] of valuesRaw.entries()) {\n    if (typeof value !== \"string\") {\n      issues.push({\n        path: `${path}/values/${index}`,\n        message: \"`enum.values` entries must be strings.\",\n        code: \"INVALID_ENUM_VALUES\",\n      });\n      return undefined;\n    }\n    if (seen.has(value)) {\n      issues.push({\n        path: `${path}/values/${index}`,\n        message: `Duplicate enum value \"${value}\".`,\n        code: \"INVALID_ENUM_VALUES\",\n      });\n      return undefined;\n    }\n    seen.add(value);\n    values.push(value);\n  }\n\n  const modifiers = validatePropertyModifiers(raw, path, \"enum\", issues);\n  if (modifiers === undefined) return undefined;\n\n  return finalizeProperty<ExtensionEnumProperty>(\"enum\", { values }, modifiers);\n}\n\nfunction validateArrayProperty(\n  raw: Record<string, unknown>,\n  path: string,\n  depth: number,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): ExtensionArrayProperty | undefined {\n  // Forward-compat: unknown refinement keys are silently accepted.\n  const itemsRaw = raw[\"items\"];\n  if (itemsRaw === undefined) {\n    issues.push({\n      path: `${path}/items`,\n      message: \"`array.items` is required.\",\n      code: \"INVALID_PROPERTY_REFINEMENT\",\n    });\n    return undefined;\n  }\n  if (!isPlainObject(itemsRaw)) {\n    issues.push({\n      path: `${path}/items`,\n      message: \"`array.items` must be a plain property descriptor.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n  const itemType = itemsRaw[\"type\"];\n  if (itemType === \"array\") {\n    issues.push({\n      path: `${path}/items`,\n      message: \"Nested arrays are not supported in v1.\",\n      code: \"NESTED_ARRAY\",\n    });\n    return undefined;\n  }\n  const items = validateProperty(\n    itemsRaw,\n    `${path}/items`,\n    depth + 1,\n    issues,\n    strict,\n  );\n  if (items === undefined) return undefined;\n  if (items.type === \"array\") {\n    // Type-narrow only: `validateProperty` returns the wider\n    // `ExtensionPropertyType`, but `ExtensionArrayItemType` excludes\n    // nested arrays. The earlier `itemType === \"array\"` check above\n    // already rejected this at the raw-shape level, so this branch\n    // is unreachable at runtime.\n    return undefined;\n  }\n\n  const modifiers = validatePropertyModifiers(raw, path, \"array\", issues);\n  if (modifiers === undefined) return undefined;\n\n  return finalizeProperty<ExtensionArrayProperty>(\n    \"array\",\n    { items },\n    modifiers,\n  );\n}\n\nfunction validateObjectProperty(\n  raw: Record<string, unknown>,\n  path: string,\n  depth: number,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): ExtensionObjectProperty | undefined {\n  // Forward-compat: unknown refinement keys are silently accepted.\n  if (depth >= 1) {\n    issues.push({\n      path,\n      message: \"Nested objects are limited to a single level in v1.\",\n      code: \"NESTED_OBJECT_TOO_DEEP\",\n    });\n    return undefined;\n  }\n\n  const propertiesRaw = raw[\"properties\"];\n  if (!isPlainObject(propertiesRaw)) {\n    issues.push({\n      path: `${path}/properties`,\n      message: \"`object.properties` must be a plain object.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n\n  const propertiesEntries = Object.entries(propertiesRaw);\n  if (propertiesEntries.length === 0) {\n    issues.push({\n      path: `${path}/properties`,\n      message: \"`object.properties` must declare at least one field.\",\n      code: \"EMPTY_PROPERTIES\",\n    });\n    return undefined;\n  }\n\n  // Data-keyed: nested object field names read out of the document.\n  const fields = createDataKeyedBag<ExtensionObjectFieldProperty>();\n  for (const [name, value] of propertiesEntries) {\n    const fieldPath = `${path}/properties/${encodeJsonPointerSegment(name)}`;\n    if (\n      refuseUnstorablePropertyName(name, fieldPath, \"a nested object\", issues)\n    ) {\n      continue;\n    }\n    if (!isPlainObject(value)) {\n      issues.push({\n        path: fieldPath,\n        message: \"Object field descriptor must be a plain object.\",\n        code: \"INVALID_DOCUMENT_SHAPE\",\n      });\n      continue;\n    }\n    const fieldType = value[\"type\"];\n    if (fieldType === \"object\") {\n      issues.push({\n        path: fieldPath,\n        message: \"Nested objects are limited to a single level in v1.\",\n        code: \"NESTED_OBJECT_TOO_DEEP\",\n      });\n      continue;\n    }\n    const field = validateProperty(value, fieldPath, depth + 1, issues, strict);\n    if (field === undefined) continue;\n    fields[name] = field as ExtensionObjectFieldProperty;\n  }\n\n  const modifiers = validatePropertyModifiers(raw, path, \"object\", issues);\n  if (modifiers === undefined) return undefined;\n\n  return finalizeProperty<ExtensionObjectProperty>(\n    \"object\",\n    { properties: { ...fields } },\n    modifiers,\n  );\n}\n\n// ============================================================\n// Modifiers\n// ============================================================\n\ntype NormalizedModifiers = Readonly<{\n  optional?: boolean;\n  searchable?: { language?: string };\n  embedding?: { dimensions: number };\n  description?: string;\n}>;\n\n/**\n * Assemble a final property descriptor from a type-specific field map\n * plus the already-validated modifiers. Centralizes the modifier-spread\n * boilerplate so adding a new modifier slot (or tweaking how undefineds\n * are pruned) touches one site instead of six.\n *\n * Callers run `validatePropertyModifiers` first because some types\n * (`string`) need cross-modifier validation (e.g. `format` ↔ `searchable`)\n * after the modifiers are known but before the final shape is built.\n */\nfunction finalizeProperty<T extends ExtensionPropertyType>(\n  type: T[\"type\"],\n  specific: Record<string, unknown>,\n  modifiers: NormalizedModifiers,\n): T {\n  return compactUndefined<Record<string, unknown>>({\n    type,\n    ...specific,\n    optional: modifiers.optional,\n    searchable: modifiers.searchable,\n    embedding: modifiers.embedding,\n    description: modifiers.description,\n  }) as T;\n}\n\nfunction validatePropertyModifiers(\n  raw: Record<string, unknown>,\n  path: string,\n  propertyType: ExtensionPropertyType[\"type\"],\n  issues: GraphExtensionIssue[],\n): NormalizedModifiers | undefined {\n  // Mirrors `issues.length` rather than carrying its own boolean: any\n  // helper that pushes also signals failure here.\n  const issuesAtEntry = issues.length;\n\n  const optional = validateOptionalBoolean(\n    raw[\"optional\"],\n    `${path}/optional`,\n    \"`optional`\",\n    \"INVALID_PROPERTY_REFINEMENT\",\n    issues,\n  );\n\n  let searchable: { language?: string } | undefined;\n  if (raw[\"searchable\"] !== undefined) {\n    if (propertyType !== \"string\") {\n      issues.push({\n        path: `${path}/searchable`,\n        message: `\\`searchable\\` is only valid on string properties (got \"${propertyType}\").`,\n        code: \"INVALID_MODIFIER_TARGET\",\n      });\n    } else if (isPlainObject(raw[\"searchable\"])) {\n      const searchableRaw = raw[\"searchable\"];\n      const language = searchableRaw[\"language\"];\n      if (language === undefined) {\n        searchable = {};\n      } else {\n        if (typeof language !== \"string\" || language.length === 0) {\n          issues.push({\n            path: `${path}/searchable/language`,\n            message: \"`searchable.language` must be a non-empty string.\",\n            code: \"INVALID_SEARCHABLE_LANGUAGE\",\n          });\n        } else {\n          searchable = { language };\n        }\n      }\n    } else {\n      issues.push({\n        path: `${path}/searchable`,\n        message: \"`searchable` must be a plain object (use `{}` for defaults).\",\n        code: \"INVALID_PROPERTY_REFINEMENT\",\n      });\n    }\n  }\n\n  let embedding: { dimensions: number } | undefined;\n  if (raw[\"embedding\"] !== undefined) {\n    if (propertyType === \"array\") {\n      const itemsRaw = raw[\"items\"];\n      const itemType = isPlainObject(itemsRaw) ? itemsRaw[\"type\"] : undefined;\n      if (itemType !== \"number\") {\n        issues.push({\n          path: `${path}/embedding`,\n          message: '`embedding` requires `array.items.type === \"number\"`.',\n          code: \"INVALID_MODIFIER_TARGET\",\n        });\n      } else if (isPlainObject(raw[\"embedding\"])) {\n        const dim = raw[\"embedding\"][\"dimensions\"];\n        if (typeof dim !== \"number\" || !Number.isInteger(dim) || dim <= 0) {\n          issues.push({\n            path: `${path}/embedding/dimensions`,\n            message: \"`embedding.dimensions` must be a positive integer.\",\n            code: \"INVALID_EMBEDDING_DIMENSIONS\",\n          });\n        } else {\n          // `embedding(dimensions)` replaces the array's item validator with a\n          // length+finite-number check; any extra refinements on the items\n          // (min, max, int) would silently disappear at compile time.\n          const itemsObject = isPlainObject(itemsRaw) ? itemsRaw : {};\n          const extraneous = Object.keys(itemsObject).filter(\n            (key) => key !== \"type\",\n          );\n          if (extraneous.length > 0) {\n            issues.push({\n              path: `${path}/items`,\n              message: `\\`embedding\\` arrays must declare items as \\`{ type: \"number\" }\\` only — additional refinements (${extraneous.join(\", \")}) are silently dropped by the embedding schema. Drop the refinements, or drop \\`embedding\\` and use a plain array.`,\n              code: \"INVALID_PROPERTY_REFINEMENT\",\n            });\n          } else {\n            embedding = { dimensions: dim };\n          }\n        }\n      } else {\n        issues.push({\n          path: `${path}/embedding`,\n          message:\n            \"`embedding` must be a plain object with a `dimensions` field.\",\n          code: \"INVALID_PROPERTY_REFINEMENT\",\n        });\n      }\n    } else {\n      issues.push({\n        path: `${path}/embedding`,\n        message: `\\`embedding\\` is only valid on array-of-number properties (got \"${propertyType}\").`,\n        code: \"INVALID_MODIFIER_TARGET\",\n      });\n    }\n  }\n\n  let description: string | undefined;\n  if (raw[\"description\"] !== undefined) {\n    if (typeof raw[\"description\"] === \"string\") {\n      description = raw[\"description\"];\n    } else {\n      issues.push({\n        path: `${path}/description`,\n        message: \"`description` must be a string.\",\n        code: \"INVALID_PROPERTY_REFINEMENT\",\n      });\n    }\n  }\n\n  if (issues.length > issuesAtEntry) return undefined;\n  return compactUndefined<NormalizedModifiers>({\n    optional,\n    searchable,\n    embedding,\n    description,\n  });\n}\n\n// ============================================================\n// Unique constraints\n// ============================================================\n\nfunction validateUniqueConstraints(\n  raw: unknown,\n  path: string,\n  properties: Record<string, ExtensionPropertyType>,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): readonly ExtensionUniqueConstraint[] | undefined {\n  if (raw === undefined) return undefined;\n  if (!Array.isArray(raw)) {\n    issues.push({\n      path,\n      message: \"`unique` must be an array of constraint declarations.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n\n  const result: ExtensionUniqueConstraint[] = [];\n  const names = new Set<string>();\n  for (const [index, entry] of raw.entries()) {\n    const constraintPath = `${path}/${index}`;\n    if (!isPlainObject(entry)) {\n      issues.push({\n        path: constraintPath,\n        message: \"Unique constraint must be a plain object.\",\n        code: \"INVALID_DOCUMENT_SHAPE\",\n      });\n      continue;\n    }\n\n    if (strict) {\n      rejectUnknownObjectKeys(\n        entry,\n        UNIQUE_CONSTRAINT_KEYS,\n        \"unique-constraint\",\n        constraintPath,\n        \"INVALID_DOCUMENT_SHAPE\",\n        issues,\n      );\n    }\n\n    const constraint = entry;\n    const name = constraint[\"name\"];\n    if (typeof name !== \"string\" || name.length === 0) {\n      issues.push({\n        path: `${constraintPath}/name`,\n        message: \"Unique constraint `name` must be a non-empty string.\",\n        code: \"INVALID_DOCUMENT_SHAPE\",\n      });\n      continue;\n    }\n    if (names.has(name)) {\n      issues.push({\n        path: `${constraintPath}/name`,\n        message: `Duplicate unique constraint name \"${name}\".`,\n        code: \"DUPLICATE_UNIQUE_CONSTRAINT\",\n      });\n      continue;\n    }\n    names.add(name);\n\n    const fieldsRaw = constraint[\"fields\"];\n    if (!Array.isArray(fieldsRaw) || fieldsRaw.length === 0) {\n      issues.push({\n        path: `${constraintPath}/fields`,\n        message:\n          \"Unique constraint `fields` must be a non-empty array of property names.\",\n        code: \"EMPTY_UNIQUE_FIELDS\",\n      });\n      continue;\n    }\n\n    const fields: string[] = [];\n    const seenFields = new Set<string>();\n    let fieldsValid = true;\n    for (const [fieldIndex, field] of fieldsRaw.entries()) {\n      if (typeof field !== \"string\" || field.length === 0) {\n        issues.push({\n          path: `${constraintPath}/fields/${fieldIndex}`,\n          message: \"Unique constraint field must be a non-empty string.\",\n          code: \"INVALID_DOCUMENT_SHAPE\",\n        });\n        fieldsValid = false;\n        break;\n      }\n      if (seenFields.has(field)) {\n        issues.push({\n          path: `${constraintPath}/fields/${fieldIndex}`,\n          message: `Duplicate field \"${field}\" in unique constraint.`,\n          code: \"DUPLICATE_UNIQUE_FIELD\",\n        });\n        fieldsValid = false;\n        break;\n      }\n      if (!hasOwnKey(properties, field)) {\n        issues.push({\n          path: `${constraintPath}/fields/${fieldIndex}`,\n          message: `Unique constraint field \"${field}\" is not declared on this kind.`,\n          code: \"UNKNOWN_UNIQUE_FIELD\",\n        });\n        fieldsValid = false;\n        break;\n      }\n      seenFields.add(field);\n      fields.push(field);\n    }\n    if (!fieldsValid) continue;\n\n    const scopeResult = validateOptionalLiteral(\n      constraint[\"scope\"],\n      [\"kind\", \"kindWithSubClasses\"] as const,\n      `${constraintPath}/scope`,\n      \"Unique constraint `scope`\",\n      \"INVALID_DOCUMENT_SHAPE\",\n      issues,\n    );\n    if (!scopeResult.ok) continue;\n    const scope = scopeResult.value;\n\n    const collationResult = validateOptionalLiteral(\n      constraint[\"collation\"],\n      [\"binary\", \"caseInsensitive\"] as const,\n      `${constraintPath}/collation`,\n      \"Unique constraint `collation`\",\n      \"INVALID_DOCUMENT_SHAPE\",\n      issues,\n    );\n    if (!collationResult.ok) continue;\n    const collation = collationResult.value;\n\n    const where: { field: string; op: NullCheckOp } | undefined =\n      constraint[\"where\"] === undefined ?\n        undefined\n      : validateUniqueWhere(\n          constraint[\"where\"],\n          `${constraintPath}/where`,\n          properties,\n          issues,\n          strict,\n        );\n    if (constraint[\"where\"] !== undefined && where === undefined) continue;\n\n    result.push(\n      compactUndefined<ExtensionUniqueConstraint>({\n        name,\n        fields,\n        scope,\n        collation,\n        where,\n      }),\n    );\n  }\n\n  return result;\n}\n\nfunction validateUniqueWhere(\n  raw: unknown,\n  path: string,\n  properties: Record<string, ExtensionPropertyType>,\n  issues: GraphExtensionIssue[],\n  strict: boolean,\n): { field: string; op: NullCheckOp } | undefined {\n  if (!isPlainObject(raw)) {\n    issues.push({\n      path,\n      message: \"Unique constraint `where` must be `{ field, op }`.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n  if (strict) {\n    rejectUnknownObjectKeys(\n      raw,\n      WHERE_CLAUSE_KEYS,\n      \"where-clause\",\n      path,\n      \"INVALID_DOCUMENT_SHAPE\",\n      issues,\n    );\n  }\n  const field = raw[\"field\"];\n  const op = raw[\"op\"];\n  if (typeof field !== \"string\" || field.length === 0) {\n    issues.push({\n      path: `${path}/field`,\n      message: \"Unique `where.field` must be a non-empty string.\",\n      code: \"INVALID_DOCUMENT_SHAPE\",\n    });\n    return undefined;\n  }\n  if (!hasOwnKey(properties, field)) {\n    issues.push({\n      path: `${path}/field`,\n      message: `Unique \\`where.field\\` \"${field}\" is not declared on this kind.`,\n      code: \"UNKNOWN_UNIQUE_WHERE_FIELD\",\n    });\n    return undefined;\n  }\n  if (op !== \"isNull\" && op !== \"isNotNull\") {\n    issues.push({\n      path: `${path}/op`,\n      message: `Unique \\`where.op\\` must be \"isNull\" or \"isNotNull\" (got ${describeUnknownValue(op)}).`,\n      code: \"INVALID_UNIQUE_WHERE_OP\",\n    });\n    return undefined;\n  }\n  return { field, op };\n}\n\n// ============================================================\n// Annotations\n// ============================================================\n\nfunction validateAnnotations<\n  T extends GraphAnnotations | KindAnnotations = KindAnnotations,\n>(\n  raw: unknown,\n  path: string,\n  ownerLabel: string,\n  issues: GraphExtensionIssue[],\n): T | undefined {\n  if (raw === undefined) return undefined;\n  if (!isPlainObject(raw)) {\n    issues.push({\n      path,\n      message: `Annotations must be a plain JSON object.`,\n      code: \"INVALID_ANNOTATION\",\n    });\n    return undefined;\n  }\n\n  try {\n    assertJsonValue(raw, \"annotations\", ownerLabel);\n  } catch (error) {\n    if (error instanceof ConfigurationError) {\n      const detailPath = (error.details as Record<string, unknown>)[\"path\"];\n      const annotationPath =\n        typeof detailPath === \"string\" ?\n          `${path}/${detailPath\n            .replace(/^annotations\\.?/, \"\")\n            .replaceAll(\".\", \"/\")}`\n        : path;\n      issues.push({\n        path: annotationPath,\n        message: error.message,\n        code: \"INVALID_ANNOTATION\",\n      });\n      return undefined;\n    }\n    throw error;\n  }\n\n  return raw as T;\n}\n\n// ============================================================\n// Helpers\n// ============================================================\n\n// Two-mode unknown-key handling — see `rejectUnknownPropertyKeys`\n// above. Strict authoring (`defineGraphExtension`,\n// `validateGraphExtension(_, { strict: true })`) rejects unknown\n// sibling keys at every property level so a `minLenght`-style typo\n// from an LLM proposal surfaces with a JSON-pointer path instead of\n// silently compiling to a weaker schema. Persistence load\n// (`validateGraphExtension(_, { strict: false })`, used by the\n// `createStoreWithSchema` reader) ignores unknown keys so a future\n// v1.x.y writer with additive refinements still parses on an older\n// v1 reader — the older compiler builds the Zod schema from the\n// refinements it recognizes, and the new modifier's behavior simply\n// isn't applied. `ExtensionPropertyType` is exported so consumers\n// writing runtime-shape generators can add their own strict-key check\n// if needed for additional validation slots beyond what this\n// validator covers.\n\nfunction validateNonNegativeInteger(\n  value: unknown,\n  path: string,\n  label: string,\n  code: GraphExtensionIssueCode,\n  issues: GraphExtensionIssue[],\n): number | undefined {\n  if (value === undefined) return undefined;\n  if (typeof value !== \"number\" || !Number.isInteger(value) || value < 0) {\n    issues.push({\n      path,\n      message: `${label} must be a non-negative integer.`,\n      code,\n    });\n    return undefined;\n  }\n  return value;\n}\n\nfunction validateOptionalString(\n  value: unknown,\n  path: string,\n  label: string,\n  code: GraphExtensionIssueCode,\n  issues: GraphExtensionIssue[],\n): string | undefined {\n  if (value === undefined) return undefined;\n  if (typeof value !== \"string\") {\n    issues.push({ path, message: `${label} must be a string.`, code });\n    return undefined;\n  }\n  return value;\n}\n\nfunction validateOptionalBoolean(\n  value: unknown,\n  path: string,\n  label: string,\n  code: GraphExtensionIssueCode,\n  issues: GraphExtensionIssue[],\n): boolean | undefined {\n  if (value === undefined) return undefined;\n  if (typeof value !== \"boolean\") {\n    issues.push({ path, message: `${label} must be a boolean.`, code });\n    return undefined;\n  }\n  return value;\n}\n\nfunction validateOptionalFiniteNumber(\n  value: unknown,\n  path: string,\n  label: string,\n  code: GraphExtensionIssueCode,\n  issues: GraphExtensionIssue[],\n): number | undefined {\n  if (value === undefined) return undefined;\n  if (typeof value !== \"number\" || !Number.isFinite(value)) {\n    issues.push({ path, message: `${label} must be a finite number.`, code });\n    return undefined;\n  }\n  return value;\n}\n\n/**\n * Discriminated result for optional-literal validation: callers branch\n * on `ok` so \"absent\" (`{ ok: true, value: undefined }`) is distinct from\n * \"invalid\" (`{ ok: false }`). Replaces the prior issue-counter trick\n * (`const before = issues.length; … if (issues.length > before) …`)\n * which conflated those two outcomes when the underlying helper\n * returned `T | undefined`.\n */\ntype OptionalLiteralResult<T> =\n  Readonly<{ ok: true; value: T | undefined }> | Readonly<{ ok: false }>;\n\nfunction validateOptionalLiteral<T extends string>(\n  value: unknown,\n  allowed: readonly T[],\n  path: string,\n  label: string,\n  code: GraphExtensionIssueCode,\n  issues: GraphExtensionIssue[],\n): OptionalLiteralResult<T> {\n  if (value === undefined) return { ok: true, value: undefined };\n  if (typeof value !== \"string\" || !allowed.includes(value as T)) {\n    const list = allowed.map((entry) => `\"${entry}\"`).join(\", \");\n    issues.push({ path, message: `${label} must be one of: ${list}.`, code });\n    return { ok: false };\n  }\n  return { ok: true, value: value as T };\n}\n\nfunction isValidKindName(name: string): boolean {\n  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);\n}\n\n/**\n * Renders an unknown value for inclusion in an error message without\n * tripping `[object Object]` from a generic `String()` call. Strings\n * are quoted; numbers, booleans, and null pass through; other values\n * use `JSON.stringify` and fall back to `typeof` if that fails.\n */\nfunction describeUnknownValue(value: unknown): string {\n  if (typeof value === \"string\") return `\"${value}\"`;\n  if (\n    value === null ||\n    typeof value === \"number\" ||\n    typeof value === \"boolean\"\n  ) {\n    return JSON.stringify(value);\n  }\n  try {\n    return JSON.stringify(value);\n  } catch {\n    return `(${typeof value})`;\n  }\n}\n\n// ============================================================\n// Freezing\n// ============================================================\n\nfunction freezeDocument(input: {\n  version: GraphExtensionVersion;\n  annotations: GraphAnnotations | undefined;\n  nodes: Record<string, ExtensionNodeDef> | undefined;\n  edges: Record<string, ExtensionEdgeDef> | undefined;\n  ontology: readonly ExtensionOntologyRelation[] | undefined;\n  indexes: readonly ExtensionIndex[] | undefined;\n}): GraphExtension {\n  return Object.freeze(\n    compactUndefined<{\n      version: GraphExtensionVersion;\n      annotations?: GraphAnnotations;\n      nodes?: Record<string, ExtensionNodeDef>;\n      edges?: Record<string, ExtensionEdgeDef>;\n      ontology?: readonly ExtensionOntologyRelation[];\n      indexes?: readonly ExtensionIndex[];\n    }>({\n      version: input.version,\n      annotations:\n        input.annotations === undefined ?\n          undefined\n        : cloneAndFreezeGraphAnnotations(input.annotations),\n      nodes: input.nodes === undefined ? undefined : freezeDeep(input.nodes),\n      edges: input.edges === undefined ? undefined : freezeDeep(input.edges),\n      ontology:\n        input.ontology === undefined ?\n          undefined\n        : Object.freeze(\n            input.ontology.map((entry) => Object.freeze({ ...entry })),\n          ),\n      indexes:\n        input.indexes === undefined ?\n          undefined\n        : Object.freeze(input.indexes.map((entry) => freezeDeep({ ...entry }))),\n    }),\n  );\n}\n"]}