@utaba/deep-memory 0.6.1 → 0.7.0

package/dist/index.cjs

@@ -43,6 +43,8 @@ __export(src_exports, {
   RelationshipConstraintError: () => RelationshipConstraintError,
   RelationshipNotFoundError: () => RelationshipNotFoundError,
   RepositoryNotFoundError: () => RepositoryNotFoundError,
+  RepositoryValidator: () => RepositoryValidator,
+  SelfReferentialRelationshipError: () => SelfReferentialRelationshipError,
   TraversalTimeoutError: () => TraversalTimeoutError,
   TraversalValidationError: () => TraversalValidationError,
   TraversalVocabularyError: () => TraversalVocabularyError,
@@ -181,6 +183,20 @@ var RelationshipConstraintError = class extends DeepMemoryError {
     this.targetType = targetType;
   }
 };
+var SelfReferentialRelationshipError = class extends DeepMemoryError {
+  entityId;
+  relationshipType;
+  constructor(entityId, relationshipType) {
+    super(
+      "SELF_REFERENTIAL_RELATIONSHIP",
+      `Self-referential relationship not allowed: "${relationshipType}" from entity "${entityId}" to itself`,
+      `Relationships must connect two different entities. Check that sourceEntityId and targetEntityId refer to distinct entities.`
+    );
+    this.name = "SelfReferentialRelationshipError";
+    this.entityId = entityId;
+    this.relationshipType = relationshipType;
+  }
+};
 var GovernanceDeniedError = class extends DeepMemoryError {
   governanceMode;
   constructor(governanceMode, reason) {
@@ -339,6 +355,10 @@ var EntityManager = class {
   eventBus;
   storage;
   embedding;
+  /** Swap the embedding provider, e.g. after a repository re-embed changes the model or dimensionality */
+  setEmbeddingProvider(embedding) {
+    this.embedding = embedding;
+  }
   /** Create one or more entities with vocabulary validation, ID generation, provenance, and events */
   async create(inputs) {
     const results = [];
@@ -414,14 +434,41 @@ var EntityManager = class {
       throw new OperationCancelledError("Entity update", hookResult.reason ?? "cancelled by hook");
     }
     const provenance = this.provenanceTracker.stampUpdate(existing.provenance);
-    const mergedProperties = updates.properties ? { ...existing.properties, ...updates.properties } : existing.properties;
+    let mergedProperties = existing.properties;
+    if (updates.properties) {
+      const merged = { ...existing.properties };
+      for (const [key, value] of Object.entries(updates.properties)) {
+        if (value === null) {
+          delete merged[key];
+        } else {
+          merged[key] = value;
+        }
+      }
+      mergedProperties = merged;
+    }
+    const typeChanged = updates.entityType !== void 0 && updates.entityType !== existing.entityType;
+    const labelChanged = updates.label !== void 0 && updates.label !== existing.label;
+    let newSlug;
+    if (typeChanged || labelChanged) {
+      const nextType = updates.entityType ?? existing.entityType;
+      const nextLabel = updates.label ?? existing.label;
+      newSlug = await generateUniqueSlug(
+        nextType,
+        nextLabel,
+        async (candidateSlug) => {
+          if (candidateSlug === existing.slug) return false;
+          const other = await this.storage.getEntityBySlug(this.repositoryId, candidateSlug);
+          return other !== null;
+        }
+      );
+    }
     const needsReembed = updates.reembed === true || updates.label !== void 0 || updates.summary !== void 0;
-    const entityEmbedding = needsReembed ? await this.generateEmbedding(
-      updates.label ?? existing.label,
-      updates.summary !== void 0 ? updates.summary : existing.summary
-    ) : 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 updated = await this.storage.updateEntity(this.repositoryId, entityId, {
+      entityType: typeChanged ? updates.entityType : void 0,
       label: updates.label,
+      slug: newSlug,
       summary: updates.summary,
       properties: updates.properties ? mergedProperties : void 0,
       data: updates.data,
@@ -492,18 +539,33 @@ var EntityManager = class {
       offset: result.offset
     };
   }
-  /** Delete an entity */
+  /** Delete an entity — throws EntityNotFoundError if it does not exist */
   async delete(entityId) {
     const existing = await this.storage.getEntity(this.repositoryId, entityId);
     if (!existing) {
       throw new EntityNotFoundError(entityId);
     }
-    const hookResult = await this.eventBus.emitHook("entity:deleting", { id: entityId });
+    const hookResult = await this.eventBus.emitHook("entity:deleting", { ids: [entityId] });
     if (hookResult.cancelled) {
       throw new OperationCancelledError("Entity deletion", hookResult.reason ?? "cancelled by hook");
     }
     await this.storage.deleteEntity(this.repositoryId, entityId);
-    await this.eventBus.emit("entity:deleted", { id: entityId });
+    await this.eventBus.emit("entity:deleted", { ids: [entityId] });
+  }
+  /** Delete multiple entities in a single batch operation */
+  async deleteMany(ids) {
+    const hookResult = await this.eventBus.emitHook("entity:deleting", { ids });
+    if (hookResult.cancelled) {
+      throw new OperationCancelledError("Entity deletion", hookResult.reason ?? "cancelled by hook");
+    }
+    const { deleted, notFound } = await this.storage.deleteEntities(this.repositoryId, ids);
+    if (deleted.length > 0) {
+      await this.eventBus.emit("entity:deleted", { ids: deleted });
+    }
+    return {
+      deleted,
+      failed: notFound.map((id) => ({ id, error: `Entity '${id}' not found` }))
+    };
   }
   /**
    * Re-embed a specific set of entities using the current EmbeddingProvider.
@@ -727,6 +789,9 @@ var RelationshipManager = class {
   async create(inputs) {
     const results = [];
     for (const input of inputs) {
+      if (input.sourceEntityId === input.targetEntityId) {
+        throw new SelfReferentialRelationshipError(input.sourceEntityId, input.relationshipType);
+      }
       const sourceEntity = await this.storage.getEntity(this.repositoryId, input.sourceEntityId);
       if (!sourceEntity) {
         throw new EntityNotFoundError(input.sourceEntityId);
@@ -777,21 +842,20 @@ var RelationshipManager = class {
     }
     return results;
   }
-  /** Remove a relationship by ID */
-  async remove(relationshipId) {
-    const existing = await this.storage.getRelationship(this.repositoryId, relationshipId);
-    if (!existing) {
-      throw new RelationshipNotFoundError(relationshipId);
-    }
-    const hookResult = await this.eventBus.emitHook("relationship:removing", { id: relationshipId });
+  /** Remove one or more relationships in a single batch storage operation */
+  async removeMany(ids) {
+    const hookResult = await this.eventBus.emitHook("relationship:removing", { ids });
     if (hookResult.cancelled) {
-      throw new OperationCancelledError(
-        "Relationship removal",
-        hookResult.reason ?? "cancelled by hook"
-      );
+      throw new OperationCancelledError("Relationship removal", hookResult.reason ?? "cancelled by hook");
+    }
+    const { deleted, notFound } = await this.storage.deleteRelationships(this.repositoryId, ids);
+    if (deleted.length > 0) {
+      await this.eventBus.emit("relationship:removed", { ids: deleted });
     }
-    await this.storage.deleteRelationship(this.repositoryId, relationshipId);
-    await this.eventBus.emit("relationship:removed", { id: relationshipId });
+    return {
+      removed: deleted,
+      failed: notFound.map((id) => ({ id, error: `Relationship '${id}' not found` }))
+    };
   }
   /** Get relationships for an entity with filtering */
   async getForEntity(entityId, options) {
@@ -1542,6 +1606,10 @@ var SearchOrchestrator = class {
     this.defaultSimilarityThreshold = config.defaultSimilarityThreshold ?? 0.5;
     this.conceptSearchScanLimit = config.conceptSearchScanLimit ?? 1e3;
   }
+  /** Swap the embedding provider, e.g. after a repository re-embed changes the model or dimensionality */
+  setEmbeddingProvider(embedding) {
+    this.embedding = embedding;
+  }
   /**
    * Find entities by label, type, and property filters.
    * When a SearchProvider is available, its results are merged with
@@ -1694,6 +1762,381 @@ 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 {
+  constructor(repositoryId, storage, vocabularyEngine) {
+    this.repositoryId = repositoryId;
+    this.storage = storage;
+    this.vocabularyEngine = vocabularyEngine;
+  }
+  repositoryId;
+  storage;
+  vocabularyEngine;
+  async validateEntities(options) {
+    const offset = options?.offset ?? 0;
+    const take = options?.take ?? DEFAULT_TAKE;
+    const delayMs = options?.delayBetweenChunksMs ?? 0;
+    const vocabulary = await this.vocabularyEngine.getVocabulary();
+    const issues = [];
+    let scanned = 0;
+    let skipped = 0;
+    let stoppedEarly = false;
+    for await (const chunk of this.storage.exportAll(this.repositoryId)) {
+      if (chunk.type !== "entities") {
+        break;
+      }
+      const data = chunk.data;
+      for (const entity of data) {
+        scanned++;
+        const result = validateEntity(
+          {
+            entityType: entity.entityType,
+            label: entity.label,
+            properties: entity.properties
+          },
+          vocabulary
+        );
+        if (!result.valid) {
+          if (skipped < offset) {
+            skipped++;
+            continue;
+          }
+          issues.push({
+            entityId: entity.id,
+            slug: entity.slug,
+            entityType: entity.entityType,
+            label: entity.label,
+            errors: result.errors
+          });
+          if (issues.length >= take) {
+            stoppedEarly = true;
+            break;
+          }
+        }
+      }
+      if (stoppedEarly) break;
+      if (delayMs > 0 && !chunk.isLast) {
+        await new Promise((resolve) => {
+          setTimeout(resolve, delayMs);
+        });
+      }
+    }
+    return {
+      issues,
+      scanned,
+      nextOffset: offset + issues.length,
+      done: !stoppedEarly
+    };
+  }
+  async validateRelationships(options) {
+    const offset = options?.offset ?? 0;
+    const take = options?.take ?? DEFAULT_TAKE;
+    const delayMs = options?.delayBetweenChunksMs ?? 0;
+    const vocabulary = await this.vocabularyEngine.getVocabulary();
+    const entityMap = /* @__PURE__ */ new Map();
+    const issues = [];
+    let scanned = 0;
+    let skipped = 0;
+    let stoppedEarly = false;
+    for await (const chunk of this.storage.exportAll(this.repositoryId)) {
+      if (chunk.type === "entities") {
+        for (const entity of chunk.data) {
+          entityMap.set(entity.id, {
+            entityType: entity.entityType,
+            label: entity.label,
+            slug: entity.slug
+          });
+        }
+        if (delayMs > 0 && !chunk.isLast) {
+          await new Promise((resolve) => {
+            setTimeout(resolve, delayMs);
+          });
+        }
+        continue;
+      }
+      const data = chunk.data;
+      for (const rel of data) {
+        scanned++;
+        const src = entityMap.get(rel.sourceEntityId);
+        const tgt = entityMap.get(rel.targetEntityId);
+        const errors = [];
+        if (!src) {
+          errors.push({
+            field: "sourceEntityId",
+            message: `Source entity "${rel.sourceEntityId}" does not exist in this repository`
+          });
+        }
+        if (!tgt) {
+          errors.push({
+            field: "targetEntityId",
+            message: `Target entity "${rel.targetEntityId}" does not exist in this repository`
+          });
+        }
+        if (rel.sourceEntityId === rel.targetEntityId) {
+          errors.push({
+            field: "targetEntityId",
+            message: `Self-referential relationship: source and target are the same entity "${rel.sourceEntityId}"`,
+            suggestion: "Remove the relationship, or repoint it to a different entity."
+          });
+        }
+        if (src && tgt) {
+          const result = validateRelationship(
+            {
+              relationshipType: rel.relationshipType,
+              sourceEntityId: rel.sourceEntityId,
+              targetEntityId: rel.targetEntityId,
+              properties: rel.properties
+            },
+            vocabulary,
+            src.entityType,
+            tgt.entityType
+          );
+          errors.push(...result.errors);
+        }
+        if (errors.length > 0) {
+          if (skipped < offset) {
+            skipped++;
+            continue;
+          }
+          issues.push({
+            relationshipId: rel.id,
+            relationshipType: rel.relationshipType,
+            sourceEntityId: rel.sourceEntityId,
+            targetEntityId: rel.targetEntityId,
+            sourceLabel: src?.label,
+            targetLabel: tgt?.label,
+            sourceEntityType: src?.entityType,
+            targetEntityType: tgt?.entityType,
+            errors
+          });
+          if (issues.length >= take) {
+            stoppedEarly = true;
+            break;
+          }
+        }
+      }
+      if (stoppedEarly) break;
+      if (delayMs > 0 && !chunk.isLast) {
+        await new Promise((resolve) => {
+          setTimeout(resolve, delayMs);
+        });
+      }
+    }
+    return {
+      issues,
+      scanned,
+      nextOffset: offset + issues.length,
+      done: !stoppedEarly,
+      entitiesInMap: entityMap.size
+    };
+  }
+};
+
 // src/core/MemoryRepository.ts
 var MemoryRepository = class {
   repositoryId;
@@ -1706,6 +2149,8 @@ var MemoryRepository = class {
   relationshipManager;
   graphTraversal;
   searchOrchestrator;
+  embeddingFactory;
+  embedding;
   constructor(config) {
     this.repositoryId = config.repositoryId;
     this.storage = config.storage;
@@ -1713,6 +2158,8 @@ var MemoryRepository = class {
     this.vocabularyEngine = config.vocabularyEngine;
     this.provenanceTracker = config.provenanceTracker;
     this.eventBus = config.eventBus;
+    this.embedding = config.embedding;
+    this.embeddingFactory = config.embeddingFactory;
     this.entityManager = new EntityManager(
       config.repositoryId,
       config.vocabularyEngine,
@@ -1798,11 +2245,14 @@ var MemoryRepository = class {
   async findEntities(query) {
     return this.searchOrchestrator.findEntities(query);
   }
-  async deleteEntity(entityId) {
-    await this.entityManager.delete(entityId);
-    if (this.search) {
-      await this.search.removeEntity(this.repositoryId, entityId);
+  async deleteEntities(ids) {
+    const result = await this.entityManager.deleteMany(ids);
+    if (this.search && result.deleted.length > 0) {
+      for (const id of result.deleted) {
+        await this.search.removeEntity(this.repositoryId, id);
+      }
     }
+    return result;
   }
   // ─── Re-embedding ──────────────────────────────────────────────────
   /** Re-embed specific entities using the current EmbeddingProvider */
@@ -1810,11 +2260,45 @@ var MemoryRepository = class {
     return this.entityManager.reembedEntities(entityIds);
   }
   /**
-   * Re-embed all entities in the repository using the current EmbeddingProvider.
+   * Re-embed all entities in the repository. If `model` or `dimensions` is provided,
+   * the repository's embedding configuration is updated to the new values before
+   * re-embedding, so all subsequent entity writes use the new model/dimensionality.
+   *
    * Processes in batches with optional rate limiting. Emits reembed:* events for progress tracking.
    * Updates repository metadata with the new model ID and dimensions on completion.
    */
   async reembedAll(options) {
+    if (options?.model !== void 0 || options?.dimensions !== void 0) {
+      if (!this.embeddingFactory) {
+        throw new Error(
+          "Cannot change embedding model or dimensions: DeepMemory was constructed without an embeddingFactory. Provide embeddingFactory in DeepMemoryConfig to enable per-repository embedding reconfiguration."
+        );
+      }
+      const currentModel = this.embedding?.modelId();
+      let currentDimensions;
+      try {
+        currentDimensions = this.embedding?.dimensions();
+      } catch {
+        currentDimensions = void 0;
+      }
+      const nextModel = options.model ?? currentModel;
+      const nextDimensions = options.dimensions ?? currentDimensions;
+      if (!nextModel || nextDimensions === void 0) {
+        throw new Error(
+          `Cannot rebuild embedding provider: model and dimensions must both be known. Got model="${nextModel ?? "undefined"}", dimensions=${nextDimensions ?? "undefined"}.`
+        );
+      }
+      const newProvider = this.embeddingFactory({ model: nextModel, dimensions: nextDimensions });
+      this.embedding = newProvider;
+      this.entityManager.setEmbeddingProvider(newProvider);
+      this.searchOrchestrator.setEmbeddingProvider(newProvider);
+      await this.storage.updateRepository(this.repositoryId, {
+        metadata: {
+          embeddingModelId: nextModel,
+          embeddingDimensions: nextDimensions
+        }
+      });
+    }
     const stats = await this.getStats();
     await this.eventBus.emit("reembed:started", {
       repositoryId: this.repositoryId,
@@ -1860,8 +2344,8 @@ var MemoryRepository = class {
   async createRelationships(inputs) {
     return this.relationshipManager.create(inputs);
   }
-  async removeRelationship(relationshipId) {
-    return this.relationshipManager.remove(relationshipId);
+  async removeRelationships(ids) {
+    return this.relationshipManager.removeMany(ids);
   }
   async getRelationships(entityId, options) {
     return this.relationshipManager.getForEntity(entityId, options);
@@ -2047,6 +2531,34 @@ var MemoryRepository = class {
   async getStats() {
     return this.storage.getRepositoryStats(this.repositoryId);
   }
+  // ─── Validation ────────────────────────────────────────────────────
+  /**
+   * Audit a window of entities against the current vocabulary. Returns a single
+   * page; callers loop until `done` is true. Paging is over scanned entities,
+   * not issues. Does not mutate anything.
+   */
+  async validateEntities(options) {
+    const validator = new RepositoryValidator(
+      this.repositoryId,
+      this.storage,
+      this.vocabularyEngine
+    );
+    return validator.validateEntities(options);
+  }
+  /**
+   * Audit a window of relationships against the current vocabulary. Returns a
+   * single page; callers loop until `done` is true. The full entity set is
+   * loaded once per call to resolve orphan and type-mismatch checks, then
+   * offset/take is applied to the relationship stream. Does not mutate anything.
+   */
+  async validateRelationships(options) {
+    const validator = new RepositoryValidator(
+      this.repositoryId,
+      this.storage,
+      this.vocabularyEngine
+    );
+    return validator.validateRelationships(options);
+  }
   // ─── Bulk Operations ──────────────────────────────────────────────
   /** Delete all entities and relationships in this repository, preserving the repository and vocabulary */
   async deleteAllContents() {
@@ -2620,195 +3132,6 @@ function generateChangeId() {
   return `change_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
 }
 
-// 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, context) {
-  const results = [];
-  const providedProperties = properties ?? {};
-  for (const schema of schemas) {
-    const value = providedProperties[schema.name];
-    results.push(validatePropertyValue(schema.name, value, schema));
-  }
-  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}" on ${context}`,
-          suggestion: `Known properties: ${schemas.map((s) => s.name).join(", ") || "none"}`
-        })
-      );
-    }
-  }
-  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, input.entityType);
-}
-function validateEntityUpdate(input, entityTypeDef) {
-  if (input.label !== void 0 && input.label.trim().length === 0) {
-    return fail({
-      field: "label",
-      message: "Entity label cannot be empty"
-    });
-  }
-  if (input.properties) {
-    const results = [];
-    for (const [key, value] of Object.entries(input.properties)) {
-      const schema = entityTypeDef.properties.find((p) => p.name === key);
-      if (!schema) {
-        results.push(
-          fail({
-            field: `properties.${key}`,
-            message: `Unknown property "${key}" on ${entityTypeDef.type}`,
-            suggestion: `Known properties: ${entityTypeDef.properties.map((p) => p.name).join(", ") || "none"}`
-          })
-        );
-      } 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, input.relationshipType)
-    );
-  }
-  return merge(...results);
-}
-function getEntityTypeDef(entityType, vocabulary) {
-  return vocabulary.entityTypes.find((et) => et.type === entityType) ?? null;
-}
-
 // src/core/VocabularyEngine.ts
 var VocabularyEngine = class {
   repositoryId;
@@ -2870,7 +3193,7 @@ var VocabularyEngine = class {
         ]
       };
     }
-    return validateEntityUpdate(input, typeDef);
+    return validateEntityUpdate(input, typeDef, vocabulary);
   }
   /** Validate a relationship creation input against the vocabulary */
   async validateRelationship(input, sourceEntityType, targetEntityType) {
@@ -3094,7 +3417,7 @@ var EventBus = class {
 };
 
 // src/portability/RepositoryExporter.ts
-var LIBRARY_VERSION = true ? "0.6.1" : "0.1.0";
+var LIBRARY_VERSION = true ? "0.7.0" : "0.1.0";
 var RepositoryExporter = class {
   storage;
   provenance;
@@ -3744,7 +4067,9 @@ function isValidUuid(value) {
 var DeepMemory = class {
   storage;
   search;
-  embedding;
+  embeddingFactory;
+  defaultEmbeddingModel;
+  defaultEmbeddingDimensions;
   /** Reserved for future distributed locking support */
   lock;
   graphTraversalProvider;
@@ -3754,12 +4079,22 @@ var DeepMemory = class {
   constructor(config) {
     this.storage = config.storage;
     this.search = config.search;
-    this.embedding = config.embedding;
+    this.embeddingFactory = config.embeddingFactory;
+    this.defaultEmbeddingModel = config.defaultEmbeddingModel;
+    this.defaultEmbeddingDimensions = config.defaultEmbeddingDimensions;
     this.lock = config.lock;
     this.graphTraversalProvider = config.graphTraversal;
     this.provenance = new ProvenanceTracker(config.provenance);
     this.globalEventBus = new EventBus(config.provenance);
   }
+  /**
+   * Build an embedding provider for a repository given its stored model + dimensions.
+   * Returns undefined when no factory is configured or when model/dimensions are missing.
+   */
+  buildEmbeddingForRepository(model, dimensions) {
+    if (!this.embeddingFactory || !model || dimensions === void 0) return void 0;
+    return this.embeddingFactory({ model, dimensions });
+  }
   /** Initialize the storage provider and optional providers (call once before use) */
   async ensureInitialized() {
     if (!this.initialized) {
@@ -3811,16 +4146,11 @@ var DeepMemory = class {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const governanceConfig = config.governance ?? { mode: "open" };
     const metadata = { ...config.metadata };
-    if (this.embedding) {
-      if (!metadata.embeddingModelId) {
-        metadata.embeddingModelId = this.embedding.modelId();
-      }
-      if (metadata.embeddingDimensions === void 0) {
-        try {
-          metadata.embeddingDimensions = this.embedding.dimensions();
-        } catch {
-        }
-      }
+    if (!metadata.embeddingModelId && this.defaultEmbeddingModel) {
+      metadata.embeddingModelId = this.defaultEmbeddingModel;
+    }
+    if (metadata.embeddingDimensions === void 0 && this.defaultEmbeddingDimensions !== void 0) {
+      metadata.embeddingDimensions = this.defaultEmbeddingDimensions;
     }
     await this.storage.createRepository({
       repositoryId,
@@ -3836,18 +4166,23 @@ var DeepMemory = class {
     });
     const vocabulary = config.vocabulary ? buildVocabulary(config.vocabulary, context.actorId) : createEmptyVocabulary(context.actorId);
     await this.storage.saveVocabulary(repositoryId, vocabulary);
+    const embedding = this.buildEmbeddingForRepository(
+      metadata.embeddingModelId,
+      metadata.embeddingDimensions
+    );
     const eventBus = new EventBus(context, repositoryId);
     const vocabularyEngine = new VocabularyEngine({
       repositoryId,
       storageProvider: this.storage,
       governanceConfig,
-      embeddingProvider: this.embedding
+      embeddingProvider: embedding
     });
     const repo = new MemoryRepository({
       repositoryId,
       storage: this.storage,
       search: this.search,
-      embedding: this.embedding,
+      embedding,
+      embeddingFactory: this.embeddingFactory,
       graphTraversal: this.graphTraversalProvider,
       vocabularyEngine,
       provenanceTracker: this.provenance,
@@ -3869,17 +4204,22 @@ var DeepMemory = class {
     }
     const context = this.provenance.getContext();
     const eventBus = new EventBus(context, repositoryId);
+    const embedding = this.buildEmbeddingForRepository(
+      storedRepo.metadata?.embeddingModelId ?? this.defaultEmbeddingModel,
+      storedRepo.metadata?.embeddingDimensions ?? this.defaultEmbeddingDimensions
+    );
     const vocabularyEngine = new VocabularyEngine({
       repositoryId,
       storageProvider: this.storage,
       governanceConfig: storedRepo.governanceConfig,
-      embeddingProvider: this.embedding
+      embeddingProvider: embedding
     });
     const repo = new MemoryRepository({
       repositoryId,
       storage: this.storage,
       search: this.search,
-      embedding: this.embedding,
+      embedding,
+      embeddingFactory: this.embeddingFactory,
       graphTraversal: this.graphTraversalProvider,
       vocabularyEngine,
       provenanceTracker: this.provenance,
@@ -4601,11 +4941,12 @@ var InMemoryStorageProvider = class {
     }
     const updated = {
       ...existing,
+      entityType: updates.entityType ?? existing.entityType,
       label: updates.label ?? existing.label,
-      summary: updates.summary !== void 0 ? updates.summary : existing.summary,
+      summary: updates.summary === void 0 ? existing.summary : updates.summary ?? void 0,
       properties: updates.properties ?? existing.properties,
-      data: updates.data !== void 0 ? updates.data : existing.data,
-      dataFormat: updates.dataFormat !== void 0 ? updates.dataFormat : existing.dataFormat,
+      data: updates.data === void 0 ? existing.data : updates.data ?? void 0,
+      dataFormat: updates.dataFormat === void 0 ? existing.dataFormat : updates.dataFormat ?? void 0,
       provenance: updates.provenance,
       embedding: updates.embedding ?? existing.embedding
     };
@@ -4732,6 +5073,29 @@ var InMemoryStorageProvider = class {
       offset
     };
   }
+  async deleteEntities(repositoryId, ids) {
+    const store = this.getStore(repositoryId);
+    const deleted = [];
+    const notFound = [];
+    const deletedSet = /* @__PURE__ */ new Set();
+    for (const id of ids) {
+      const existing = store.entities.get(id);
+      if (!existing) {
+        notFound.push(id);
+        continue;
+      }
+      store.slugIndex.delete(existing.slug);
+      store.entities.delete(id);
+      deleted.push(id);
+      deletedSet.add(id);
+    }
+    for (const [relId, rel] of store.relationships) {
+      if (deletedSet.has(rel.sourceEntityId) || deletedSet.has(rel.targetEntityId)) {
+        store.relationships.delete(relId);
+      }
+    }
+    return { deleted, notFound };
+  }
   async deleteRelationship(repositoryId, relationshipId) {
     const store = this.getStore(repositoryId);
     if (!store.relationships.has(relationshipId)) {
@@ -4739,6 +5103,20 @@ var InMemoryStorageProvider = class {
     }
     store.relationships.delete(relationshipId);
   }
+  async deleteRelationships(repositoryId, ids) {
+    const store = this.getStore(repositoryId);
+    const deleted = [];
+    const notFound = [];
+    for (const id of ids) {
+      if (store.relationships.has(id)) {
+        store.relationships.delete(id);
+        deleted.push(id);
+      } else {
+        notFound.push(id);
+      }
+    }
+    return { deleted, notFound };
+  }
   async deleteRelationshipsByType(repositoryId, relationshipType) {
     const store = this.getStore(repositoryId);
     let deletedRelationships = 0;
@@ -5150,6 +5528,8 @@ var NoOpEmbeddingProvider = class {
   RelationshipConstraintError,
   RelationshipNotFoundError,
   RepositoryNotFoundError,
+  RepositoryValidator,
+  SelfReferentialRelationshipError,
   TraversalTimeoutError,
   TraversalValidationError,
   TraversalVocabularyError,