@nicia-ai/typegraph 0.33.0 → 0.35.0

package/dist/{chunk-XVUJY72M.js → chunk-K3PPLHY7.js}

@@ -1,11 +1,13 @@
-import { NODE_TYPE_BRAND, EDGE_TYPE_BRAND, nowIso, getNodeKinds, getEdgeKinds, autoDeriveVectorIndexes, mergeVectorIndexes } from './chunk-QBYTJSAY.js';
-import { defineNodeIndex, defineEdgeIndex } from './chunk-6NRFUHMS.js';
-import { searchable } from './chunk-IZ4PCL47.js';
-import { embedding } from './chunk-454I6GDF.js';
-import { ALL_META_EDGE_NAMES, META_EDGE_IMPLIES, META_EDGE_INVERSE_OF, META_EDGE_PART_OF, META_EDGE_HAS_PART, META_EDGE_DISJOINT_WITH, META_EDGE_DIFFERENT_FROM, META_EDGE_SAME_AS, META_EDGE_EQUIVALENT_TO, META_EDGE_RELATED_TO, META_EDGE_BROADER, META_EDGE_NARROWER, META_EDGE_SUB_CLASS_OF, assertJsonValue, isReachable, computeTransitiveClosure, invertClosure, LEGACY_GRAPH_EXTENSION_VERSION, unwrap, validateGraphExtension, compactUndefined, KindCollisionError, GraphExtensionUnresolvedEndpointError, freezeDeep, assertSchemaKeysAreFree, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS } from './chunk-YCV72E6L.js';
-import { canonicalEqual, sortedReplacer, isMissingTableError } from './chunk-GYVBEZAO.js';
-import { sha256Hex } from './chunk-2YMGNYXY.js';
-import { ConfigurationError, KindNotFoundError, DatabaseOperationError, MigrationError, ValidationError } from './chunk-TQOYM4LN.js';
+import { canonicalEqual, sortedReplacer } from './chunk-UR7W5YQK.js';
+import { NODE_TYPE_BRAND, EDGE_TYPE_BRAND, getNodeKinds, getEdgeKinds, autoDeriveVectorIndexes, mergeVectorIndexes } from './chunk-QWEUYILR.js';
+import { defineNodeIndex, defineEdgeIndex } from './chunk-OR5ZA5WP.js';
+import { sha256Hex } from './chunk-W63OVYY4.js';
+import { ALL_META_EDGE_NAMES, META_EDGE_IMPLIES, META_EDGE_INVERSE_OF, META_EDGE_PART_OF, META_EDGE_HAS_PART, META_EDGE_DISJOINT_WITH, META_EDGE_DIFFERENT_FROM, META_EDGE_SAME_AS, META_EDGE_EQUIVALENT_TO, META_EDGE_RELATED_TO, META_EDGE_BROADER, META_EDGE_NARROWER, META_EDGE_SUB_CLASS_OF, assertJsonValue, isReachable, LEGACY_GRAPH_EXTENSION_VERSION, unwrap, validateGraphExtension, KindCollisionError, GraphExtensionUnresolvedEndpointError, computeTransitiveClosure, invertClosure } from './chunk-QOTI55H7.js';
+import { assertSchemaKeysAreFree, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS } from './chunk-RGPG7EOJ.js';
+import { nowIso, isMissingTableError } from './chunk-I7ZUZKFD.js';
+import { embedding, searchable } from './chunk-KBGQIPRQ.js';
+import { compactUndefined, freezeDeep } from './chunk-ITE4IXAK.js';
+import { ConfigurationError, KindNotFoundError, DatabaseOperationError, MigrationError } from './chunk-MP2JQKSG.js';
 import { z } from 'zod';
 
 // src/core/node.ts
