@utaba/deep-memory 0.6.1 → 0.8.0

package/dist/index.js

@@ -125,6 +125,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) {
@@ -267,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) {
@@ -283,6 +561,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 = [];
@@ -312,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,
@@ -358,14 +640,42 @@ 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;
-    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;
+    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 || updates.properties !== void 0;
+    const nextSummary = updates.summary === void 0 ? existing.summary : updates.summary ?? 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,
+      slug: newSlug,
       summary: updates.summary,
       properties: updates.properties ? mergedProperties : void 0,
       data: updates.data,
@@ -436,18 +746,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.
@@ -460,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) {
@@ -562,10 +892,13 @@ 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(" ");
+    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);
   }
 };
@@ -602,57 +935,6 @@ function storedToBrief(stored) {
   };
 }
 
-// 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/relationships/RelationshipManager.ts
 var RelationshipManager = class {
   constructor(repositoryId, vocabularyEngine, provenanceTracker, eventBus, storage) {
@@ -671,6 +953,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);
@@ -721,21 +1006,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) {
@@ -1475,6 +1759,7 @@ var SearchOrchestrator = class {
   search;
   embedding;
   eventBus;
+  vocabularyEngine;
   defaultSimilarityThreshold;
   conceptSearchScanLimit;
   constructor(config) {
@@ -1483,9 +1768,14 @@ 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;
   }
+  /** 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
@@ -1553,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);
       }
@@ -1612,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) {
@@ -1638,6 +1944,177 @@ var SearchOrchestrator = class {
   }
 };
 
+// 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;
@@ -1650,6 +2127,8 @@ var MemoryRepository = class {
   relationshipManager;
   graphTraversal;
   searchOrchestrator;
+  embeddingFactory;
+  embedding;
   constructor(config) {
     this.repositoryId = config.repositoryId;
     this.storage = config.storage;
@@ -1657,6 +2136,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,
@@ -1684,6 +2165,7 @@ var MemoryRepository = class {
       search: config.search,
       embedding: config.embedding,
       eventBus: config.eventBus,
+      vocabularyEngine: config.vocabularyEngine,
       defaultSimilarityThreshold: config.vocabularyEngine.getGovernanceConfig().defaultSimilarityThreshold
     });
   }
@@ -1742,11 +2224,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 */
@@ -1754,11 +2239,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,
@@ -1804,8 +2323,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);
@@ -1991,6 +2510,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() {
@@ -2564,195 +3111,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;
@@ -2814,7 +3172,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) {
@@ -2851,6 +3209,10 @@ var VocabularyEngine = class {
         }
       }
     }
+    const propertySchemaErrors = this.validateProposalPropertySchemas(proposal);
+    if (propertySchemaErrors) {
+      return propertySchemaErrors;
+    }
     const { result, updatedVocabulary } = processProposal(
       vocabulary,
       proposal,
@@ -2888,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) => ({
@@ -3038,7 +3431,7 @@ var EventBus = class {
 };
 
 // src/portability/RepositoryExporter.ts
-var LIBRARY_VERSION = true ? "0.6.1" : "0.1.0";
+var LIBRARY_VERSION = true ? "0.8.0" : "0.1.0";
 var RepositoryExporter = class {
   storage;
   provenance;
@@ -3688,7 +4081,9 @@ function isValidUuid(value) {
 var DeepMemory = class {
   storage;
   search;
-  embedding;
+  embeddingFactory;
+  defaultEmbeddingModel;
+  defaultEmbeddingDimensions;
   /** Reserved for future distributed locking support */
   lock;
   graphTraversalProvider;
@@ -3698,12 +4093,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) {
@@ -3755,16 +4160,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,
@@ -3780,18 +4180,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,
@@ -3813,17 +4218,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,
@@ -4545,11 +4955,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
     };
@@ -4676,6 +5087,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)) {
@@ -4683,6 +5117,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;
@@ -5093,6 +5541,8 @@ export {
   RelationshipConstraintError,
   RelationshipNotFoundError,
   RepositoryNotFoundError,
+  RepositoryValidator,
+  SelfReferentialRelationshipError,
   TraversalTimeoutError,
   TraversalValidationError,
   TraversalVocabularyError,