@utaba/deep-memory 0.7.0 → 0.8.1

package/dist/index.js

@@ -281,6 +281,270 @@ function generateRelationshipId() {
   return generateId();
 }
 
+// src/vocabulary/similarity.ts
+function jaroSimilarity(a, b) {
+  if (a === b) return 1;
+  if (a.length === 0 || b.length === 0) return 0;
+  const matchWindow = Math.max(Math.floor(Math.max(a.length, b.length) / 2) - 1, 0);
+  const aMatches = new Array(a.length).fill(false);
+  const bMatches = new Array(b.length).fill(false);
+  let matches = 0;
+  let transpositions = 0;
+  for (let i = 0; i < a.length; i++) {
+    const start = Math.max(0, i - matchWindow);
+    const end = Math.min(i + matchWindow + 1, b.length);
+    for (let j = start; j < end; j++) {
+      if (bMatches[j] || a[i] !== b[j]) continue;
+      aMatches[i] = true;
+      bMatches[j] = true;
+      matches++;
+      break;
+    }
+  }
+  if (matches === 0) return 0;
+  let k = 0;
+  for (let i = 0; i < a.length; i++) {
+    if (!aMatches[i]) continue;
+    while (!bMatches[k]) k++;
+    if (a[i] !== b[k]) transpositions++;
+    k++;
+  }
+  return (matches / a.length + matches / b.length + (matches - transpositions / 2) / matches) / 3;
+}
+function jaroWinklerSimilarity(a, b, scalingFactor = 0.1) {
+  const jaro = jaroSimilarity(a, b);
+  if (jaro === 0) return 0;
+  const prefixLength = Math.min(4, Math.min(a.length, b.length));
+  let commonPrefix = 0;
+  for (let i = 0; i < prefixLength; i++) {
+    if (a[i] === b[i]) {
+      commonPrefix++;
+    } else {
+      break;
+    }
+  }
+  return jaro + commonPrefix * Math.min(scalingFactor, 0.25) * (1 - jaro);
+}
+function normalizeTypeName(name) {
+  return name.toLowerCase().trim().replace(/[-\s.]+/g, "_").replace(/[^a-z0-9_]/g, "");
+}
+function toScreamingSnakeCase(name) {
+  return name.trim().replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/[-\s.]+/g, "_").replace(/[^A-Za-z0-9_]/g, "").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+}
+
+// src/vocabulary/VocabularyValidator.ts
+function ok() {
+  return { valid: true, errors: [] };
+}
+function fail(...errors) {
+  return { valid: false, errors };
+}
+function merge(...results) {
+  const errors = results.flatMap((r) => r.errors);
+  return { valid: errors.length === 0, errors };
+}
+function findClosestType(typeName, types) {
+  if (types.length === 0) return void 0;
+  const lower = typeName.toLowerCase();
+  const match = types.find(
+    (t) => t.type.toLowerCase().includes(lower) || lower.includes(t.type.toLowerCase())
+  );
+  return match?.type;
+}
+function validatePropertySchema(schema) {
+  if (schema.embeddable === true && schema.type !== "string") {
+    return fail({
+      field: `properties.${schema.name}`,
+      message: `Property "${schema.name}" cannot be embeddable \u2014 only string properties support embedding (type is "${schema.type}")`
+    });
+  }
+  return ok();
+}
+function validatePropertyValue(name, value, schema) {
+  if (value === void 0 || value === null) {
+    if (schema.required) {
+      return fail({
+        field: `properties.${name}`,
+        message: `Required property "${name}" is missing`
+      });
+    }
+    return ok();
+  }
+  switch (schema.type) {
+    case "string":
+      if (typeof value !== "string") {
+        return fail({
+          field: `properties.${name}`,
+          message: `Property "${name}" must be a string, got ${typeof value}`
+        });
+      }
+      break;
+    case "number":
+      if (typeof value !== "number" || Number.isNaN(value)) {
+        return fail({
+          field: `properties.${name}`,
+          message: `Property "${name}" must be a number, got ${typeof value}`
+        });
+      }
+      break;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        return fail({
+          field: `properties.${name}`,
+          message: `Property "${name}" must be a boolean, got ${typeof value}`
+        });
+      }
+      break;
+    case "date":
+      if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+        return fail({
+          field: `properties.${name}`,
+          message: `Property "${name}" must be a valid ISO date string`
+        });
+      }
+      break;
+    case "enum":
+      if (typeof value !== "string") {
+        return fail({
+          field: `properties.${name}`,
+          message: `Property "${name}" must be a string (enum value), got ${typeof value}`
+        });
+      }
+      if (schema.enumValues && !schema.enumValues.includes(value)) {
+        return fail({
+          field: `properties.${name}`,
+          message: `Property "${name}" must be one of: ${schema.enumValues.join(", ")}`,
+          suggestion: `Valid values: ${schema.enumValues.join(", ")}`
+        });
+      }
+      break;
+  }
+  return ok();
+}
+function validateProperties(properties, schemas) {
+  const results = [];
+  const providedProperties = properties ?? {};
+  for (const schema of schemas) {
+    const value = providedProperties[schema.name];
+    results.push(validatePropertyValue(schema.name, value, schema));
+  }
+  if (schemas.length > 0) {
+    const knownNames = new Set(schemas.map((s) => s.name));
+    for (const key of Object.keys(providedProperties)) {
+      if (!knownNames.has(key)) {
+        results.push(fail({
+          field: `properties.${key}`,
+          message: `Unknown property "${key}"`,
+          suggestion: `Known properties: ${schemas.map((s) => s.name).join(", ")}`
+        }));
+      }
+    }
+  }
+  return merge(...results);
+}
+function validateEntity(input, vocabulary) {
+  const entityTypeDef = vocabulary.entityTypes.find((et) => et.type === input.entityType);
+  if (!entityTypeDef) {
+    const closest = findClosestType(input.entityType, vocabulary.entityTypes);
+    return fail({
+      field: "entityType",
+      message: `Entity type "${input.entityType}" does not exist in the vocabulary`,
+      suggestion: closest ? `Did you mean "${closest}"?` : `Available types: ${vocabulary.entityTypes.map((et) => et.type).join(", ") || "none"}`
+    });
+  }
+  if (!input.label || input.label.trim().length === 0) {
+    return fail({
+      field: "label",
+      message: "Entity label is required and cannot be empty"
+    });
+  }
+  return validateProperties(input.properties, entityTypeDef.properties);
+}
+function validateEntityUpdate(input, currentEntityTypeDef, vocabulary) {
+  if (input.label !== void 0 && input.label.trim().length === 0) {
+    return fail({
+      field: "label",
+      message: "Entity label cannot be empty"
+    });
+  }
+  let targetTypeDef = currentEntityTypeDef;
+  if (input.entityType !== void 0 && input.entityType !== currentEntityTypeDef.type) {
+    const newTypeDef = vocabulary.entityTypes.find((et) => et.type === input.entityType);
+    if (!newTypeDef) {
+      const closest = findClosestType(input.entityType, vocabulary.entityTypes);
+      return fail({
+        field: "entityType",
+        message: `Entity type "${input.entityType}" does not exist in the vocabulary`,
+        suggestion: closest ? `Did you mean "${closest}"?` : `Available types: ${vocabulary.entityTypes.map((et) => et.type).join(", ") || "none"}`
+      });
+    }
+    targetTypeDef = newTypeDef;
+  }
+  if (input.properties) {
+    const results = [];
+    const hasDefinedProps = targetTypeDef.properties.length > 0;
+    for (const [key, value] of Object.entries(input.properties)) {
+      if (value === null) continue;
+      const schema = targetTypeDef.properties.find((p) => p.name === key);
+      if (!schema) {
+        if (hasDefinedProps) {
+          results.push(fail({
+            field: `properties.${key}`,
+            message: `Unknown property "${key}"`,
+            suggestion: `Known properties: ${targetTypeDef.properties.map((p) => p.name).join(", ")}`
+          }));
+        }
+      } else {
+        results.push(validatePropertyValue(key, value, schema));
+      }
+    }
+    return merge(...results);
+  }
+  return ok();
+}
+function validateRelationship(input, vocabulary, sourceEntityType, targetEntityType) {
+  const normalizedType = toScreamingSnakeCase(input.relationshipType);
+  const relTypeDef = vocabulary.relationshipTypes.find(
+    (rt) => rt.type === normalizedType
+  );
+  if (!relTypeDef) {
+    const closest = findClosestType(input.relationshipType, vocabulary.relationshipTypes);
+    return fail({
+      field: "relationshipType",
+      message: `Relationship type "${input.relationshipType}" does not exist in the vocabulary`,
+      suggestion: closest ? `Did you mean "${closest}"?` : `Available types: ${vocabulary.relationshipTypes.map((rt) => rt.type).join(", ") || "none"}`
+    });
+  }
+  const results = [];
+  if (relTypeDef.allowedSourceTypes.length > 0 && !relTypeDef.allowedSourceTypes.includes(sourceEntityType)) {
+    results.push(
+      fail({
+        field: "sourceEntityId",
+        message: `Entity type "${sourceEntityType}" is not allowed as source for relationship type "${input.relationshipType}"`,
+        suggestion: `Allowed source types: ${relTypeDef.allowedSourceTypes.join(", ")}`
+      })
+    );
+  }
+  if (relTypeDef.allowedTargetTypes.length > 0 && !relTypeDef.allowedTargetTypes.includes(targetEntityType)) {
+    results.push(
+      fail({
+        field: "targetEntityId",
+        message: `Entity type "${targetEntityType}" is not allowed as target for relationship type "${input.relationshipType}"`,
+        suggestion: `Allowed target types: ${relTypeDef.allowedTargetTypes.join(", ")}`
+      })
+    );
+  }
+  if (relTypeDef.properties) {
+    results.push(
+      validateProperties(input.properties, relTypeDef.properties)
+    );
+  }
+  return merge(...results);
+}
+function getEntityTypeDef(entityType, vocabulary) {
+  return vocabulary.entityTypes.find((et) => et.type === entityType) ?? null;
+}
+
 // src/entities/EntityManager.ts
 var EntityManager = class {
   constructor(repositoryId, vocabularyEngine, provenanceTracker, eventBus, storage, embedding) {
@@ -330,7 +594,7 @@ var EntityManager = class {
         }
       );
       const provenance = this.provenanceTracker.stampCreate();
-      const entityEmbedding = await this.generateEmbedding(input.label, input.summary);
+      const entityEmbedding = await this.generateEmbedding(input.label, input.summary, input.properties ?? {}, input.entityType);
       const storedEntity = {
         id,
         slug,
@@ -404,9 +668,10 @@ var EntityManager = class {
         }
       );
     }
