@nicia-ai/typegraph 0.24.1 → 0.25.1

package/dist/chunk-4BOWVUGQ.js

@@ -0,0 +1,2029 @@
+import { TypeGraphError, ConfigurationError } from './chunk-DOTEN2FG.js';
+import { encodeJsonPointerSegment } from './chunk-NZ5PMBTG.js';
+
+// src/graph-extension/errors.ts
+var GRAPH_EXTENSION_ISSUE_CODES = [
+  "UNSUPPORTED_PROPERTY_TYPE",
+  "INVALID_PROPERTY_REFINEMENT",
+  "NESTED_ARRAY",
+  "NESTED_OBJECT_TOO_DEEP",
+  "INVALID_MODIFIER_TARGET",
+  "INVALID_ENUM_VALUES",
+  "INVALID_NUMBER_BOUNDS",
+  "INVALID_LENGTH_BOUNDS",
+  "INVALID_PATTERN",
+  "INVALID_EMBEDDING_DIMENSIONS",
+  "INVALID_SEARCHABLE_LANGUAGE",
+  "RESERVED_PROPERTY_NAME",
+  "INVALID_KIND_NAME",
+  "DUPLICATE_KIND_NAME",
+  "EMPTY_PROPERTIES",
+  "EMPTY_FROM_OR_TO",
+  "DUPLICATE_UNIQUE_CONSTRAINT",
+  "EMPTY_UNIQUE_FIELDS",
+  "DUPLICATE_UNIQUE_FIELD",
+  "UNKNOWN_UNIQUE_FIELD",
+  "INVALID_UNIQUE_WHERE_OP",
+  "UNKNOWN_UNIQUE_WHERE_FIELD",
+  "INVALID_ANNOTATION",
+  "UNKNOWN_META_EDGE",
+  "ONTOLOGY_CYCLE",
+  "ONTOLOGY_SELF_LOOP",
+  "ONTOLOGY_DISJOINT_CONFLICT",
+  "DUPLICATE_ONTOLOGY_RELATION",
+  "INVALID_DOCUMENT_SHAPE",
+  "UNKNOWN_DOCUMENT_KEY",
+  "UNSUPPORTED_STRING_FORMAT",
+  "INVALID_INDEX_DECLARATION",
+  "DUPLICATE_INDEX_NAME",
+  "EMPTY_INDEX_FIELDS",
+  "UNKNOWN_PROPERTY_KEY"
+];
+var GraphExtensionError = class extends TypeGraphError {
+  constructor(spec) {
+    super(spec.message, spec.code, {
+      details: spec.details,
+      category: spec.category ?? "user",
+      suggestion: spec.suggestion,
+      ...spec.cause === void 0 ? {} : { cause: spec.cause }
+    });
+    this.name = new.target.name;
+  }
+};
+var GraphExtensionValidationError = class extends GraphExtensionError {
+  code = "GRAPH_EXTENSION_INVALID";
+  issues;
+  constructor(issues, cause) {
+    const frozenIssues = Object.freeze([...issues]);
+    super({
+      message: `Graph extension document is invalid (${issues.length} issue${issues.length === 1 ? "" : "s"}): ${summarizeIssues(issues)}`,
+      code: "GRAPH_EXTENSION_INVALID",
+      details: { issues: frozenIssues },
+      suggestion: `Inspect error.issues for per-field paths and codes; each issue's "path" is a JSON pointer into the source document.`,
+      cause
+    });
+    this.issues = frozenIssues;
+  }
+};
+function summarizeWithOverflow(items, formatItem, emptyMessage) {
+  if (items.length === 0) return emptyMessage;
+  const head = items.slice(0, 3).map((item) => formatItem(item)).join("; ");
+  const overflow = items.length > 3 ? ` (+${items.length - 3} more)` : "";
+  return `${head}${overflow}`;
+}
+function summarizeIssues(issues) {
+  return summarizeWithOverflow(
+    issues,
+    (issue) => `${issue.path || "(root)"} \u2014 ${issue.message}`,
+    "no specific issues recorded"
+  );
+}
+var KindCollisionError = class extends GraphExtensionError {
+  code = "KIND_COLLISION";
+  kindName;
+  entity;
+  constructor(kindName, entity, graphId) {
+    super({
+      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.`,
+      code: "KIND_COLLISION",
+      details: { kindName, entity, graphId },
+      suggestion: "Pick a different graph-extension-declared kind name, or remove the compile-time declaration."
+    });
+    this.kindName = kindName;
+    this.entity = entity;
+  }
+};
+var INCOMPATIBLE_CHANGE_TYPES = [
+  "REMOVE_PROPERTY",
+  "ADD_REQUIRED_PROPERTY",
+  "TIGHTEN_OPTIONALITY",
+  "TIGHTEN_CONSTRAINT",
+  "ADD_PATTERN",
+  "CHANGE_PATTERN",
+  "ADD_FORMAT",
+  "CHANGE_FORMAT",
+  "TIGHTEN_INT",
+  "TIGHTEN_ENUM",
+  "TYPE_CHANGE",
+  "ADD_UNIQUE_ON_POPULATED",
+  "TIGHTEN_EDGE_ENDPOINTS"
+];
+var IncompatibleChangeError = class extends GraphExtensionError {
+  code = "INCOMPATIBLE_CHANGE";
+  changes;
+  constructor(changes, graphId) {
+    const frozenChanges = Object.freeze([...changes]);
+    super({
+      message: `Graph extension contains ${changes.length} incompatible change${changes.length === 1 ? "" : "s"} against existing graph-extension kinds on graph "${graphId}": ${summarizeChanges(changes)}`,
+      code: "INCOMPATIBLE_CHANGE",
+      details: { graphId, changes: frozenChanges },
+      suggestion: "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."
+    });
+    this.changes = frozenChanges;
+  }
+};
+function summarizeChanges(changes) {
+  return summarizeWithOverflow(
+    changes,
+    (change) => {
+      const field = change.field === void 0 ? "" : `.${change.field}`;
+      const detail = change.detail === void 0 ? "" : ` (${change.detail})`;
+      return `${change.kind}${field}: ${change.type}${detail}`;
+    },
+    "(no specific changes recorded)"
+  );
+}
+var GraphExtensionUnresolvedEndpointError = class extends GraphExtensionError {
+  code = "GRAPH_EXTENSION_UNRESOLVED_ENDPOINT";
+  edgeKind;
+  side;
+  endpoint;
+  constructor(edgeKind, side, endpoint, graphId) {
+    super({
+      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.`,
+      code: "GRAPH_EXTENSION_UNRESOLVED_ENDPOINT",
+      details: { edgeKind, side, endpoint, graphId },
+      suggestion: "Restore the compile-time kind, or remove the graph-extension-declared kind via store.removeKinds before redeploying without it."
+    });
+    this.edgeKind = edgeKind;
+    this.side = side;
+    this.endpoint = endpoint;
+  }
+};
+var RemoveCompileTimeKindError = class extends GraphExtensionError {
+  code = "REMOVE_COMPILE_TIME_KIND";
+  kindName;
+  entity;
+  constructor(kindName, entity, graphId) {
+    super({
+      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}".`,
+      code: "REMOVE_COMPILE_TIME_KIND",
+      details: { kindName, entity, graphId },
+      suggestion: "Drop the kind from your defineGraph call and redeploy. Only graph-extension kinds (added via store.evolve) are removable through removeKinds."
+    });
+    this.kindName = kindName;
+    this.entity = entity;
+  }
+};
+var KindHasReferentsError = class extends GraphExtensionError {
+  code = "KIND_HAS_REFERENTS";
+  kindName;
+  referents;
+  constructor(kindName, referents, graphId) {
+    const summary = referents.map((referent) => `${referent.type}:${referent.name}`).join(", ");
+    const frozenReferents = Object.freeze([...referents]);
+    super({
+      message: `Cannot remove graph-extension kind "${kindName}" on graph "${graphId}" \u2014 it is referenced by compile-time declarations: ${summary}.`,
+      code: "KIND_HAS_REFERENTS",
+      details: { kindName, graphId, referents: frozenReferents },
+      suggestion: "Remove the compile-time references first (drop the edge or ontology relation from defineGraph), or pick a different kind to remove."
+    });
+    this.kindName = kindName;
+    this.referents = frozenReferents;
+  }
+};
+var GraphExtensionVersionUnsupportedError = class extends GraphExtensionError {
+  code = "GRAPH_EXTENSION_VERSION_UNSUPPORTED";
+  persistedVersion;
+  currentVersion;
+  constructor(persistedVersion, currentVersion) {
+    super({
+      message: `Persisted extension was authored against graph-extension format v${persistedVersion}, but this library only supports up to v${currentVersion}. Upgrade @nicia-ai/typegraph.`,
+      code: "GRAPH_EXTENSION_VERSION_UNSUPPORTED",
+      details: { persistedVersion, currentVersion },
+      category: "system",
+      suggestion: `Upgrade @nicia-ai/typegraph to a version that supports graph-extension format v${persistedVersion}, or downgrade the writer.`
+    });
+    this.persistedVersion = persistedVersion;
+    this.currentVersion = currentVersion;
+  }
+};
+
+// src/graph-extension/extension-types.ts
+var LEGACY_GRAPH_EXTENSION_VERSION = 1;
+var CURRENT_GRAPH_EXTENSION_VERSION = 1;
+var GRAPH_EXTENSION_TOP_LEVEL_KEYS = [
+  "version",
+  "nodes",
+  "edges",
+  "ontology",
+  "indexes"
+];
+
+// src/utils/object.ts
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function compactUndefined(value) {
+  const result = {};
+  for (const [key, fieldValue] of Object.entries(value)) {
+    if (fieldValue !== void 0) result[key] = fieldValue;
+  }
+  return result;
+}
+function freezeDeep(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Object.isFrozen(value)) return value;
+  for (const nested of Object.values(value)) {
+    freezeDeep(nested);
+  }
+  return Object.freeze(value);
+}
+
+// src/core/json-value.ts
+function assertJsonValue(value, rootLabel, ownerKind) {
+  walk(value, rootLabel, ownerKind);
+}
+function walk(value, path, ownerKind) {
+  if (value === null) return;
+  const valueType = typeof value;
+  if (valueType === "number") {
+    if (!Number.isFinite(value)) {
+      throwInvalid(path, describeNonFinite(value), ownerKind);
+    }
+    return;
+  }
+  if (valueType === "string" || valueType === "boolean") return;
+  if (valueType === "bigint" || valueType === "function" || valueType === "symbol" || valueType === "undefined") {
+    throwInvalid(path, valueType, ownerKind);
+  }
+  if (Array.isArray(value)) {
+    for (const [index, element] of value.entries()) {
+      walk(element, `${path}[${index}]`, ownerKind);
+    }
+    return;
+  }
+  if (!isPlainObject(value)) {
+    throwInvalid(path, describeNonPlain(value), ownerKind);
+  }
+  for (const [key, nested] of Object.entries(value)) {
+    walk(nested, `${path}.${key}`, ownerKind);
+  }
+}
+function describeNonFinite(value) {
+  if (Number.isNaN(value)) return "NaN";
+  if (value === Number.POSITIVE_INFINITY) return "Infinity";
+  if (value === Number.NEGATIVE_INFINITY) return "-Infinity";
+  return "non-finite number";
+}
+function describeNonPlain(value) {
+  const constructorName = value?.constructor?.name;
+  if (typeof constructorName === "string" && constructorName.length > 0) {
+    return `${constructorName} instance`;
+  }
+  return "non-plain object";
+}
+function throwInvalid(path, kind, ownerKind) {
+  throw new ConfigurationError(
+    `${ownerKind} ${path} contains a non-JSON value (${kind}). Annotations must be JSON-serializable.`,
+    { path, valueKind: kind },
+    {
+      suggestion: "Use only strings, numbers, booleans, null, arrays, and plain objects in annotations."
+    }
+  );
+}
+
+// src/ontology/closures.ts
+function computeTransitiveClosure(relations) {
+  const closure = /* @__PURE__ */ new Map();
+  const allNodes = /* @__PURE__ */ new Set();
+  for (const [from, to] of relations) {
+    allNodes.add(from);
+    allNodes.add(to);
+  }
+  for (const node of allNodes) {
+    closure.set(node, /* @__PURE__ */ new Set());
+  }
+  for (const [from, to] of relations) {
+    closure.get(from)?.add(to);
+  }
+  for (const k of allNodes) {
+    for (const index of allNodes) {
+      const indexReaches = closure.get(index);
+      if (!indexReaches?.has(k)) continue;
+      const kReaches = closure.get(k);
+      if (!kReaches) continue;
+      for (const index2 of kReaches) {
+        indexReaches.add(index2);
+      }
+    }
+  }
+  return closure;
+}
+function invertClosure(closure) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [from, tos] of closure) {
+    for (const to of tos) {
+      const existing = result.get(to) ?? /* @__PURE__ */ new Set();
+      existing.add(from);
+      result.set(to, existing);
+    }
+  }
+  return result;
+}
+function isReachable(closure, source, target) {
+  return closure.get(source)?.has(target) ?? false;
+}
+
+// src/ontology/constants.ts
+var META_EDGE_SUB_CLASS_OF = "subClassOf";
+var META_EDGE_BROADER = "broader";
+var META_EDGE_NARROWER = "narrower";
+var META_EDGE_RELATED_TO = "relatedTo";
+var META_EDGE_EQUIVALENT_TO = "equivalentTo";
+var META_EDGE_SAME_AS = "sameAs";
+var META_EDGE_DIFFERENT_FROM = "differentFrom";
+var META_EDGE_DISJOINT_WITH = "disjointWith";
+var META_EDGE_PART_OF = "partOf";
+var META_EDGE_HAS_PART = "hasPart";
+var META_EDGE_INVERSE_OF = "inverseOf";
+var META_EDGE_IMPLIES = "implies";
+var ALL_META_EDGE_NAMES = [
+  META_EDGE_SUB_CLASS_OF,
+  META_EDGE_BROADER,
+  META_EDGE_NARROWER,
+  META_EDGE_RELATED_TO,
+  META_EDGE_EQUIVALENT_TO,
+  META_EDGE_SAME_AS,
+  META_EDGE_DIFFERENT_FROM,
+  META_EDGE_DISJOINT_WITH,
+  META_EDGE_PART_OF,
+  META_EDGE_HAS_PART,
+  META_EDGE_INVERSE_OF,
+  META_EDGE_IMPLIES
+];
+
+// src/store/reserved-keys.ts
+var RESERVED_NODE_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "kind",
+  "meta"
+]);
+var RESERVED_EDGE_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "kind",
+  "meta",
+  "fromKind",
+  "fromId",
+  "toKind",
+  "toId"
+]);
+var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+var RESERVED_PROPERTY_PREFIX = "$";
+function isReservedPropertyName(name) {
+  return name.startsWith(RESERVED_PROPERTY_PREFIX);
+}
+function assertSchemaKeysAreFree(entityKind, name, keys, reservedStructuralKeys) {
+  const structuralConflicts = keys.filter(
+    (key) => reservedStructuralKeys.has(key)
+  );
+  if (structuralConflicts.length > 0) {
+    const label = entityKind.toLowerCase();
+    throw new ConfigurationError(
+      `${entityKind} "${name}" schema contains reserved property names: ${structuralConflicts.join(", ")}`,
+      {
+        [`${label}Type`]: name,
+        conflicts: structuralConflicts,
+        reservedKeys: [...reservedStructuralKeys]
+      },
+      {
+        suggestion: `Rename the conflicting properties. Reserved names (${[...reservedStructuralKeys].join(", ")}) are added automatically to all ${label}s.`
+      }
+    );
+  }
+  const prefixConflicts = keys.filter((key) => isReservedPropertyName(key));
+  if (prefixConflicts.length > 0) {
+    const label = entityKind.toLowerCase();
+    throw new ConfigurationError(
+      `${entityKind} "${name}" schema uses the reserved "${RESERVED_PROPERTY_PREFIX}" prefix on: ${prefixConflicts.join(", ")}`,
+      {
+        [`${label}Type`]: name,
+        conflicts: prefixConflicts,
+        reservedPrefix: RESERVED_PROPERTY_PREFIX
+      },
+      {
+        suggestion: `Property names starting with "${RESERVED_PROPERTY_PREFIX}" are reserved for TypeGraph accessors (e.g. $fulltext). Rename each field.`
+      }
+    );
+  }
+}
+function validateProjectionField(field, entityType, kind) {
+  const reserved = entityType === "node" ? RESERVED_NODE_KEYS : RESERVED_EDGE_KEYS;
+  if (reserved.has(field)) {
+    throw new ConfigurationError(
+      `Projection field "${field}" on ${entityType} kind "${kind}" conflicts with a reserved structural key`,
+      { field, kind, entityType, reservedKeys: [...reserved] },
+      {
+        suggestion: `Remove "${field}" from the projection. Structural fields (${[...reserved].join(", ")}) are included automatically when relevant.`
+      }
+    );
+  }
+  if (PROTOTYPE_POLLUTION_KEYS.has(field)) {
+    throw new ConfigurationError(
+      `Projection field "${field}" on ${entityType} kind "${kind}" is not allowed`,
+      { field, kind, entityType },
+      {
+        suggestion: `"${field}" cannot be used as a projection field name.`
+      }
+    );
+  }
+}
+function filterReservedKeys(props, reservedKeys) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(props)) {
+    if (!reservedKeys.has(key)) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+
+// src/utils/result.ts
+function ok(data) {
+  return { success: true, data };
+}
+function err(error) {
+  return { success: false, error };
+}
+function unwrap(result) {
+  if (result.success) {
+    return result.data;
+  }
+  throw result.error;
+}
+
+// src/graph-extension/validation.ts
+var META_EDGE_NAME_SET = new Set(ALL_META_EDGE_NAMES);
+var SUPPORTED_PROPERTY_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "enum",
+  "array",
+  "object"
+]);
+var SUPPORTED_STRING_FORMATS = /* @__PURE__ */ new Set([
+  "datetime",
+  "uri",
+  "email",
+  "uuid",
+  "date"
+]);
+var COMMON_PROPERTY_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "optional",
+  "description",
+  "searchable",
+  "embedding"
+]);
+var PROPERTY_TYPE_KEYS = {
+  string: /* @__PURE__ */ new Set(["minLength", "maxLength", "pattern", "format"]),
+  number: /* @__PURE__ */ new Set(["min", "max", "int"]),
+  boolean: /* @__PURE__ */ new Set(),
+  enum: /* @__PURE__ */ new Set(["values"]),
+  array: /* @__PURE__ */ new Set(["items"]),
+  object: /* @__PURE__ */ new Set(["properties"])
+};
+function rejectUnknownPropertyKeys(raw, type, path, issues) {
+  const typeKeys = PROPERTY_TYPE_KEYS[type] ?? /* @__PURE__ */ new Set();
+  const recognized = [...COMMON_PROPERTY_KEYS, ...typeKeys];
+  for (const key of Object.keys(raw)) {
+    if (COMMON_PROPERTY_KEYS.has(key) || typeKeys.has(key)) continue;
+    issues.push({
+      path: `${path}/${encodeJsonPointerSegment(key)}`,
+      message: `Unknown property key "${key}" for type "${type}". Recognized keys: ${recognized.join(", ")}.`,
+      code: "UNKNOWN_PROPERTY_KEY"
+    });
+  }
+}
+function rejectUnknownObjectKeys(raw, allowed, label, path, code, issues) {
+  for (const key of Object.keys(raw)) {
+    if (allowed.has(key)) continue;
+    issues.push({
+      path: `${path}/${encodeJsonPointerSegment(key)}`,
+      message: `Unknown ${label} key "${key}". Allowed: ${[...allowed].join(", ")}.`,
+      code
+    });
+  }
+}
+var KNOWN_DOCUMENT_KEYS = new Set(
+  GRAPH_EXTENSION_TOP_LEVEL_KEYS
+);
+var NODE_BODY_KEYS = /* @__PURE__ */ new Set([
+  "description",
+  "annotations",
+  "properties",
+  "unique"
+]);
+var EDGE_BODY_KEYS = /* @__PURE__ */ new Set([
+  "description",
+  "annotations",
+  "from",
+  "to",
+  "properties"
+]);
+var ONTOLOGY_ENTRY_KEYS = /* @__PURE__ */ new Set([
+  "metaEdge",
+  "from",
+  "to"
+]);
+var UNIQUE_CONSTRAINT_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "fields",
+  "scope",
+  "collation",
+  "where"
+]);
+var WHERE_CLAUSE_KEYS = /* @__PURE__ */ new Set(["field", "op"]);
+var NODE_INDEX_KEYS = /* @__PURE__ */ new Set([
+  "entity",
+  "kind",
+  "name",
+  "fields",
+  "coveringFields",
+  "unique",
+  "scope",
+  "where"
+]);
+var EDGE_INDEX_KEYS = /* @__PURE__ */ new Set([
+  "entity",
+  "kind",
+  "name",
+  "fields",
+  "coveringFields",
+  "unique",
+  "scope",
+  "direction",
+  "where"
+]);
+function validateGraphExtension(input, options = {}) {
+  const issues = [];
+  const strict = options.strict === true;
+  if (!isPlainObject(input)) {
+    issues.push({
+      path: "",
+      message: "Document must be a plain object.",
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return err(new GraphExtensionValidationError(issues));
+  }
+  const documentRecord = input;
+  if (strict) {
+    for (const key of Object.keys(documentRecord)) {
+      if (!KNOWN_DOCUMENT_KEYS.has(key)) {
+        issues.push({
+          path: `/${encodeJsonPointerSegment(key)}`,
+          message: `Unknown top-level key "${key}". Did you mean one of: ${[...KNOWN_DOCUMENT_KEYS].join(", ")}?`,
+          code: "UNKNOWN_DOCUMENT_KEY"
+        });
+      }
+    }
+  }
+  const version = validateVersion(documentRecord.version, issues);
+  const nodes = validateNodesSection(documentRecord.nodes, issues, strict);
+  const edges = validateEdgesSection(documentRecord.edges, issues, strict);
+  const ontology = validateOntologySection(
+    documentRecord.ontology,
+    issues,
+    strict
+  );
+  if (ontology !== void 0) {
+    validateOntology(ontology, nodes, issues);
+  }
+  const indexes = validateIndexesSection(
+    documentRecord.indexes,
+    issues,
+    strict
+  );
+  if (issues.length > 0) {
+    return err(new GraphExtensionValidationError(issues));
+  }
+  return ok(freezeDocument({ version, nodes, edges, ontology, indexes }));
+}
+function validateVersion(raw, issues) {
+  if (raw === void 0) return LEGACY_GRAPH_EXTENSION_VERSION;
+  if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 1) {
+    issues.push({
+      path: "/version",
+      message: `Document version must be a positive integer; received ${JSON.stringify(raw)}.`,
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return LEGACY_GRAPH_EXTENSION_VERSION;
+  }
+  if (raw > CURRENT_GRAPH_EXTENSION_VERSION) {
+    throw new GraphExtensionVersionUnsupportedError(
+      raw,
+      CURRENT_GRAPH_EXTENSION_VERSION
+    );
+  }
+  return raw;
+}
+function validateNodesSection(rawNodes, issues, strict) {
+  if (rawNodes === void 0) return void 0;
+  if (!isPlainObject(rawNodes)) {
+    issues.push({
+      path: "/nodes",
+      message: "`nodes` must be a plain object keyed by node-kind name.",
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return void 0;
+  }
+  const result = {};
+  const recorded = /* @__PURE__ */ new Set();
+  for (const [kindName, rawNode] of Object.entries(rawNodes)) {
+    const path = `/nodes/${encodeJsonPointerSegment(kindName)}`;
+    if (!isValidKindName(kindName)) {
+      issues.push({
+        path,
+        message: `Node kind name "${kindName}" must match /^[A-Za-z_][A-Za-z0-9_]*$/.`,
+        code: "INVALID_KIND_NAME"
+      });
+      continue;
+    }
+    if (recorded.has(kindName)) {
+      issues.push({
+        path,
+        message: `Duplicate node kind name "${kindName}".`,
+        code: "DUPLICATE_KIND_NAME"
+      });
+      continue;
+    }
+    const node = validateNodeDocument(kindName, rawNode, path, issues, strict);
+    if (node === void 0) continue;
+    result[kindName] = node;
+    recorded.add(kindName);
+  }
+  return result;
+}
+function validateNodeDocument(kindName, raw, path, issues, strict) {
+  if (!isPlainObject(raw)) {
+    issues.push({
+      path,
+      message: `Node "${kindName}" must be a plain object.`,
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return void 0;
+  }
+  if (strict) {
+    rejectUnknownObjectKeys(
+      raw,
+      NODE_BODY_KEYS,
+      "node-level",
+      path,
+      "INVALID_DOCUMENT_SHAPE",
+      issues
+    );
+  }
+  const description = validateOptionalString(
+    raw.description,
+    `${path}/description`,
+    "`description`",
+    "INVALID_DOCUMENT_SHAPE",
+    issues
+  );
+  const annotations = validateAnnotations(
+    raw.annotations,
+    `${path}/annotations`,
+    `Node "${kindName}"`,
+    issues
+  );
+  const propertiesRaw = raw.properties;
+  const properties = validatePropertiesMap(
+    propertiesRaw,
+    `${path}/properties`,
+    "node",
+    kindName,
+    issues,
+    strict
+  );
+  if (properties === void 0) return void 0;
+  const uniqueRaw = raw.unique;
+  const unique = validateUniqueConstraints(
+    uniqueRaw,
+    `${path}/unique`,
+    properties,
+    issues,
+    strict
+  );
+  return compactUndefined({
+    description,
+    annotations,
+    properties,
+    unique
+  });
+}
+function validateEdgesSection(rawEdges, issues, strict) {
+  if (rawEdges === void 0) return void 0;
+  if (!isPlainObject(rawEdges)) {
+    issues.push({
+      path: "/edges",
+      message: "`edges` must be a plain object keyed by edge-kind name.",
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return void 0;
+  }
+  const result = {};
+  const recorded = /* @__PURE__ */ new Set();
+  for (const [kindName, rawEdge] of Object.entries(rawEdges)) {
+    const path = `/edges/${encodeJsonPointerSegment(kindName)}`;
+    if (!isValidKindName(kindName)) {
+      issues.push({
+        path,
+        message: `Edge kind name "${kindName}" must match /^[A-Za-z_][A-Za-z0-9_]*$/.`,
+        code: "INVALID_KIND_NAME"
+      });
+      continue;
+    }
+    if (recorded.has(kindName)) {
+      issues.push({
+        path,
+        message: `Duplicate edge kind name "${kindName}".`,
+        code: "DUPLICATE_KIND_NAME"
+      });
+      continue;
+    }
+    const edge = validateEdgeDocument(kindName, rawEdge, path, issues, strict);
+    if (edge === void 0) continue;
+    result[kindName] = edge;
+    recorded.add(kindName);
+  }
+  return result;
+}
+function validateEdgeDocument(kindName, raw, path, issues, strict) {
+  if (!isPlainObject(raw)) {
+    issues.push({
+      path,
+      message: `Edge "${kindName}" must be a plain object.`,
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return void 0;
+  }
+  if (strict) {
+    rejectUnknownObjectKeys(
+      raw,
+      EDGE_BODY_KEYS,
+      "edge-level",
+      path,
+      "INVALID_DOCUMENT_SHAPE",
+      issues
+    );
+  }
+  const description = validateOptionalString(
+    raw.description,
+    `${path}/description`,
+    "`description`",
+    "INVALID_DOCUMENT_SHAPE",
+    issues
+  );
+  const annotations = validateAnnotations(
+    raw.annotations,
+    `${path}/annotations`,
+    `Edge "${kindName}"`,
+    issues
+  );
+  const from = validateEndpointList(raw.from, `${path}/from`, issues);
+  const to = validateEndpointList(raw.to, `${path}/to`, issues);
+  if (from === void 0 || to === void 0) return void 0;
+  const propertiesRaw = raw.properties;
+  const properties = propertiesRaw === void 0 ? {} : validatePropertiesMap(
+    propertiesRaw,
+    `${path}/properties`,
+    "edge",
+    kindName,
+    issues,
+    strict
+  );
+  if (properties === void 0) return void 0;
+  return compactUndefined({
+    description,
+    annotations,
+    from,
+    to,
+    properties
+  });
+}
+function validateEndpointList(raw, path, issues) {
+  if (!Array.isArray(raw)) {
+    issues.push({
+      path,
+      message: "Edge endpoint list must be an array of node-kind names.",
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return void 0;
+  }
+  if (raw.length === 0) {
+    issues.push({
+      path,
+      message: "Edge endpoint list must contain at least one node-kind name.",
+      code: "EMPTY_FROM_OR_TO"
+    });
+    return void 0;
+  }
+  const names = [];
+  for (const [index, value] of raw.entries()) {
+    if (typeof value !== "string" || value.length === 0) {
+      issues.push({
+        path: `${path}/${index}`,
+        message: "Edge endpoint must be a non-empty string node-kind name.",
+        code: "INVALID_DOCUMENT_SHAPE"
+      });
+      return void 0;
+    }
+    names.push(value);
+  }
+  return names;
+}
+function validateOntologySection(raw, issues, strict) {
+  if (raw === void 0) return void 0;
+  if (!Array.isArray(raw)) {
+    issues.push({
+      path: "/ontology",
+      message: "`ontology` must be an array of relation objects.",
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return void 0;
+  }
+  const result = [];
+  for (const [index, entry] of raw.entries()) {
+    const path = `/ontology/${index}`;
+    if (!isPlainObject(entry)) {
+      issues.push({
+        path,
+        message: "Ontology entry must be a plain object.",
+        code: "INVALID_DOCUMENT_SHAPE"
+      });
+      continue;
+    }
+    if (strict) {
+      rejectUnknownObjectKeys(
+        entry,
+        ONTOLOGY_ENTRY_KEYS,
+        "ontology-entry",
+        path,
+        "INVALID_DOCUMENT_SHAPE",
+        issues
+      );
+    }
+    const metaEdge = entry.metaEdge;
+    const from = entry.from;
+    const to = entry.to;
+    if (typeof metaEdge !== "string" || !META_EDGE_NAME_SET.has(metaEdge)) {
+      issues.push({
+        path: `${path}/metaEdge`,
+        message: `Unknown meta-edge ${describeUnknownValue(metaEdge)}. Allowed: ${[...ALL_META_EDGE_NAMES].join(", ")}.`,
+        code: "UNKNOWN_META_EDGE"
+      });
+      continue;
+    }
+    if (typeof from !== "string" || from.length === 0) {
+      issues.push({
+        path: `${path}/from`,
+        message: "Ontology relation `from` must be a non-empty string.",
+        code: "INVALID_DOCUMENT_SHAPE"
+      });
+      continue;
+    }
+    if (typeof to !== "string" || to.length === 0) {
+      issues.push({
+        path: `${path}/to`,
+        message: "Ontology relation `to` must be a non-empty string.",
+        code: "INVALID_DOCUMENT_SHAPE"
+      });
+      continue;
+    }
+    result.push({ metaEdge, from, to });
+  }
+  return result;
+}
+function validateOntology(ontology, _nodes, issues) {
+  const seenKey = /* @__PURE__ */ new Set();
+  for (const [index, relation] of ontology.entries()) {
+    const path = `/ontology/${index}`;
+    if (relation.from === relation.to && isStrictlyHierarchicalMetaEdge(relation.metaEdge)) {
+      issues.push({
+        path,
+        message: `Hierarchical meta-edge "${relation.metaEdge}" cannot be a self-loop ("${relation.from}" \u2192 "${relation.to}").`,
+        code: "ONTOLOGY_SELF_LOOP"
+      });
+    }
+    const key = `${relation.metaEdge}::${relation.from}->${relation.to}`;
+    if (seenKey.has(key)) {
+      issues.push({
+        path,
+        message: `Duplicate ontology relation "${relation.metaEdge}" (${relation.from} \u2192 ${relation.to}).`,
+        code: "DUPLICATE_ONTOLOGY_RELATION"
+      });
+      continue;
+    }
+    seenKey.add(key);
+  }
+  detectHierarchicalCycles(ontology, issues);
+  detectDisjointHierarchyContradictions(ontology, issues);
+}
+var STRICTLY_HIERARCHICAL = /* @__PURE__ */ new Set([
+  "subClassOf",
+  "broader",
+  "narrower",
+  "partOf",
+  "hasPart"
+]);
+function isStrictlyHierarchicalMetaEdge(name) {
+  return STRICTLY_HIERARCHICAL.has(name);
+}
+var HIERARCHICAL_NORMALIZATION = /* @__PURE__ */ new Map([
+  ["subClassOf", { canonical: "subClassOf", flip: false }],
+  ["broader", { canonical: "broader", flip: false }],
+  ["narrower", { canonical: "broader", flip: true }],
+  ["partOf", { canonical: "partOf", flip: false }],
+  ["hasPart", { canonical: "partOf", flip: true }]
+]);
+function buildHierarchicalGroups(ontology, options) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [index, relation] of ontology.entries()) {
+    const normalization = HIERARCHICAL_NORMALIZATION.get(relation.metaEdge);
+    if (normalization === void 0) continue;
+    if (options.skipSelfLoops && relation.from === relation.to) continue;
+    const from = normalization.flip ? relation.to : relation.from;
+    const to = normalization.flip ? relation.from : relation.to;
+    const list = groups.get(normalization.canonical) ?? [];
+    list.push({ from, to, originalIndex: index });
+    groups.set(normalization.canonical, list);
+  }
+  return groups;
+}
+function detectHierarchicalCycles(ontology, issues) {
+  const groups = buildHierarchicalGroups(ontology, { skipSelfLoops: true });
+  for (const [name, edges] of groups) {
+    const closure = computeTransitiveClosure(
+      edges.map((edge) => [edge.from, edge.to])
+    );
+    const reportedNodes = /* @__PURE__ */ new Set();
+    for (const [from, reachable] of closure) {
+      if (!reachable.has(from) || reportedNodes.has(from)) continue;
+      reportedNodes.add(from);
+      const offendingEdge = edges.find((edge) => edge.from === from);
+      const path = offendingEdge === void 0 ? "/ontology" : `/ontology/${offendingEdge.originalIndex}`;
+      issues.push({
+        path,
+        message: `Cycle detected in "${name}" relations involving "${from}".`,
+        code: "ONTOLOGY_CYCLE"
+      });
+    }
+  }
+}
+function detectDisjointHierarchyContradictions(ontology, issues) {
+  const disjointPairs = /* @__PURE__ */ new Set();
+  const disjointPath = /* @__PURE__ */ new Map();
+  for (const [index, relation] of ontology.entries()) {
+    if (relation.metaEdge !== "disjointWith") continue;
+    disjointPairs.add(`${relation.from}|${relation.to}`);
+    disjointPairs.add(`${relation.to}|${relation.from}`);
+    disjointPath.set(`${relation.from}|${relation.to}`, `/ontology/${index}`);
+    disjointPath.set(`${relation.to}|${relation.from}`, `/ontology/${index}`);
+  }
+  if (disjointPairs.size === 0) return;
+  const groups = buildHierarchicalGroups(ontology, { skipSelfLoops: false });
+  const reported = /* @__PURE__ */ new Set();
+  for (const [name, edges] of groups) {
+    const closure = computeTransitiveClosure(
+      edges.map((edge) => [edge.from, edge.to])
+    );
+    for (const [from, reachable] of closure) {
+      for (const to of reachable) {
+        const pairKey = `${from}|${to}`;
+        if (!disjointPairs.has(pairKey)) continue;
+        if (reported.has(pairKey)) continue;
+        reported.add(pairKey);
+        issues.push({
+          path: disjointPath.get(pairKey) ?? "/ontology",
+          message: `Contradiction: "${from}" and "${to}" are declared disjointWith but also related by "${name}" (directly or transitively).`,
+          code: "ONTOLOGY_DISJOINT_CONFLICT"
+        });
+      }
+    }
+  }
+}
+var INDEX_SCOPE_VALUES = ["graphAndKind", "graph", "none"];
+var EDGE_INDEX_DIRECTION_VALUES = ["out", "in", "none"];
+var RUNTIME_INDEX_WHERE_OPS = /* @__PURE__ */ new Set([
+  "isNull",
+  "isNotNull"
+]);
+function validateIndexesSection(rawIndexes, issues, strict) {
+  if (rawIndexes === void 0) return void 0;
+  if (!Array.isArray(rawIndexes)) {
+    issues.push({
+      path: "/indexes",
+      message: "`indexes` must be an array of index declarations.",
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return void 0;
+  }
+  const result = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const [arrayIndex, entry] of rawIndexes.entries()) {
+    const path = `/indexes/${arrayIndex}`;
+    const validated = validateIndexEntry(entry, path, issues, strict);
+    if (validated === void 0) continue;
+    if (validated.name !== void 0) {
+      if (seenNames.has(validated.name)) {
+        issues.push({
+          path: `${path}/name`,
+          message: `Duplicate index name "${validated.name}".`,
+          code: "DUPLICATE_INDEX_NAME"
+        });
+        continue;
+      }
+      seenNames.add(validated.name);
+    }
+    result.push(validated);
+  }
+  return result;
+}
+function validateIndexEntry(raw, path, issues, strict) {
+  if (!isPlainObject(raw)) {
+    issues.push({
+      path,
+      message: "Index entry must be a plain object.",
+      code: "INVALID_INDEX_DECLARATION"
+    });
+    return void 0;
+  }
+  const entity = raw.entity;
+  if (entity !== "node" && entity !== "edge") {
+    issues.push({
+      path: `${path}/entity`,
+      message: `Index \`entity\` must be "node" or "edge"; received ${describeUnknownValue(entity)}.`,
+      code: "INVALID_INDEX_DECLARATION"
+    });
+    return void 0;
+  }
+  if (strict) {
+    rejectUnknownObjectKeys(
+      raw,
+      entity === "node" ? NODE_INDEX_KEYS : EDGE_INDEX_KEYS,
+      `${entity}-index`,
+      path,
+      "INVALID_INDEX_DECLARATION",
+      issues
+    );
+  }
+  if (typeof raw.kind !== "string" || !isValidKindName(raw.kind)) {
+    issues.push({
+      path: `${path}/kind`,
+      message: "Index `kind` must be a non-empty kind name matching /^[A-Za-z_][A-Za-z0-9_]*$/.",
+      code: "INVALID_INDEX_DECLARATION"
+    });
+    return void 0;
+  }
+  const fields = validateStringList(raw.fields, `${path}/fields`, issues, {
+    allowEmpty: false,
+    label: "fields",
+    emptyCode: "EMPTY_INDEX_FIELDS"
+  });
+  if (fields === void 0) return void 0;
+  const coveringFields = validateStringList(
+    raw.coveringFields,
+    `${path}/coveringFields`,
+    issues,
+    { allowEmpty: true, label: "coveringFields" }
+  );
+  if (raw.unique !== void 0 && typeof raw.unique !== "boolean") {
+    issues.push({
+      path: `${path}/unique`,
+      message: "Index `unique` must be a boolean.",
+      code: "INVALID_INDEX_DECLARATION"
+    });
+    return void 0;
+  }
+  let name;
+  if (raw.name !== void 0) {
+    if (typeof raw.name !== "string" || raw.name.length === 0) {
+      issues.push({
+        path: `${path}/name`,
+        message: "Index `name` must be a non-empty string.",
+        code: "INVALID_INDEX_DECLARATION"
+      });
+      return void 0;
+    }
+    name = raw.name;
+  }
+  const scopeResult = validateOptionalLiteral(
+    raw.scope,
+    INDEX_SCOPE_VALUES,
+    `${path}/scope`,
+    "Index `scope`",
+    "INVALID_INDEX_DECLARATION",
+    issues
+  );
+  if (!scopeResult.ok) return void 0;
+  const scope = scopeResult.value;
+  const where = validateGraphExtensionIndexWhere(
+    raw.where,
+    `${path}/where`,
+    issues,
+    strict
+  );
+  if (entity === "node") {
+    return compactUndefined({
+      entity: "node",
+      kind: raw.kind,
+      name,
+      fields,
+      coveringFields,
+      unique: raw.unique,
+      scope,
+      where
+    });
+  }
+  const directionResult = validateOptionalLiteral(
+    raw.direction,
+    EDGE_INDEX_DIRECTION_VALUES,
+    `${path}/direction`,
+    "Edge index `direction`",
+    "INVALID_INDEX_DECLARATION",
+    issues
+  );
+  if (!directionResult.ok) return void 0;
+  const direction = directionResult.value;
+  return compactUndefined({
+    entity: "edge",
+    kind: raw.kind,
+    name,
+    direction,
+    fields,
+    coveringFields,
+    unique: raw.unique,
+    scope,
+    where
+  });
+}
+function validateStringList(raw, path, issues, options) {
+  if (raw === void 0) {
+    if (options.allowEmpty) return void 0;
+    issues.push({
+      path,
+      message: `\`${options.label}\` is required and must contain at least one entry.`,
+      code: options.emptyCode ?? "INVALID_INDEX_DECLARATION"
+    });
+    return void 0;
+  }
+  if (!Array.isArray(raw)) {
+    issues.push({
+      path,
+      message: `\`${options.label}\` must be an array of strings.`,
+      code: "INVALID_INDEX_DECLARATION"
+    });
+    return void 0;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const [index, value] of raw.entries()) {
+    if (typeof value !== "string" || value.length === 0) {
+      issues.push({
+        path: `${path}/${index}`,
+        message: `\`${options.label}[${index}]\` must be a non-empty string.`,
+        code: "INVALID_INDEX_DECLARATION"
+      });
+      return void 0;
+    }
+    if (seen.has(value)) {
+      issues.push({
+        path: `${path}/${index}`,
+        message: `Duplicate ${options.label} entry "${value}".`,
+        code: "INVALID_INDEX_DECLARATION"
+      });
+      return void 0;
+    }
+    seen.add(value);
+    result.push(value);
+  }
+  if (!options.allowEmpty && result.length === 0) {
+    issues.push({
+      path,
+      message: `\`${options.label}\` must contain at least one entry.`,
+      code: options.emptyCode ?? "INVALID_INDEX_DECLARATION"
+    });
+    return void 0;
+  }
+  return result;
+}
+function validateGraphExtensionIndexWhere(raw, path, issues, strict) {
+  if (raw === void 0) return void 0;
+  if (!isPlainObject(raw)) {
+    issues.push({
+      path,
+      message: "Index `where` must be a plain object.",
+      code: "INVALID_INDEX_DECLARATION"
+    });
+    return void 0;
+  }
+  if (strict) {
+    rejectUnknownObjectKeys(
+      raw,
+      WHERE_CLAUSE_KEYS,
+      "where-clause",
+      path,
+      "INVALID_INDEX_DECLARATION",
+      issues
+    );
+  }
+  if (typeof raw.field !== "string" || raw.field.length === 0) {
+    issues.push({
+      path: `${path}/field`,
+      message: "`where.field` must be a non-empty string.",
+      code: "INVALID_INDEX_DECLARATION"
+    });
+    return void 0;
+  }
+  if (typeof raw.op !== "string" || !RUNTIME_INDEX_WHERE_OPS.has(raw.op)) {
+    issues.push({
+      path: `${path}/op`,
+      message: '`where.op` must be "isNull" or "isNotNull" in v1.',
+      code: "INVALID_INDEX_DECLARATION"
+    });
+    return void 0;
+  }
+  return Object.freeze({
+    field: raw.field,
+    op: raw.op
+  });
+}
+function validatePropertiesMap(raw, path, ownerType, ownerName, issues, strict) {
+  if (!isPlainObject(raw)) {
+    issues.push({
+      path,
+      message: `\`properties\` must be a plain object.`,
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return void 0;
+  }
+  const reserved = ownerType === "node" ? RESERVED_NODE_KEYS : RESERVED_EDGE_KEYS;
+  const result = {};
+  for (const [propertyName, propertyValue] of Object.entries(raw)) {
+    const propertyPath = `${path}/${encodeJsonPointerSegment(propertyName)}`;
+    if (reserved.has(propertyName)) {
+      issues.push({
+        path: propertyPath,
+        message: `Property name "${propertyName}" is reserved for ${ownerType} "${ownerName}".`,
+        code: "RESERVED_PROPERTY_NAME"
+      });
+      continue;
+    }
+    if (propertyName.startsWith("$")) {
+      issues.push({
+        path: propertyPath,
+        message: `Property name "${propertyName}" uses the reserved "$" prefix.`,
+        code: "RESERVED_PROPERTY_NAME"
+      });
+      continue;
+    }
+    const validated = validateProperty(
+      propertyValue,
+      propertyPath,
+      0,
+      issues,
+      strict
+    );
+    if (validated === void 0) continue;
+    result[propertyName] = validated;
+  }
+  return result;
+}
+function validateProperty(raw, path, depth, issues, strict) {
+  if (!isPlainObject(raw)) {
+    issues.push({
+      path,
+      message: "Property descriptor must be a plain object with a `type` field.",
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return void 0;
+  }
+  const property = raw;
+  const type = property.type;
+  if (typeof type !== "string" || !SUPPORTED_PROPERTY_TYPES.has(type)) {
+    issues.push({
+      path: `${path}/type`,
+      message: `Unsupported property type ${describeUnknownValue(type)}. Supported: ${[...SUPPORTED_PROPERTY_TYPES].join(", ")}.`,
+      code: "UNSUPPORTED_PROPERTY_TYPE"
+    });
+    return void 0;
+  }
+  if (strict) rejectUnknownPropertyKeys(property, type, path, issues);
+  switch (type) {
+    case "string": {
+      return validateStringProperty(property, path, issues, strict);
+    }
+    case "number": {
+      return validateNumberProperty(property, path, issues);
+    }
+    case "boolean": {
+      return validateBooleanProperty(property, path, issues);
+    }
+    case "enum": {
+      return validateEnumProperty(property, path, issues);
+    }
+    case "array": {
+      return validateArrayProperty(property, path, depth, issues, strict);
+    }
+    case "object": {
+      return validateObjectProperty(property, path, depth, issues, strict);
+    }
+  }
+  return void 0;
+}
+function validateStringProperty(raw, path, issues, strict) {
+  const minLength = validateNonNegativeInteger(
+    raw.minLength,
+    `${path}/minLength`,
+    "string.minLength",
+    "INVALID_LENGTH_BOUNDS",
+    issues
+  );
+  const maxLength = validateNonNegativeInteger(
+    raw.maxLength,
+    `${path}/maxLength`,
+    "string.maxLength",
+    "INVALID_LENGTH_BOUNDS",
+    issues
+  );
+  if (minLength !== void 0 && maxLength !== void 0 && minLength > maxLength) {
+    issues.push({
+      path,
+      message: `string.minLength (${minLength}) cannot exceed string.maxLength (${maxLength}).`,
+      code: "INVALID_LENGTH_BOUNDS"
+    });
+  }
+  let pattern;
+  if (raw.pattern !== void 0) {
+    if (typeof raw.pattern === "string") {
+      try {
+        new RegExp(raw.pattern);
+        pattern = raw.pattern;
+      } catch (error) {
+        issues.push({
+          path: `${path}/pattern`,
+          message: `Pattern is not a valid regular expression: ${error instanceof Error ? error.message : String(error)}`,
+          code: "INVALID_PATTERN"
+        });
+      }
+    } else {
+      issues.push({
+        path: `${path}/pattern`,
+        message: "`pattern` must be a string regular expression.",
+        code: "INVALID_PATTERN"
+      });
+    }
+  }
+  let format;
+  if (raw.format !== void 0) {
+    if (typeof raw.format !== "string") {
+      issues.push({
+        path: `${path}/format`,
+        message: `String format must be a string; received ${describeUnknownValue(raw.format)}.`,
+        code: "INVALID_PROPERTY_REFINEMENT"
+      });
+    } else if (SUPPORTED_STRING_FORMATS.has(raw.format)) {
+      format = raw.format;
+    } else if (strict) {
+      issues.push({
+        path: `${path}/format`,
+        message: `Unsupported string format "${raw.format}". Supported: ${[...SUPPORTED_STRING_FORMATS].join(", ")}.`,
+        code: "UNSUPPORTED_STRING_FORMAT"
+      });
+    }
+  }
+  const modifiers = validatePropertyModifiers(raw, path, "string", issues);
+  if (modifiers === void 0) return void 0;
+  if (format !== void 0 && modifiers.searchable !== void 0) {
+    issues.push({
+      path,
+      message: "`searchable` cannot be combined with `format` on a string property \u2014 the format-specific schema cannot carry the searchable brand. Drop one, or split into two fields.",
+      code: "INVALID_PROPERTY_REFINEMENT"
+    });
+    return void 0;
+  }
+  if (format !== void 0 && (minLength !== void 0 || maxLength !== void 0 || pattern !== void 0)) {
+    issues.push({
+      path,
+      message: "`format` cannot be combined with `minLength`, `maxLength`, or `pattern` on a string property \u2014 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`.",
+      code: "INVALID_PROPERTY_REFINEMENT"
+    });
+    return void 0;
+  }
+  return finalizeProperty(
+    "string",
+    { minLength, maxLength, pattern, format },
+    modifiers
+  );
+}
+function validateNumberProperty(raw, path, issues) {
+  const min = validateOptionalFiniteNumber(
+    raw.min,
+    `${path}/min`,
+    "`min`",
+    "INVALID_NUMBER_BOUNDS",
+    issues
+  );
+  const max = validateOptionalFiniteNumber(
+    raw.max,
+    `${path}/max`,
+    "`max`",
+    "INVALID_NUMBER_BOUNDS",
+    issues
+  );
+  if (min !== void 0 && max !== void 0 && min > max) {
+    issues.push({
+      path,
+      message: `number.min (${min}) cannot exceed number.max (${max}).`,
+      code: "INVALID_NUMBER_BOUNDS"
+    });
+  }
+  const int = validateOptionalBoolean(
+    raw.int,
+    `${path}/int`,
+    "`int`",
+    "INVALID_PROPERTY_REFINEMENT",
+    issues
+  );
+  if (int === true) {
+    if (min !== void 0 && !Number.isInteger(min)) {
+      issues.push({
+        path: `${path}/min`,
+        message: "`min` must be an integer when `int: true`.",
+        code: "INVALID_NUMBER_BOUNDS"
+      });
+    }
+    if (max !== void 0 && !Number.isInteger(max)) {
+      issues.push({
+        path: `${path}/max`,
+        message: "`max` must be an integer when `int: true`.",
+        code: "INVALID_NUMBER_BOUNDS"
+      });
+    }
+  }
+  const modifiers = validatePropertyModifiers(raw, path, "number", issues);
+  if (modifiers === void 0) return void 0;
+  return finalizeProperty(
+    "number",
+    { min, max, int },
+    modifiers
+  );
+}
+function validateBooleanProperty(raw, path, issues) {
+  const modifiers = validatePropertyModifiers(raw, path, "boolean", issues);
+  if (modifiers === void 0) return void 0;
+  return finalizeProperty("boolean", {}, modifiers);
+}
+function validateEnumProperty(raw, path, issues) {
+  const valuesRaw = raw.values;
+  if (!Array.isArray(valuesRaw) || valuesRaw.length === 0) {
+    issues.push({
+      path: `${path}/values`,
+      message: "`enum.values` must be a non-empty array of strings.",
+      code: "INVALID_ENUM_VALUES"
+    });
+    return void 0;
+  }
+  const values = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, value] of valuesRaw.entries()) {
+    if (typeof value !== "string") {
+      issues.push({
+        path: `${path}/values/${index}`,
+        message: "`enum.values` entries must be strings.",
+        code: "INVALID_ENUM_VALUES"
+      });
+      return void 0;
+    }
+    if (seen.has(value)) {
+      issues.push({
+        path: `${path}/values/${index}`,
+        message: `Duplicate enum value "${value}".`,
+        code: "INVALID_ENUM_VALUES"
+      });
+      return void 0;
+    }
+    seen.add(value);
+    values.push(value);
+  }
+  const modifiers = validatePropertyModifiers(raw, path, "enum", issues);
+  if (modifiers === void 0) return void 0;
+  return finalizeProperty("enum", { values }, modifiers);
+}
+function validateArrayProperty(raw, path, depth, issues, strict) {
+  const itemsRaw = raw.items;
+  if (itemsRaw === void 0) {
+    issues.push({
+      path: `${path}/items`,
+      message: "`array.items` is required.",
+      code: "INVALID_PROPERTY_REFINEMENT"
+    });
+    return void 0;
+  }
+  if (!isPlainObject(itemsRaw)) {
+    issues.push({
+      path: `${path}/items`,
+      message: "`array.items` must be a plain property descriptor.",
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return void 0;
+  }
+  const itemType = itemsRaw.type;
+  if (itemType === "array") {
+    issues.push({
+      path: `${path}/items`,
+      message: "Nested arrays are not supported in v1.",
+      code: "NESTED_ARRAY"
+    });
+    return void 0;
+  }
+  const items = validateProperty(
+    itemsRaw,
+    `${path}/items`,
+    depth + 1,
+    issues,
+    strict
+  );
+  if (items === void 0) return void 0;
+  if (items.type === "array") {
+    return void 0;
+  }
+  const modifiers = validatePropertyModifiers(raw, path, "array", issues);
+  if (modifiers === void 0) return void 0;
+  return finalizeProperty(
+    "array",
+    { items },
+    modifiers
+  );
+}
+function validateObjectProperty(raw, path, depth, issues, strict) {
+  if (depth >= 1) {
+    issues.push({
+      path,
+      message: "Nested objects are limited to a single level in v1.",
+      code: "NESTED_OBJECT_TOO_DEEP"
+    });
+    return void 0;
+  }
+  const propertiesRaw = raw.properties;
+  if (!isPlainObject(propertiesRaw)) {
+    issues.push({
+      path: `${path}/properties`,
+      message: "`object.properties` must be a plain object.",
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return void 0;
+  }
+  const propertiesEntries = Object.entries(propertiesRaw);
+  if (propertiesEntries.length === 0) {
+    issues.push({
+      path: `${path}/properties`,
+      message: "`object.properties` must declare at least one field.",
+      code: "EMPTY_PROPERTIES"
+    });
+    return void 0;
+  }
+  const fields = {};
+  for (const [name, value] of propertiesEntries) {
+    const fieldPath = `${path}/properties/${encodeJsonPointerSegment(name)}`;
+    if (!isPlainObject(value)) {
+      issues.push({
+        path: fieldPath,
+        message: "Object field descriptor must be a plain object.",
+        code: "INVALID_DOCUMENT_SHAPE"
+      });
+      continue;
+    }
+    const fieldType = value.type;
+    if (fieldType === "object") {
+      issues.push({
+        path: fieldPath,
+        message: "Nested objects are limited to a single level in v1.",
+        code: "NESTED_OBJECT_TOO_DEEP"
+      });
+      continue;
+    }
+    const field = validateProperty(value, fieldPath, depth + 1, issues, strict);
+    if (field === void 0) continue;
+    fields[name] = field;
+  }
+  const modifiers = validatePropertyModifiers(raw, path, "object", issues);
+  if (modifiers === void 0) return void 0;
+  return finalizeProperty(
+    "object",
+    { properties: fields },
+    modifiers
+  );
+}
+function finalizeProperty(type, specific, modifiers) {
+  return compactUndefined({
+    type,
+    ...specific,
+    optional: modifiers.optional,
+    searchable: modifiers.searchable,
+    embedding: modifiers.embedding,
+    description: modifiers.description
+  });
+}
+function validatePropertyModifiers(raw, path, propertyType, issues) {
+  const issuesAtEntry = issues.length;
+  const optional = validateOptionalBoolean(
+    raw.optional,
+    `${path}/optional`,
+    "`optional`",
+    "INVALID_PROPERTY_REFINEMENT",
+    issues
+  );
+  let searchable;
+  if (raw.searchable !== void 0) {
+    if (propertyType !== "string") {
+      issues.push({
+        path: `${path}/searchable`,
+        message: `\`searchable\` is only valid on string properties (got "${propertyType}").`,
+        code: "INVALID_MODIFIER_TARGET"
+      });
+    } else if (isPlainObject(raw.searchable)) {
+      const searchableRaw = raw.searchable;
+      const language = searchableRaw.language;
+      if (language === void 0) {
+        searchable = {};
+      } else {
+        if (typeof language !== "string" || language.length === 0) {
+          issues.push({
+            path: `${path}/searchable/language`,
+            message: "`searchable.language` must be a non-empty string.",
+            code: "INVALID_SEARCHABLE_LANGUAGE"
+          });
+        } else {
+          searchable = { language };
+        }
+      }
+    } else {
+      issues.push({
+        path: `${path}/searchable`,
+        message: "`searchable` must be a plain object (use `{}` for defaults).",
+        code: "INVALID_PROPERTY_REFINEMENT"
+      });
+    }
+  }
+  let embedding;
+  if (raw.embedding !== void 0) {
+    if (propertyType === "array") {
+      const itemsRaw = raw.items;
+      const itemType = isPlainObject(itemsRaw) ? itemsRaw.type : void 0;
+      if (itemType !== "number") {
+        issues.push({
+          path: `${path}/embedding`,
+          message: '`embedding` requires `array.items.type === "number"`.',
+          code: "INVALID_MODIFIER_TARGET"
+        });
+      } else if (isPlainObject(raw.embedding)) {
+        const dim = raw.embedding.dimensions;
+        if (typeof dim !== "number" || !Number.isInteger(dim) || dim <= 0) {
+          issues.push({
+            path: `${path}/embedding/dimensions`,
+            message: "`embedding.dimensions` must be a positive integer.",
+            code: "INVALID_EMBEDDING_DIMENSIONS"
+          });
+        } else {
+          const itemsObject = isPlainObject(itemsRaw) ? itemsRaw : {};
+          const extraneous = Object.keys(itemsObject).filter(
+            (key) => key !== "type"
+          );
+          if (extraneous.length > 0) {
+            issues.push({
+              path: `${path}/items`,
+              message: `\`embedding\` arrays must declare items as \`{ type: "number" }\` only \u2014 additional refinements (${extraneous.join(", ")}) are silently dropped by the embedding schema. Drop the refinements, or drop \`embedding\` and use a plain array.`,
+              code: "INVALID_PROPERTY_REFINEMENT"
+            });
+          } else {
+            embedding = { dimensions: dim };
+          }
+        }
+      } else {
+        issues.push({
+          path: `${path}/embedding`,
+          message: "`embedding` must be a plain object with a `dimensions` field.",
+          code: "INVALID_PROPERTY_REFINEMENT"
+        });
+      }
+    } else {
+      issues.push({
+        path: `${path}/embedding`,
+        message: `\`embedding\` is only valid on array-of-number properties (got "${propertyType}").`,
+        code: "INVALID_MODIFIER_TARGET"
+      });
+    }
+  }
+  let description;
+  if (raw.description !== void 0) {
+    if (typeof raw.description === "string") {
+      description = raw.description;
+    } else {
+      issues.push({
+        path: `${path}/description`,
+        message: "`description` must be a string.",
+        code: "INVALID_PROPERTY_REFINEMENT"
+      });
+    }
+  }
+  if (issues.length > issuesAtEntry) return void 0;
+  return compactUndefined({
+    optional,
+    searchable,
+    embedding,
+    description
+  });
+}
+function validateUniqueConstraints(raw, path, properties, issues, strict) {
+  if (raw === void 0) return void 0;
+  if (!Array.isArray(raw)) {
+    issues.push({
+      path,
+      message: "`unique` must be an array of constraint declarations.",
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return void 0;
+  }
+  const result = [];
+  const names = /* @__PURE__ */ new Set();
+  for (const [index, entry] of raw.entries()) {
+    const constraintPath = `${path}/${index}`;
+    if (!isPlainObject(entry)) {
+      issues.push({
+        path: constraintPath,
+        message: "Unique constraint must be a plain object.",
+        code: "INVALID_DOCUMENT_SHAPE"
+      });
+      continue;
+    }
+    if (strict) {
+      rejectUnknownObjectKeys(
+        entry,
+        UNIQUE_CONSTRAINT_KEYS,
+        "unique-constraint",
+        constraintPath,
+        "INVALID_DOCUMENT_SHAPE",
+        issues
+      );
+    }
+    const constraint = entry;
+    const name = constraint.name;
+    if (typeof name !== "string" || name.length === 0) {
+      issues.push({
+        path: `${constraintPath}/name`,
+        message: "Unique constraint `name` must be a non-empty string.",
+        code: "INVALID_DOCUMENT_SHAPE"
+      });
+      continue;
+    }
+    if (names.has(name)) {
+      issues.push({
+        path: `${constraintPath}/name`,
+        message: `Duplicate unique constraint name "${name}".`,
+        code: "DUPLICATE_UNIQUE_CONSTRAINT"
+      });
+      continue;
+    }
+    names.add(name);
+    const fieldsRaw = constraint.fields;
+    if (!Array.isArray(fieldsRaw) || fieldsRaw.length === 0) {
+      issues.push({
+        path: `${constraintPath}/fields`,
+        message: "Unique constraint `fields` must be a non-empty array of property names.",
+        code: "EMPTY_UNIQUE_FIELDS"
+      });
+      continue;
+    }
+    const fields = [];
+    const seenFields = /* @__PURE__ */ new Set();
+    let fieldsValid = true;
+    for (const [fieldIndex, field] of fieldsRaw.entries()) {
+      if (typeof field !== "string" || field.length === 0) {
+        issues.push({
+          path: `${constraintPath}/fields/${fieldIndex}`,
+          message: "Unique constraint field must be a non-empty string.",
+          code: "INVALID_DOCUMENT_SHAPE"
+        });
+        fieldsValid = false;
+        break;
+      }
+      if (seenFields.has(field)) {
+        issues.push({
+          path: `${constraintPath}/fields/${fieldIndex}`,
+          message: `Duplicate field "${field}" in unique constraint.`,
+          code: "DUPLICATE_UNIQUE_FIELD"
+        });
+        fieldsValid = false;
+        break;
+      }
+      if (!(field in properties)) {
+        issues.push({
+          path: `${constraintPath}/fields/${fieldIndex}`,
+          message: `Unique constraint field "${field}" is not declared on this kind.`,
+          code: "UNKNOWN_UNIQUE_FIELD"
+        });
+        fieldsValid = false;
+        break;
+      }
+      seenFields.add(field);
+      fields.push(field);
+    }
+    if (!fieldsValid) continue;
+    const scopeResult = validateOptionalLiteral(
+      constraint.scope,
+      ["kind", "kindWithSubClasses"],
+      `${constraintPath}/scope`,
+      "Unique constraint `scope`",
+      "INVALID_DOCUMENT_SHAPE",
+      issues
+    );
+    if (!scopeResult.ok) continue;
+    const scope = scopeResult.value;
+    const collationResult = validateOptionalLiteral(
+      constraint.collation,
+      ["binary", "caseInsensitive"],
+      `${constraintPath}/collation`,
+      "Unique constraint `collation`",
+      "INVALID_DOCUMENT_SHAPE",
+      issues
+    );
+    if (!collationResult.ok) continue;
+    const collation = collationResult.value;
+    const where = constraint.where === void 0 ? void 0 : validateUniqueWhere(
+      constraint.where,
+      `${constraintPath}/where`,
+      properties,
+      issues,
+      strict
+    );
+    if (constraint.where !== void 0 && where === void 0) continue;
+    result.push(
+      compactUndefined({
+        name,
+        fields,
+        scope,
+        collation,
+        where
+      })
+    );
+  }
+  return result;
+}
+function validateUniqueWhere(raw, path, properties, issues, strict) {
+  if (!isPlainObject(raw)) {
+    issues.push({
+      path,
+      message: "Unique constraint `where` must be `{ field, op }`.",
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return void 0;
+  }
+  if (strict) {
+    rejectUnknownObjectKeys(
+      raw,
+      WHERE_CLAUSE_KEYS,
+      "where-clause",
+      path,
+      "INVALID_DOCUMENT_SHAPE",
+      issues
+    );
+  }
+  const field = raw.field;
+  const op = raw.op;
+  if (typeof field !== "string" || field.length === 0) {
+    issues.push({
+      path: `${path}/field`,
+      message: "Unique `where.field` must be a non-empty string.",
+      code: "INVALID_DOCUMENT_SHAPE"
+    });
+    return void 0;
+  }
+  if (!(field in properties)) {
+    issues.push({
+      path: `${path}/field`,
+      message: `Unique \`where.field\` "${field}" is not declared on this kind.`,
+      code: "UNKNOWN_UNIQUE_WHERE_FIELD"
+    });
+    return void 0;
+  }
+  if (op !== "isNull" && op !== "isNotNull") {
+    issues.push({
+      path: `${path}/op`,
+      message: `Unique \`where.op\` must be "isNull" or "isNotNull" (got ${describeUnknownValue(op)}).`,
+      code: "INVALID_UNIQUE_WHERE_OP"
+    });
+    return void 0;
+  }
+  return { field, op };
+}
+function validateAnnotations(raw, path, ownerLabel, issues) {
+  if (raw === void 0) return void 0;
+  if (!isPlainObject(raw)) {
+    issues.push({
+      path,
+      message: `Annotations must be a plain JSON object.`,
+      code: "INVALID_ANNOTATION"
+    });
+    return void 0;
+  }
+  try {
+    assertJsonValue(raw, "annotations", ownerLabel);
+  } catch (error) {
+    if (error instanceof ConfigurationError) {
+      const detailPath = error.details.path;
+      const annotationPath = typeof detailPath === "string" ? `${path}/${detailPath.replace(/^annotations\.?/, "").replaceAll(".", "/")}` : path;
+      issues.push({
+        path: annotationPath,
+        message: error.message,
+        code: "INVALID_ANNOTATION"
+      });
+      return void 0;
+    }
+    throw error;
+  }
+  return raw;
+}
+function validateNonNegativeInteger(value, path, label, code, issues) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    issues.push({
+      path,
+      message: `${label} must be a non-negative integer.`,
+      code
+    });
+    return void 0;
+  }
+  return value;
+}
+function validateOptionalString(value, path, label, code, issues) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") {
+    issues.push({ path, message: `${label} must be a string.`, code });
+    return void 0;
+  }
+  return value;
+}
+function validateOptionalBoolean(value, path, label, code, issues) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "boolean") {
+    issues.push({ path, message: `${label} must be a boolean.`, code });
+    return void 0;
+  }
+  return value;
+}
+function validateOptionalFiniteNumber(value, path, label, code, issues) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    issues.push({ path, message: `${label} must be a finite number.`, code });
+    return void 0;
+  }
+  return value;
+}
+function validateOptionalLiteral(value, allowed, path, label, code, issues) {
+  if (value === void 0) return { ok: true, value: void 0 };
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    const list = allowed.map((entry) => `"${entry}"`).join(", ");
+    issues.push({ path, message: `${label} must be one of: ${list}.`, code });
+    return { ok: false };
+  }
+  return { ok: true, value };
+}
+function isValidKindName(name) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+}
+function describeUnknownValue(value) {
+  if (typeof value === "string") return `"${value}"`;
+  if (value === null || typeof value === "number" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return `(${typeof value})`;
+  }
+}
+function freezeDocument(input) {
+  return Object.freeze(
+    compactUndefined({
+      version: input.version,
+      nodes: input.nodes === void 0 ? void 0 : freezeDeep(input.nodes),
+      edges: input.edges === void 0 ? void 0 : freezeDeep(input.edges),
+      ontology: input.ontology === void 0 ? void 0 : Object.freeze(
+        input.ontology.map((entry) => Object.freeze({ ...entry }))
+      ),
+      indexes: input.indexes === void 0 ? void 0 : Object.freeze(input.indexes.map((entry) => freezeDeep({ ...entry })))
+    })
+  );
+}
+
+export { ALL_META_EDGE_NAMES, CURRENT_GRAPH_EXTENSION_VERSION, GRAPH_EXTENSION_ISSUE_CODES, GRAPH_EXTENSION_TOP_LEVEL_KEYS, GraphExtensionError, GraphExtensionUnresolvedEndpointError, GraphExtensionValidationError, GraphExtensionVersionUnsupportedError, INCOMPATIBLE_CHANGE_TYPES, IncompatibleChangeError, KindCollisionError, KindHasReferentsError, LEGACY_GRAPH_EXTENSION_VERSION, META_EDGE_BROADER, META_EDGE_DIFFERENT_FROM, META_EDGE_DISJOINT_WITH, META_EDGE_EQUIVALENT_TO, META_EDGE_HAS_PART, META_EDGE_IMPLIES, META_EDGE_INVERSE_OF, META_EDGE_NARROWER, META_EDGE_PART_OF, META_EDGE_RELATED_TO, META_EDGE_SAME_AS, META_EDGE_SUB_CLASS_OF, RESERVED_EDGE_KEYS, RESERVED_NODE_KEYS, RemoveCompileTimeKindError, assertJsonValue, assertSchemaKeysAreFree, compactUndefined, computeTransitiveClosure, filterReservedKeys, freezeDeep, invertClosure, isReachable, unwrap, validateGraphExtension, validateProjectionField };
+//# sourceMappingURL=chunk-4BOWVUGQ.js.map
+//# sourceMappingURL=chunk-4BOWVUGQ.js.map