@@ -345,24 +347,10 @@ function diffNodes(before, after) {
 function diffNodeDef(name, before, after) {
   const changes = [];
   if (!canonicalEqual(before.properties, after.properties)) {
-    const beforeProps = before.properties.properties ?? {};
-    const afterProps = after.properties.properties ?? {};
-    const beforeRequired = new Set(before.properties.required);
-    const afterRequired = new Set(after.properties.required);
-    const addedProps = Object.keys(afterProps).filter(
-      (p) => !(p in beforeProps)
-    );
-    const removedProps = Object.keys(beforeProps).filter(
-      (p) => !(p in afterProps)
-    );
-    const newRequired = [...afterRequired].filter(
-      (p) => !beforeRequired.has(p)
-    );
-    const { severity, details } = computePropertyChangeSeverity(
+    const { severity, details } = classifyPropertyChanges(
       name,
-      removedProps,
-      addedProps,
-      newRequired
+      before.properties,
+      after.properties
     );
     changes.push({
       type: "modified",
@@ -405,29 +393,103 @@ function diffNodeDef(name, before, after) {
   }
   return changes;
 }
-function computePropertyChangeSeverity(name, removedProps, addedProps, newRequired) {
-  if (removedProps.length > 0) {
+function propertyTypeSignature(schema) {
+  if (schema.type !== void 0) return JSON.stringify(schema.type);
+  if (schema.const !== void 0) return "const";
+  if (schema.enum !== void 0) return "enum";
+  if (schema.anyOf !== void 0) return "anyOf";
+  if (schema.oneOf !== void 0) return "oneOf";
+  if (schema.allOf !== void 0) return "allOf";
+  return "unknown";
+}
+var NON_CONSTRAINING_KEYWORDS = /* @__PURE__ */ new Set([
+  "description",
+  "title",
+  "default",
+  "$schema"
+]);
+function stripSchemaMetadata(schema) {
+  const stripped = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (!NON_CONSTRAINING_KEYWORDS.has(key)) stripped[key] = value;
+  }
+  return stripped;
+}
+function isObjectSchema(schema) {
+  return schema.type === "object" || schema.properties !== void 0;
+}
+function isBreakingPropertyChange(before, after) {
+  if (canonicalEqual(stripSchemaMetadata(before), stripSchemaMetadata(after))) {
+    return false;
+  }
+  if (propertyTypeSignature(before) !== propertyTypeSignature(after)) {
+    return true;
+  }
+  if (isObjectSchema(before) && isObjectSchema(after)) {
+    return isBreakingObjectSchemaChange(before, after);
+  }
+  return true;
+}
+function isBreakingObjectSchemaChange(before, after) {
+  const beforeProps = before.properties ?? {};
+  const afterProps = after.properties ?? {};
+  const beforeRequired = new Set(before.required);
+  const afterRequired = new Set(after.required);
+  for (const key of Object.keys(beforeProps)) {
+    if (!(key in afterProps)) return true;
+  }
+  for (const key of afterRequired) {
+    if (!beforeRequired.has(key)) return true;
+  }
+  for (const [key, beforeChild] of Object.entries(beforeProps)) {
+    const afterChild = afterProps[key];
+    if (afterChild === void 0) continue;
+    if (isBreakingPropertyChange(beforeChild, afterChild)) return true;
+  }
+  return false;
+}
+function classifyPropertyChanges(kind, before, after) {
+  const beforeProps = before.properties ?? {};
+  const afterProps = after.properties ?? {};
+  const beforeRequired = new Set(before.required);
+  const afterRequired = new Set(after.required);
+  const removed = Object.keys(beforeProps).filter((p) => !(p in afterProps));
+  const added = Object.keys(afterProps).filter((p) => !(p in beforeProps));
+  const newRequired = [...afterRequired].filter((p) => !beforeRequired.has(p));
+  const breakingProps = [];
+  for (const [property, beforeProperty] of Object.entries(beforeProps)) {
+    const afterProperty = afterProps[property];
+    if (afterProperty === void 0) continue;
+    if (canonicalEqual(beforeProperty, afterProperty)) continue;
+    if (isBreakingPropertyChange(beforeProperty, afterProperty)) {
+      breakingProps.push(property);
+    }
+  }
+  if (removed.length > 0) {
+    return {
+      severity: "breaking",
+      details: `Properties removed from "${kind}": ${removed.join(", ")}`
+    };
+  }
+  if (breakingProps.length > 0) {
     return {
       severity: "breaking",
-      details: `Properties removed from "${name}": ${removedProps.join(", ")}`
+      details: `Property schemas changed incompatibly in "${kind}": ${breakingProps.join(", ")}`
     };
   }
   if (newRequired.length > 0) {
     return {
       severity: "breaking",
-      details: `New required properties in "${name}": ${newRequired.join(", ")}`
+      details: `New required properties in "${kind}": ${newRequired.join(", ")}`
     };
   }
-  if (addedProps.length > 0) {
+  if (added.length > 0) {
     return {
       severity: "safe",
-      details: `Properties added to "${name}": ${addedProps.join(", ")}`
+      details: `Properties added to "${kind}": ${added.join(", ")}`
     };
   }
-  return {
-    severity: "safe",
-    details: `Properties changed in "${name}"`
-  };
+  return { severity: "safe", details: `Properties changed in "${kind}"` };
 }
 function diffEdges(before, after) {
   const changes = [];
@@ -498,11 +560,16 @@ function diffEdgeDef(name, before, after) {
     });
   }
   if (!canonicalEqual(before.properties, after.properties)) {
+    const { severity, details } = classifyPropertyChanges(
+      name,
+      before.properties,
+      after.properties
+    );
     changes.push({
       type: "modified",
       kind: name,
-      severity: "safe",
-      details: `Properties changed for "${name}"`,
+      severity,
+      details,
       before,
       after
     });
@@ -958,6 +1025,17 @@ var KindRegistry = class {
     if (concreteKind === targetKind) return true;
     return this.isSubClassOf(concreteKind, targetKind);
   }
+  /**
+   * Checks if a concrete kind is assignable to at least one of the given
+   * target kinds. Shared by every "is this kind usable where one of these
+   * kinds is expected" check (edge endpoint validation, ontology relation
+   * endpoint compatibility) so they can't independently drift.
+   */
+  isAssignableToAny(concreteKind, targetKinds) {
+    return targetKinds.some(
+      (targetKind) => this.isAssignableTo(concreteKind, targetKind)
+    );
+  }
   /**
    * Validates that a kind exists in the registry.
    */
@@ -1245,6 +1323,16 @@ function serializeNodeIndexDeclaration(declaration) {
     unique: declaration.unique,
     scope: declaration.scope,
     where: declaration.where,
+    // `method: "btree"` is canonicalized by absence, like `origin` below.
+    ...declaration.method === void 0 ? {} : { method: declaration.method },
+    // `keySystemColumns: []` is canonicalized by absence, same rule. Checked
+    // against length, not just `undefined` — `NodeIndexDeclaration` is
+    // exported and `defineGraph` accepts pre-built declarations directly
+    // (bypassing `defineNodeIndex`'s own canonicalization and the
+    // `nodeIndexDeclarationZod` parse boundary, which rejects an explicit
+    // `[]` via `.min(1)`), so an in-memory declaration can still carry a
+    // present-but-empty array that must canonicalize to absent here.
+    ...declaration.keySystemColumns === void 0 || declaration.keySystemColumns.length === 0 ? {} : { keySystemColumns: declaration.keySystemColumns },
     // `origin: "compile-time"` is the default and is omitted from the
     // canonical form (absence == compile-time). Only `runtime` is
     // emitted explicitly so the restart loader can route the declaration
@@ -1265,6 +1353,8 @@ function serializeEdgeIndexDeclaration(declaration) {
     unique: declaration.unique,
     scope: declaration.scope,
     where: declaration.where,
+    // `method: "btree"` is canonicalized by absence, like `origin`.
+    ...declaration.method === void 0 ? {} : { method: declaration.method },
     ...declaration.origin === "runtime" ? { origin: "runtime" } : {}
   };
 }
@@ -1440,11 +1530,7 @@ function mapToRecord(map) {
   return result;
 }
 function mapToSimpleRecord(map) {
-  const result = {};
-  for (const [key, value] of map) {
-    result[key] = value;
-  }
-  return result;
+  return Object.fromEntries(map);
 }
 var SCHEMA_PROPERTIES_CACHE = /* @__PURE__ */ new WeakMap();
 function serializeSchemaProperties(schema) {
@@ -2008,6 +2094,94 @@ function resolveOntologyEndpoints(relation, nodeKinds) {
   const to = typeof relation.to === "string" ? nodeKinds.get(relation.to) ?? relation.to : relation.to;
   return { ...relation, from, to };
 }
+
+// src/registry/validate-implies.ts
+function validateImpliesEndpointCompatibility(edgeEndpoints, registry) {
+  for (const [impliedEdgeKind, impliedEndpoints] of edgeEndpoints) {
+    for (const implyingEdgeKind of registry.expandImplyingEdges(
+      impliedEdgeKind
+    )) {
+      if (implyingEdgeKind === impliedEdgeKind) continue;
+      const implyingEndpoints = edgeEndpoints.get(implyingEdgeKind);
+      if (!implyingEndpoints) continue;
+      assertEndpointCompatible(
+        "from",
+        implyingEdgeKind,
+        implyingEndpoints.from,
+        impliedEdgeKind,
+        impliedEndpoints.from,
+        registry
+      );
+      assertEndpointCompatible(
+        "to",
+        implyingEdgeKind,
+        implyingEndpoints.to,
+        impliedEdgeKind,
+        impliedEndpoints.to,
+        registry
+      );
+    }
+  }
+}
+function assertEndpointCompatible(side, implyingEdgeKind, implyingKinds, impliedEdgeKind, impliedKinds, registry) {
+  const incompatibleKinds = implyingKinds.filter(
+    (kind) => !registry.isAssignableToAny(kind, impliedKinds)
+  );
+  if (incompatibleKinds.length === 0) return;
+  throw new ConfigurationError(
+    `implies("${implyingEdgeKind}", "${impliedEdgeKind}") is endpoint-incompatible: ${side} kind(s) [${incompatibleKinds.join(", ")}] declared on "${implyingEdgeKind}" cannot be assigned to any of "${impliedEdgeKind}"'s ${side} kind(s) [${impliedKinds.join(", ")}].`,
+    {
+      metaEdge: META_EDGE_IMPLIES,
+      implyingEdge: implyingEdgeKind,
+      impliedEdge: impliedEdgeKind,
+      endpoint: side,
+      incompatibleKinds,
+      allowedKinds: impliedKinds
+    },
+    {
+      suggestion: `Add a subClassOf relation from each of [${incompatibleKinds.join(", ")}] to one of "${impliedEdgeKind}"'s ${side} kind(s) [${impliedKinds.join(", ")}], narrow "${implyingEdgeKind}"'s ${side} declaration to exclude [${incompatibleKinds.join(", ")}], or remove implies("${implyingEdgeKind}", "${impliedEdgeKind}").`
+    }
+  );
+}
+
+// src/registry/builders.ts
+function buildKindRegistry(graph) {
+  const nodeTypes = extractNodeTypes(graph);
+  const edgeTypes = extractEdgeTypes(graph);
+  const closures = graph.ontology.length > 0 ? computeClosuresFromOntology(graph.ontology) : createEmptyClosures();
+  const registry = new KindRegistry(nodeTypes, edgeTypes, closures);
+  validateImpliesEndpointCompatibility(
+    buildEdgeEndpointKinds(graph.edges),
+    registry
+  );
+  return registry;
+}
+function buildEdgeEndpointKinds(edges) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [kind, registration] of Object.entries(edges)) {
+    result.set(kind, {
+      from: registration.from.map((node) => node.kind),
+      to: registration.to.map((node) => node.kind)
+    });
+  }
+  return result;
+}
+function extractNodeTypes(graph) {
+  const result = /* @__PURE__ */ new Map();
+  for (const typeName of getNodeKinds(graph)) {
+    const registration = graph.nodes[typeName];
+    result.set(typeName, registration.type);
+  }
+  return result;
+}
+function extractEdgeTypes(graph) {
+  const result = /* @__PURE__ */ new Map();
+  for (const typeName of getEdgeKinds(graph)) {
+    const registration = graph.edges[typeName];
+    result.set(typeName, registration.type);
+  }
+  return result;
+}
 var deleteBehaviorZod = z.enum(["restrict", "cascade", "disconnect"]);
 var cardinalityZod = z.enum(["many", "one", "unique", "oneActive"]);
 var endpointExistenceZod = z.enum(["notDeleted", "currentlyValid", "ever"]);
@@ -2057,6 +2231,12 @@ var systemColumnNameZod = z.enum([
   "updated_at",
   "version"
 ]);
+var nodeSystemColumnNameZod = systemColumnNameZod.exclude([
+  "from_kind",
+  "from_id",
+  "to_kind",
+  "to_id"
+]);
 var indexWhereOperandZod = z.discriminatedUnion("__type", [
   z.object({
     __type: z.literal("index_operand_system"),
@@ -2133,7 +2313,13 @@ var indexDeclarationCommonShape = {
 var nodeIndexDeclarationZod = z.object({
   entity: z.literal("node"),
   kind: z.string(),
-  ...indexDeclarationCommonShape
+  ...indexDeclarationCommonShape,
+  // Node-only; canonicalized by absence like `method`, so absent/optional
+  // here matches `defineNodeIndex` only emitting it when non-empty.
+  // `.min(1)` rejects an explicit `[]` at the boundary rather than
+  // silently accepting a present-but-empty array that would have to be
+  // canonicalized away again downstream (see `serializeNodeIndexDeclaration`).
+  keySystemColumns: z.array(nodeSystemColumnNameZod).min(1).optional()
 }).loose();
 var edgeIndexDeclarationZod = z.object({
   entity: z.literal("edge"),
@@ -2532,6 +2718,7 @@ function schemaNotInitializedError(graphId, cause) {
   );
 }
 async function initializeSchema(backend, graph) {
+  buildKindRegistry(graph);
   const schema = serializeSchema(graph, 1);
   const hash = await computeSchemaHash(schema);
   return backend.commitSchemaVersion({
@@ -2551,6 +2738,7 @@ async function migrateSchema(backend, graph, currentVersion) {
   return committed.version;
 }
 async function commitNewSchemaVersion(backend, graph, currentVersion) {
+  buildKindRegistry(graph);
   const newVersion = currentVersion + 1;
   const schema = serializeSchema(graph, newVersion);
   const hash = await computeSchemaHash(schema);
@@ -2593,78 +2781,6 @@ async function getSchemaChanges(backend, graph) {
   return computeSchemaDiff(storedSchema, currentSchema);
 }
 
-// src/errors/validation.ts
-function zodIssuesToValidationIssues(error) {
-  return error.issues.map((issue) => ({
-    path: issue.path.join("."),
-    message: issue.message,
-    code: issue.code
-  }));
-}
-function buildLocationString(context) {
-  if (context.id) {
-    return `${context.kind}/${context.id}`;
-  }
-  return `new ${context.kind}`;
-}
-function validateProps(schema, props, context) {
-  const result = schema.safeParse(props);
-  if (result.success) {
-    return result.data;
-  }
-  const issues = zodIssuesToValidationIssues(result.error);
-  const location = buildLocationString(context);
-  throw new ValidationError(
-    `Invalid ${context.entityType} props for ${location}: ${result.error.message}`,
-    {
-      entityType: context.entityType,
-      kind: context.kind,
-      operation: context.operation,
-      ...context.id !== void 0 && { id: context.id },
-      issues
-    },
-    { cause: result.error }
-  );
-}
-function validateNodeProps(schema, props, context) {
-  return validateProps(schema, props, {
-    entityType: "node",
-    ...context
-  });
-}
-function validateEdgeProps(schema, props, context) {
-  return validateProps(schema, props, {
-    entityType: "edge",
-    ...context
-  });
-}
-function wrapZodError(error, context) {
-  const issues = zodIssuesToValidationIssues(error);
-  const location = buildLocationString(context);
-  return new ValidationError(
-    `Validation failed for ${context.entityType} ${location}: ${error.message}`,
-    {
-      entityType: context.entityType,
-      kind: context.kind,
-      operation: context.operation,
-      ...context.id !== void 0 && { id: context.id },
-      issues
-    },
-    { cause: error }
-  );
-}
-function createValidationError(message, issues, context) {
-  return new ValidationError(message, {
-    ...context?.entityType !== void 0 && {
-      entityType: context.entityType
-    },
-    ...context?.kind !== void 0 && { kind: context.kind },
-    ...context?.operation !== void 0 && { operation: context.operation },
-    ...context?.id !== void 0 && { id: context.id },
-    issues
-  });
-}
-
-export { KindRegistry, META_EDGE_BRAND, applyDeprecatedKinds, assertSchemaCurrent, broader, buildGraphExtensionOntologyKeySet, commitNewSchemaVersion, compileTimeOntologyKey, computeClosuresFromOntology, computeSchemaDiff, computeSchemaHash, core, createEmptyClosures, createValidationError, defineEdge, defineNode, deserializeWherePredicate, differentFrom, disjointWith, ensureSchema, equivalentTo, extensionKindNames, getActiveSchema, getMigrationActions, getSchemaChanges, getTypeName, hasPart, implies, initializeSchema, inverseOf, isBackwardsCompatible, isMetaEdge, isSchemaInitialized, loadActiveSchemaWithBootstrap, loadAndMergeGraphExtensionDocument, loadAndVerifyGraph, mergeGraphExtension, migrateSchema, narrower, parseSerializedSchema, partOf, relatedTo, rollbackSchema, sameAs, serializeSchema, serializeSchemaProperties, subClassOf, validateEdgeProps, validateNodeProps, validateProps, wrapZodError };
-//# sourceMappingURL=chunk-XVUJY72M.js.map
-//# sourceMappingURL=chunk-XVUJY72M.js.map
+export { KindRegistry, META_EDGE_BRAND, applyDeprecatedKinds, assertSchemaCurrent, broader, buildGraphExtensionOntologyKeySet, buildKindRegistry, commitNewSchemaVersion, compileTimeOntologyKey, computeSchemaDiff, computeSchemaHash, core, defineEdge, defineNode, deserializeWherePredicate, differentFrom, disjointWith, ensureSchema, equivalentTo, extensionKindNames, getActiveSchema, getMigrationActions, getSchemaChanges, getTypeName, hasPart, implies, initializeSchema, inverseOf, isBackwardsCompatible, isMetaEdge, isSchemaInitialized, loadActiveSchemaWithBootstrap, loadAndMergeGraphExtensionDocument, loadAndVerifyGraph, mergeGraphExtension, migrateSchema, narrower, parseSerializedSchema, partOf, relatedTo, rollbackSchema, sameAs, serializeIndexDeclaration, serializeSchema, serializeSchemaProperties, subClassOf, validateImpliesEndpointCompatibility };
+//# sourceMappingURL=chunk-K3PPLHY7.js.map
+//# sourceMappingURL=chunk-K3PPLHY7.js.map