-    const needsReembed = updates.reembed === true || updates.label !== void 0 || updates.summary !== void 0;
+    const needsReembed = updates.reembed === true || updates.label !== void 0 || updates.summary !== void 0 || updates.properties !== void 0;
     const nextSummary = updates.summary === void 0 ? existing.summary : updates.summary ?? void 0;
-    const entityEmbedding = needsReembed ? await this.generateEmbedding(updates.label ?? existing.label, nextSummary) : void 0;
+    const nextEntityType = updates.entityType ?? existing.entityType;
+    const entityEmbedding = needsReembed ? await this.generateEmbedding(updates.label ?? existing.label, nextSummary, mergedProperties, nextEntityType) : void 0;
     const updated = await this.storage.updateEntity(this.repositoryId, entityId, {
       entityType: typeChanged ? updates.entityType : void 0,
       label: updates.label,
@@ -520,7 +785,12 @@ var EntityManager = class {
     const maxRetries = options?.maxRetries ?? 3;
     const storedMap = await this.storage.getEntities(this.repositoryId, entityIds);
     const entries = Array.from(storedMap.entries());
-    const texts = entries.map(([, e]) => [e.label, e.summary ?? ""].join(" "));
+    const vocab = await this.vocabularyEngine.getVocabulary();
+    const texts = entries.map(([, e]) => {
+      const typeDef = getEntityTypeDef(e.entityType, vocab);
+      const embeddableValues = typeDef ? typeDef.properties.filter((p) => p.embeddable === true && typeof e.properties[p.name] === "string").map((p) => e.properties[p.name]) : [];
+      return [e.label, e.summary ?? "", ...embeddableValues].filter(Boolean).join(" ");
+    });
     let embeddings;
     let attempt = 0;
     while (true) {
@@ -622,95 +892,47 @@ var EntityManager = class {
       dimensions: this.embedding.dimensions()
     };
   }
-  /** Generate an embedding vector from label + summary if a provider is available */
-  async generateEmbedding(label, summary) {
+  /** Generate an embedding vector from label + summary + embeddable string properties if a provider is available */
+  async generateEmbedding(label, summary, properties, entityType) {
     if (!this.embedding) return void 0;
-    const text = [label, summary ?? ""].join(" ");
-    return this.embedding.embed(text);
-  }
-};
-function storedToEntity(stored) {
-  return {
-    id: stored.id,
-    slug: stored.slug,
-    entityType: stored.entityType,
-    label: stored.label,
-    summary: stored.summary,
-    properties: stored.properties,
-    data: stored.data,
-    dataFormat: stored.dataFormat,
-    provenance: stored.provenance
-  };
-}
-function storedToSummary(stored) {
-  return {
-    id: stored.id,
-    slug: stored.slug,
-    entityType: stored.entityType,
-    label: stored.label,
-    summary: stored.summary,
-    properties: stored.properties
-  };
-}
-function storedToBrief(stored) {
-  return {
-    id: stored.id,
-    slug: stored.slug,
-    entityType: stored.entityType,
-    label: stored.label,
-    summary: stored.summary
-  };
-}
-
-// src/vocabulary/similarity.ts
-function jaroSimilarity(a, b) {
-  if (a === b) return 1;
-  if (a.length === 0 || b.length === 0) return 0;
-  const matchWindow = Math.max(Math.floor(Math.max(a.length, b.length) / 2) - 1, 0);
-  const aMatches = new Array(a.length).fill(false);
-  const bMatches = new Array(b.length).fill(false);
-  let matches = 0;
-  let transpositions = 0;
-  for (let i = 0; i < a.length; i++) {
-    const start = Math.max(0, i - matchWindow);
-    const end = Math.min(i + matchWindow + 1, b.length);
-    for (let j = start; j < end; j++) {
-      if (bMatches[j] || a[i] !== b[j]) continue;
-      aMatches[i] = true;
-      bMatches[j] = true;
-      matches++;
-      break;
-    }
-  }
-  if (matches === 0) return 0;
-  let k = 0;
-  for (let i = 0; i < a.length; i++) {
-    if (!aMatches[i]) continue;
-    while (!bMatches[k]) k++;
-    if (a[i] !== b[k]) transpositions++;
-    k++;
-  }
-  return (matches / a.length + matches / b.length + (matches - transpositions / 2) / matches) / 3;
-}
-function jaroWinklerSimilarity(a, b, scalingFactor = 0.1) {
-  const jaro = jaroSimilarity(a, b);
-  if (jaro === 0) return 0;
-  const prefixLength = Math.min(4, Math.min(a.length, b.length));
-  let commonPrefix = 0;
-  for (let i = 0; i < prefixLength; i++) {
-    if (a[i] === b[i]) {
-      commonPrefix++;
-    } else {
-      break;
-    }
+    const vocab = await this.vocabularyEngine.getVocabulary();
+    const typeDef = getEntityTypeDef(entityType, vocab);
+    const embeddableValues = typeDef ? typeDef.properties.filter((p) => p.embeddable === true && typeof properties[p.name] === "string").map((p) => properties[p.name]) : [];
+    const text = [label, summary ?? "", ...embeddableValues].filter(Boolean).join(" ");
+    return this.embedding.embed(text);
   }
-  return jaro + commonPrefix * Math.min(scalingFactor, 0.25) * (1 - jaro);
+};
+function storedToEntity(stored) {
+  return {
+    id: stored.id,
+    slug: stored.slug,
+    entityType: stored.entityType,
+    label: stored.label,
+    summary: stored.summary,
+    properties: stored.properties,
+    data: stored.data,
+    dataFormat: stored.dataFormat,
+    provenance: stored.provenance
+  };
 }
-function normalizeTypeName(name) {
-  return name.toLowerCase().trim().replace(/[-\s.]+/g, "_").replace(/[^a-z0-9_]/g, "");
+function storedToSummary(stored) {
+  return {
+    id: stored.id,
+    slug: stored.slug,
+    entityType: stored.entityType,
+    label: stored.label,
+    summary: stored.summary,
+    properties: stored.properties
+  };
 }
-function toScreamingSnakeCase(name) {
-  return name.trim().replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/[-\s.]+/g, "_").replace(/[^A-Za-z0-9_]/g, "").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+function storedToBrief(stored) {
+  return {
+    id: stored.id,
+    slug: stored.slug,
+    entityType: stored.entityType,
+    label: stored.label,
+    summary: stored.summary
+  };
 }
 
 // src/relationships/RelationshipManager.ts
@@ -1537,6 +1759,7 @@ var SearchOrchestrator = class {
   search;
   embedding;
   eventBus;
+  vocabularyEngine;
   defaultSimilarityThreshold;
   conceptSearchScanLimit;
   constructor(config) {
@@ -1545,6 +1768,7 @@ var SearchOrchestrator = class {
     this.search = config.search;
     this.embedding = config.embedding;
     this.eventBus = config.eventBus;
+    this.vocabularyEngine = config.vocabularyEngine;
     this.defaultSimilarityThreshold = config.defaultSimilarityThreshold ?? 0.5;
     this.conceptSearchScanLimit = config.conceptSearchScanLimit ?? 1e3;
   }
@@ -1619,7 +1843,7 @@ var SearchOrchestrator = class {
       if (entity.embedding && entity.embedding.length > 0) {
         score = this.cosineSimilarity(queryEmbedding, entity.embedding);
       } else {
-        const entityText = [entity.label, entity.summary ?? ""].join(" ");
+        const entityText = await this.buildEmbeddingText(entity.entityType, entity.label, entity.summary, entity.properties);
         const entityEmbedding = await this.embedding.embed(entityText);
         score = this.cosineSimilarity(queryEmbedding, entityEmbedding);
       }
@@ -1678,6 +1902,22 @@ var SearchOrchestrator = class {
       offset
     };
   }
+  /** Build the embedding text for an entity — label + summary + embeddable string properties */
+  async buildEmbeddingText(entityType, label, summary, properties) {
+    const embeddableValues = [];
+    if (this.vocabularyEngine) {
+      const vocab = await this.vocabularyEngine.getVocabulary();
+      const typeDef = getEntityTypeDef(entityType, vocab);
+      if (typeDef) {
+        for (const p of typeDef.properties) {
+          if (p.embeddable === true && typeof properties[p.name] === "string") {
+            embeddableValues.push(properties[p.name]);
+          }
+        }
+      }
+    }
+    return [label, summary ?? "", ...embeddableValues].filter(Boolean).join(" ");
+  }
   /** Cosine similarity between two vectors */
   cosineSimilarity(a, b) {
     if (this.embedding?.similarity) {
@@ -1704,210 +1944,6 @@ var SearchOrchestrator = class {
   }
 };
 
-// src/vocabulary/VocabularyValidator.ts
-function ok() {
-  return { valid: true, errors: [] };
-}
-function fail(...errors) {
-  return { valid: false, errors };
-}
-function merge(...results) {
-  const errors = results.flatMap((r) => r.errors);
-  return { valid: errors.length === 0, errors };
-}
-function findClosestType(typeName, types) {
-  if (types.length === 0) return void 0;
-  const lower = typeName.toLowerCase();
-  const match = types.find(
-    (t) => t.type.toLowerCase().includes(lower) || lower.includes(t.type.toLowerCase())
-  );
-  return match?.type;
-}
-function validatePropertyValue(name, value, schema) {
-  if (value === void 0 || value === null) {
-    if (schema.required) {
-      return fail({
-        field: `properties.${name}`,
-        message: `Required property "${name}" is missing`
-      });
-    }
-    return ok();
-  }
-  switch (schema.type) {
-    case "string":
-      if (typeof value !== "string") {
-        return fail({
-          field: `properties.${name}`,
-          message: `Property "${name}" must be a string, got ${typeof value}`
-        });
-      }
-      break;
-    case "number":
-      if (typeof value !== "number" || Number.isNaN(value)) {
-        return fail({
-          field: `properties.${name}`,
-          message: `Property "${name}" must be a number, got ${typeof value}`
-        });
-      }
-      break;
-    case "boolean":
-      if (typeof value !== "boolean") {
-        return fail({
-          field: `properties.${name}`,
-          message: `Property "${name}" must be a boolean, got ${typeof value}`
-        });
-      }
-      break;
-    case "date":
-      if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
-        return fail({
-          field: `properties.${name}`,
-          message: `Property "${name}" must be a valid ISO date string`
-        });
-      }
-      break;
-    case "enum":
-      if (typeof value !== "string") {
-        return fail({
-          field: `properties.${name}`,
-          message: `Property "${name}" must be a string (enum value), got ${typeof value}`
-        });
-      }
-      if (schema.enumValues && !schema.enumValues.includes(value)) {
-        return fail({
-          field: `properties.${name}`,
-          message: `Property "${name}" must be one of: ${schema.enumValues.join(", ")}`,
-          suggestion: `Valid values: ${schema.enumValues.join(", ")}`
-        });
-      }
-      break;
-  }
-  return ok();
-}
-function validateProperties(properties, schemas) {
-  const results = [];
-  const providedProperties = properties ?? {};
-  for (const schema of schemas) {
-    const value = providedProperties[schema.name];
-    results.push(validatePropertyValue(schema.name, value, schema));
-  }
-  if (schemas.length > 0) {
-    const knownNames = new Set(schemas.map((s) => s.name));
-    for (const key of Object.keys(providedProperties)) {
-      if (!knownNames.has(key)) {
-        results.push(fail({
-          field: `properties.${key}`,
-          message: `Unknown property "${key}"`,
-          suggestion: `Known properties: ${schemas.map((s) => s.name).join(", ")}`
-        }));
-      }
-    }
-  }
-  return merge(...results);
-}
-function validateEntity(input, vocabulary) {
-  const entityTypeDef = vocabulary.entityTypes.find((et) => et.type === input.entityType);
-  if (!entityTypeDef) {
-    const closest = findClosestType(input.entityType, vocabulary.entityTypes);
-    return fail({
-      field: "entityType",
-      message: `Entity type "${input.entityType}" does not exist in the vocabulary`,
-      suggestion: closest ? `Did you mean "${closest}"?` : `Available types: ${vocabulary.entityTypes.map((et) => et.type).join(", ") || "none"}`
-    });
-  }
-  if (!input.label || input.label.trim().length === 0) {
-    return fail({
-      field: "label",
-      message: "Entity label is required and cannot be empty"
-    });
-  }
-  return validateProperties(input.properties, entityTypeDef.properties);
-}
-function validateEntityUpdate(input, currentEntityTypeDef, vocabulary) {
-  if (input.label !== void 0 && input.label.trim().length === 0) {
-    return fail({
-      field: "label",
-      message: "Entity label cannot be empty"
-    });
-  }
-  let targetTypeDef = currentEntityTypeDef;
-  if (input.entityType !== void 0 && input.entityType !== currentEntityTypeDef.type) {
-    const newTypeDef = vocabulary.entityTypes.find((et) => et.type === input.entityType);
-    if (!newTypeDef) {
-      const closest = findClosestType(input.entityType, vocabulary.entityTypes);
-      return fail({
-        field: "entityType",
-        message: `Entity type "${input.entityType}" does not exist in the vocabulary`,
-        suggestion: closest ? `Did you mean "${closest}"?` : `Available types: ${vocabulary.entityTypes.map((et) => et.type).join(", ") || "none"}`
-      });
-    }
-    targetTypeDef = newTypeDef;
-  }
-  if (input.properties) {
-    const results = [];
-    const hasDefinedProps = targetTypeDef.properties.length > 0;
-    for (const [key, value] of Object.entries(input.properties)) {
-      if (value === null) continue;
-      const schema = targetTypeDef.properties.find((p) => p.name === key);
-      if (!schema) {
-        if (hasDefinedProps) {
-          results.push(fail({
-            field: `properties.${key}`,
-            message: `Unknown property "${key}"`,
-            suggestion: `Known properties: ${targetTypeDef.properties.map((p) => p.name).join(", ")}`
-          }));
-        }
-      } else {
-        results.push(validatePropertyValue(key, value, schema));
-      }
-    }
-    return merge(...results);
-  }
-  return ok();
-}
-function validateRelationship(input, vocabulary, sourceEntityType, targetEntityType) {
-  const normalizedType = toScreamingSnakeCase(input.relationshipType);
-  const relTypeDef = vocabulary.relationshipTypes.find(
-    (rt) => rt.type === normalizedType
-  );
-  if (!relTypeDef) {
-    const closest = findClosestType(input.relationshipType, vocabulary.relationshipTypes);
-    return fail({
-      field: "relationshipType",
-      message: `Relationship type "${input.relationshipType}" does not exist in the vocabulary`,
-      suggestion: closest ? `Did you mean "${closest}"?` : `Available types: ${vocabulary.relationshipTypes.map((rt) => rt.type).join(", ") || "none"}`
-    });
-  }
-  const results = [];
-  if (relTypeDef.allowedSourceTypes.length > 0 && !relTypeDef.allowedSourceTypes.includes(sourceEntityType)) {
-    results.push(
-      fail({
-        field: "sourceEntityId",
-        message: `Entity type "${sourceEntityType}" is not allowed as source for relationship type "${input.relationshipType}"`,
-        suggestion: `Allowed source types: ${relTypeDef.allowedSourceTypes.join(", ")}`
-      })
-    );
-  }
-  if (relTypeDef.allowedTargetTypes.length > 0 && !relTypeDef.allowedTargetTypes.includes(targetEntityType)) {
-    results.push(
-      fail({
-        field: "targetEntityId",
-        message: `Entity type "${targetEntityType}" is not allowed as target for relationship type "${input.relationshipType}"`,
-        suggestion: `Allowed target types: ${relTypeDef.allowedTargetTypes.join(", ")}`
-      })
-    );
-  }
-  if (relTypeDef.properties) {
-    results.push(
-      validateProperties(input.properties, relTypeDef.properties)
-    );
-  }
-  return merge(...results);
-}
-function getEntityTypeDef(entityType, vocabulary) {
-  return vocabulary.entityTypes.find((et) => et.type === entityType) ?? null;
-}
-
 // src/validation/RepositoryValidator.ts
 var DEFAULT_TAKE = 200;
 var RepositoryValidator = class {
@@ -2129,6 +2165,7 @@ var MemoryRepository = class {
       search: config.search,
       embedding: config.embedding,
       eventBus: config.eventBus,
+      vocabularyEngine: config.vocabularyEngine,
       defaultSimilarityThreshold: config.vocabularyEngine.getGovernanceConfig().defaultSimilarityThreshold
     });
   }
@@ -3172,6 +3209,10 @@ var VocabularyEngine = class {
         }
       }
     }
+    const propertySchemaErrors = this.validateProposalPropertySchemas(proposal);
+    if (propertySchemaErrors) {
+      return propertySchemaErrors;
+    }
     const { result, updatedVocabulary } = processProposal(
       vocabulary,
       proposal,
@@ -3209,6 +3250,37 @@ var VocabularyEngine = class {
     }
     return { deletedEntities: 0, deletedRelationships: 0 };
   }
+  /** Validate all property schemas in a proposal — returns a rejected result on the first invalid schema, or undefined if all pass */
+  validateProposalPropertySchemas(proposal) {
+    const schemas = [];
+    let typeName = "";
+    if (proposal.proposalType === "entity_type" && proposal.entityType) {
+      schemas.push(...proposal.entityType.properties ?? []);
+      typeName = proposal.entityType.type;
+    } else if (proposal.proposalType === "relationship_type" && proposal.relationshipType) {
+      schemas.push(...proposal.relationshipType.properties ?? []);
+      typeName = proposal.relationshipType.type;
+    } else if (proposal.proposalType === "edit_entity_type" && proposal.editEntityType) {
+      schemas.push(...proposal.editEntityType.addProperties ?? []);
+      schemas.push(...proposal.editEntityType.updateProperties ?? []);
+      typeName = proposal.editEntityType.type;
+    } else if (proposal.proposalType === "edit_relationship_type" && proposal.editRelationshipType) {
+      schemas.push(...proposal.editRelationshipType.addProperties ?? []);
+      schemas.push(...proposal.editRelationshipType.updateProperties ?? []);
+      typeName = proposal.editRelationshipType.type;
+    }
+    for (const schema of schemas) {
+      const result = validatePropertySchema(schema);
+      if (!result.valid) {
+        return {
+          status: "rejected",
+          type: typeName,
+          reason: result.errors.map((e) => e.message).join("; ")
+        };
+      }
+    }
+    return void 0;
+  }
   getExistingTypesForProposal(proposal, vocabulary) {
     if (proposal.proposalType === "entity_type") {
       return vocabulary.entityTypes.map((et) => ({
@@ -3359,7 +3431,7 @@ var EventBus = class {
 };
 
 // src/portability/RepositoryExporter.ts
-var LIBRARY_VERSION = true ? "0.7.0" : "0.1.0";
+var LIBRARY_VERSION = true ? "0.8.1" : "0.1.0";
 var RepositoryExporter = class {
   storage;
   provenance;
@@ -3943,8 +4015,21 @@ var RepositoryImporter = class {
                 relationshipId: rel.id
               });
             } else {
-              await this.storage.createRelationship(repositoryId, rel);
-              relationshipsImported++;
+              try {
+                await this.storage.createRelationship(repositoryId, rel);
+                relationshipsImported++;
+              } catch (err) {
+                if (err instanceof DuplicateRelationshipError) {
+                  relationshipsSkipped++;
+                  warnings.push({
+                    code: "relationship_skipped",
+                    message: `Relationship "${rel.id}" already exists \u2014 skipped`,
+                    relationshipId: rel.id
+                  });
+                } else {
+                  throw err;
+                }
+              }
             }
           }
         }