@utaba/deep-memory 0.2.0 → 0.3.0

package/dist/index.js

@@ -795,6 +795,7 @@ var DEFAULT_MAX_LIMIT = 200;
 var DEFAULT_FALLBACK_MAX_DEPTH = 10;
 function validateTraversalSpec(spec, vocabulary, capabilities) {
   const errors = [];
+  const steps = spec.steps ?? [];
   if (!spec.start) {
     errors.push("start is required");
   } else {
@@ -808,37 +809,45 @@ function validateTraversalSpec(spec, vocabulary, capabilities) {
       errors.push("start.entityType without entityId requires limit on the spec to prevent full type scans");
     }
   }
-  if (!spec.steps || spec.steps.length === 0) {
-    errors.push("steps must contain at least one step");
-  }
   const maxSteps = capabilities?.maxTraversalDepth ?? DEFAULT_MAX_STEPS;
-  if (spec.steps && spec.steps.length > maxSteps) {
-    errors.push(`steps length ${spec.steps.length} exceeds maximum ${maxSteps}`);
-  }
-  if (spec.steps) {
-    for (let i = 0; i < spec.steps.length; i++) {
-      const step = spec.steps[i];
-      if (!step.direction || !["out", "in", "both"].includes(step.direction)) {
-        errors.push(`steps[${i}].direction must be 'out', 'in', or 'both'`);
-      }
-      if (step.repeat) {
-        if (step.repeat.maxDepth === void 0 || step.repeat.maxDepth <= 0) {
-          errors.push(`steps[${i}].repeat.maxDepth must be a positive number`);
-        }
+  if (steps.length > maxSteps) {
+    errors.push(`steps length ${steps.length} exceeds maximum ${maxSteps}`);
+  }
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    if (!step.direction || !["out", "in", "both"].includes(step.direction)) {
+      errors.push(`steps[${i}].direction must be 'out', 'in', or 'both'`);
+    }
+    if (step.repeat) {
+      if (step.repeat.maxDepth === void 0 || step.repeat.maxDepth <= 0) {
+        errors.push(`steps[${i}].repeat.maxDepth must be a positive number`);
       }
     }
+  }
+  if (steps.length > 0) {
     const maxProviderDepth = capabilities?.maxTraversalDepth ?? DEFAULT_FALLBACK_MAX_DEPTH;
     let totalDepth = 0;
-    for (const step of spec.steps) {
+    for (const step of steps) {
       totalDepth += step.repeat ? step.repeat.maxDepth : 1;
     }
     if (totalDepth > maxProviderDepth) {
       errors.push(`total potential depth ${totalDepth} exceeds provider maximum ${maxProviderDepth}`);
     }
   }
+  if (spec.returnMode === "path" && steps.length === 0) {
+    errors.push("returnMode 'path' requires at least one step");
+  }
   if (spec.returnMode && !["terminal", "path", "all"].includes(spec.returnMode)) {
     errors.push(`returnMode must be 'terminal', 'path', or 'all'`);
   }
+  if (spec.projection) {
+    if (!spec.projection.properties || spec.projection.properties.length === 0) {
+      errors.push("projection.properties must contain at least one property name");
+    }
+    if (spec.projection.mode && !["count", "values"].includes(spec.projection.mode)) {
+      errors.push("projection.mode must be 'count' or 'values'");
+    }
+  }
   if (spec.limit !== void 0) {
     if (spec.limit < 1 || spec.limit > DEFAULT_MAX_LIMIT) {
       errors.push(`limit must be between 1 and ${DEFAULT_MAX_LIMIT}`);
@@ -847,15 +856,15 @@ function validateTraversalSpec(spec, vocabulary, capabilities) {
   if (spec.offset !== void 0 && spec.offset < 0) {
     errors.push("offset must be >= 0");
   }
-  if (vocabulary && spec.steps) {
+  if (vocabulary) {
     const entityTypeSet = new Set(vocabulary.entityTypes.map((et) => et.type));
     const relationshipTypeSet = new Set(vocabulary.relationshipTypes.map((rt) => rt.type));
     const unknownTypes = [];
     if (spec.start?.entityType && !entityTypeSet.has(spec.start.entityType)) {
       unknownTypes.push(`entity type "${spec.start.entityType}"`);
     }
-    for (let i = 0; i < spec.steps.length; i++) {
-      const step = spec.steps[i];
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i];
       if (step.relationshipTypes) {
         for (const rt of step.relationshipTypes) {
           if (!relationshipTypeSet.has(rt)) {
@@ -909,7 +918,8 @@ var GremlinCompiler = class {
         parts.push(compilePropertyFilter(f, nextParam));
       }
     }
-    for (const step of spec.steps) {
+    const steps = spec.steps ?? [];
+    for (const step of steps) {
       if (step.repeat) {
         parts.push(compileRepeatStep(step, nextParam));
         estimatedFanOut *= step.repeat.maxDepth * DEFAULT_ESTIMATED_FANOUT_PER_HOP;
@@ -1091,8 +1101,9 @@ var CypherCompiler = class {
       }
     }
     let lastNode = startNode;
-    for (let i = 0; i < spec.steps.length; i++) {
-      const step = spec.steps[i];
+    const steps = spec.steps ?? [];
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i];
       const targetNode = `n${nodeIndex++}`;
       const relAlias = `r${i}`;
       const relTypes = step.relationshipTypes?.length ? step.relationshipTypes.join("|") : "";
@@ -1134,7 +1145,7 @@ WHERE ${whereClauses.join(" AND ")}` : "";
     let returnClause;
     if (spec.returnMode === "path") {
       const allNodes = Array.from({ length: nodeIndex }, (_, i) => `n${i}`);
-      const allRels = spec.steps.map((_, i) => `r${i}`);
+      const allRels = steps.map((_, i) => `r${i}`);
       returnClause = `RETURN ${[...allNodes, ...allRels].join(", ")}`;
     } else if (spec.returnMode === "all") {
       const allNodes = Array.from({ length: nodeIndex }, (_, i) => `n${i}`);
@@ -1215,6 +1226,7 @@ function matchesSingleFilter(properties, filter) {
 
 // src/relationships/FallbackTraversalExecutor.ts
 var MAX_STORAGE_CALLS = 500;
+var MAX_ENTITY_SCAN = 1e4;
 var REL_FETCH_LIMIT = 1e3;
 async function executeFallbackTraversal(repositoryId, storage, spec) {
   const startTime = Date.now();
@@ -1224,6 +1236,9 @@ async function executeFallbackTraversal(repositoryId, storage, spec) {
       throw new Error(`Fallback traversal exceeded ${MAX_STORAGE_CALLS} storage calls. Consider using a GraphTraversalProvider for large traversals.`);
     }
   };
+  const isVertexQuery = !spec.steps || spec.steps.length === 0;
+  const needsFullScan = isVertexQuery || spec.projection !== void 0;
+  const fetchLimit = needsFullScan ? MAX_ENTITY_SCAN : spec.limit ?? 50;
   let frontier = [];
   if (spec.start.entityId) {
     const entity = await resolveEntity(repositoryId, storage, spec.start.entityId);
@@ -1236,7 +1251,7 @@ async function executeFallbackTraversal(repositoryId, storage, spec) {
   } else if (spec.start.entityType) {
     const result = await storage.findEntities(repositoryId, {
       entityTypes: [spec.start.entityType],
-      limit: spec.limit ?? 50,
+      limit: fetchLimit,
       offset: 0
     });
     storageCalls++;
@@ -1247,7 +1262,7 @@ async function executeFallbackTraversal(repositoryId, storage, spec) {
     }));
   } else if (spec.start.filter && spec.start.filter.length > 0) {
     const result = await storage.findEntities(repositoryId, {
-      limit: spec.limit ?? 50,
+      limit: fetchLimit,
       offset: 0
     });
     storageCalls++;
@@ -1262,8 +1277,9 @@ async function executeFallbackTraversal(repositoryId, storage, spec) {
       (entry) => matchesPropertyFilters(entry.entity.properties, spec.start.filter)
     );
   }
+  const steps = spec.steps ?? [];
   const allCollected = spec.returnMode === "all" ? [...frontier] : [];
-  for (const step of spec.steps) {
+  for (const step of steps) {
     checkCallLimit();
     if (step.repeat) {
       const result = await executeRepeatStep(
@@ -1316,10 +1332,89 @@ async function executeFallbackTraversal(repositoryId, storage, spec) {
   }
   const total = resultEntries.length;
   const paged = resultEntries.slice(offset, offset + limit);
-  const entities = paged.map((entry) => projectEntity(entry.entity, detailLevel));
+  const suppressEntities = spec.projection !== void 0 && spec.projection.includeEntities !== true;
+  let entities;
+  if (suppressEntities) {
+    entities = [];
+  } else {
+    entities = paged.map((entry) => {
+      const projected = projectEntity(entry.entity, detailLevel);
+      if (!spec.includeProvenance) {
+        delete projected["provenance"];
+      }
+      return projected;
+    });
+    if (spec.includeRelationshipSummary && entities.length > 0) {
+      const summaryResults = await Promise.all(
+        paged.map(async (entry) => {
+          storageCalls++;
+          const result = await storage.getEntityRelationships(repositoryId, entry.entity.id, {
+            direction: "both",
+            limit: 1e4
+          });
+          const summary = { outbound: {}, inbound: {} };
+          for (const rel of result.items) {
+            if (rel.sourceEntityId === entry.entity.id) {
+              summary.outbound[rel.relationshipType] = (summary.outbound[rel.relationshipType] ?? 0) + 1;
+            }
+            if (rel.targetEntityId === entry.entity.id) {
+              summary.inbound[rel.relationshipType] = (summary.inbound[rel.relationshipType] ?? 0) + 1;
+            }
+          }
+          return summary;
+        })
+      );
+      entities = entities.map((e, i) => ({ ...e, relationshipSummary: summaryResults[i] }));
+    }
+  }
+  let aggregations;
+  if (spec.projection) {
+    const propNames = spec.projection.properties;
+    const mode = spec.projection.mode ?? "values";
+    const distinct = spec.projection.distinct ?? false;
+    const sourceEntries = dedup ? (() => {
+      const seen = /* @__PURE__ */ new Set();
+      return (spec.returnMode === "all" ? allCollected : frontier).filter((e) => {
+        if (seen.has(e.entity.id)) return false;
+        seen.add(e.entity.id);
+        return true;
+      });
+    })() : spec.returnMode === "all" ? allCollected : frontier;
+    if (mode === "count" || distinct) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const entry of sourceEntries) {
+        const vals = {};
+        for (const prop of propNames) {
+          vals[prop] = entry.entity.properties[prop] ?? null;
+        }
+        const key = JSON.stringify(vals);
+        const existing = groups.get(key);
+        if (existing) {
+          existing.count++;
+        } else {
+          groups.set(key, { values: vals, count: 1 });
+        }
+      }
+      aggregations = Array.from(groups.values()).map((g) => ({
+        values: g.values,
+        ...mode === "count" ? { count: g.count } : {}
+      }));
+      if (mode === "count") {
+        aggregations.sort((a, b) => (b.count ?? 0) - (a.count ?? 0));
+      }
+    } else {
+      aggregations = sourceEntries.map((entry) => {
+        const vals = {};
+        for (const prop of propNames) {
+          vals[prop] = entry.entity.properties[prop] ?? null;
+        }
+        return { values: vals };
+      });
+    }
+  }
   let relationships;
   let paths;
-  if (spec.returnMode === "path" || spec.returnMode === "all") {
+  if (!suppressEntities && (spec.returnMode === "path" || spec.returnMode === "all")) {
     const relMap = /* @__PURE__ */ new Map();
     for (const entry of paged) {
       for (const rel of entry.relationshipPath) {
@@ -1337,10 +1432,14 @@ async function executeFallbackTraversal(repositoryId, storage, spec) {
     }
     relationships = Array.from(relMap.values());
   }
-  if (spec.returnMode === "path") {
+  if (!suppressEntities && spec.returnMode === "path") {
     paths = paged.map((entry) => ({
       length: entry.entityPath.length - 1,
-      entities: [projectEntity(entry.entity, detailLevel)],
+      entities: [(() => {
+        const e = projectEntity(entry.entity, detailLevel);
+        if (!spec.includeProvenance) delete e["provenance"];
+        return e;
+      })()],
       relationships: entry.relationshipPath.map((rel) => ({
         id: rel.id,
         type: rel.relationshipType,
@@ -1356,6 +1455,7 @@ async function executeFallbackTraversal(repositoryId, storage, spec) {
     entities,
     relationships,
     paths,
+    aggregations,
     total,
     returned: paged.length,
     hasMore: offset + limit < total,
@@ -2190,6 +2290,58 @@ var MemoryRepository = class {
   async getStats() {
     return this.storage.getRepositoryStats(this.repositoryId);
   }
+  // ─── Bulk Operations ──────────────────────────────────────────────
+  /** Delete all entities and relationships in this repository, preserving the repository and vocabulary */
+  async deleteAllContents() {
+    return this.storage.deleteAllContents(this.repositoryId);
+  }
+  /**
+   * Returns a static markdown guide describing the recommended query strategy
+   * for AI agents and other consumers of the repository.
+   */
+  getQueryGuide() {
+    return `## Query Strategy Guide
+
+### Step 1 \u2014 Discover before you traverse
+
+Before following relationships from an entity, check that it actually has relationships.
+\`memory_query_graph\` includes \`relationshipSummary\` on every returned entity by default
+(outbound and inbound counts by type). Inspect this before traversing \u2014 entities with
+zero outbound counts for the relationship type you need have no connections to follow.
+To skip summaries and reduce response size, set \`includeRelationshipSummary: false\`.
+
+### Step 2 \u2014 Use projection for aggregation
+
+To understand what data exists (e.g. all distinct values of a property, or counts by
+category), use \`memory_query_graph\` with \`projection\` instead of fetching full entities:
+\`{ start: { entityType: "..." }, projection: { properties: ["propName"], distinct: true }, limit: 200 }\`
+
+This returns only the aggregated values \u2014 no entity objects \u2014 keeping responses lightweight.
+
+### Step 3 \u2014 Traverse efficiently
+
+- **Omit relationshipTypes** in a traversal step to follow all relationship types at once,
+  rather than making separate calls per type.
+- **Use multi-step traversals** for multi-hop patterns. A two-step query
+  (e.g. Equipment \u2192 Component \u2192 MaintenanceProcedure) is one call, not two sequential calls.
+- **Use returnMode "all"** when you need intermediate entities along the path, not just
+  the terminal nodes.
+
+### Step 4 \u2014 Use semantic search for known-unknowns
+
+\`memory_search_by_concept\` is best for finding specific entities when you know roughly
+what you're looking for but not the exact label or type. It is not efficient for broad
+discovery \u2014 use projection or find_entities for that.
+
+### Common anti-patterns to avoid
+
+- **Don't traverse from entities with zero relationship counts.** The \`relationshipSummary\` on each entity tells you what is connected before you traverse.
+- **Don't split queries by relationship type.** One step with no type filter is better
+  than three separate single-type calls.
+- **Don't use sequential single-hop traversals** when a multi-step query achieves the
+  same result in one call.
+- **Don't fetch full entities when you only need property values.** Use projection.`;
+  }
   // ─── Events ────────────────────────────────────────────────────────
   on(event, handler) {
     return this.eventBus.on(event, handler);
@@ -3185,7 +3337,7 @@ var EventBus = class {
 };
 
 // src/portability/RepositoryExporter.ts
-var LIBRARY_VERSION = true ? "0.2.0" : "0.1.0";
+var LIBRARY_VERSION = true ? "0.3.0" : "0.1.0";
 var RepositoryExporter = class {
   storage;
   provenance;
@@ -3528,13 +3680,22 @@ function describeChange(change) {
 }
 
 // src/portability/RepositoryImporter.ts
+function estimateChunkCount(totalEntities, totalRelationships) {
+  const ESTIMATED_CHUNK_SIZE = 100;
+  return Math.max(
+    1,
+    Math.ceil(totalEntities / ESTIMATED_CHUNK_SIZE) + Math.ceil(totalRelationships / ESTIMATED_CHUNK_SIZE)
+  );
+}
 var RepositoryImporter = class {
   storage;
   actorId;
+  onProgress;
   migrationEngine = new MigrationEngine();
   constructor(config) {
     this.storage = config.storage;
     this.actorId = config.actorId;
+    this.onProgress = config.onProgress;
   }
   /**
    * Import an export archive according to the provided options.
@@ -3585,26 +3746,34 @@ var RepositoryImporter = class {
       return this.importStreamMerge(header, chunks, options, warnings);
     }
   }
-  /** Streaming create mode — set up repo then pipe chunks through importBulk */
+  /** Streaming create mode — fast bulk inserts with no existence checks */
   async importStreamCreate(header, chunks, options, warnings) {
     const target = options.target;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await this.storage.createRepository({
-      repositoryId: target.repositoryId,
-      type: target.config.type,
-      label: target.config.label,
-      description: target.config.description,
-      governanceConfig: target.config.governance ?? { mode: "open" },
-      createdAt: now,
-      createdBy: this.actorId
-    });
+    const existing = await this.storage.getRepository(target.repositoryId);
+    if (!existing) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await this.storage.createRepository({
+        repositoryId: target.repositoryId,
+        type: target.config.type,
+        label: target.config.label,
+        description: target.config.description,
+        governanceConfig: target.config.governance ?? { mode: "open" },
+        createdAt: now,
+        createdBy: this.actorId
+      });
+    }
     await this.storage.saveVocabulary(target.repositoryId, header.vocabulary);
+    const totalEntities = header.manifest?.statistics?.entityCount ?? 0;
+    const totalRelationships = header.manifest?.statistics?.relationshipCount ?? 0;
+    const totalChunks = estimateChunkCount(totalEntities, totalRelationships);
     let entitiesImported = 0;
     let relationshipsImported = 0;
+    let chunksCompleted = 0;
     for await (const chunk of chunks) {
-      const bulkResult = await this.storage.importBulk(target.repositoryId, [chunk]);
+      const bulkResult = await this.storage.importBulk(target.repositoryId, [chunk], { skipExistenceCheck: true });
       entitiesImported += bulkResult.entitiesImported;
       relationshipsImported += bulkResult.relationshipsImported;
+      chunksCompleted++;
       for (const e of bulkResult.errors) {
         warnings.push({
           code: "import_error",
@@ -3612,6 +3781,15 @@ var RepositoryImporter = class {
           id: e.item
         });
       }
+      await this.onProgress?.({
+        repositoryId: target.repositoryId,
+        entitiesImported,
+        relationshipsImported,
+        totalEntities,
+        totalRelationships,
+        chunksCompleted,
+        totalChunks
+      });
     }
     return {
       success: true,
@@ -3659,11 +3837,15 @@ var RepositoryImporter = class {
     if (migrationResult.mergedVocabulary && migrationResult.mergedVocabulary !== targetVocabulary) {
       await this.storage.saveVocabulary(repositoryId, migrationResult.mergedVocabulary);
     }
+    const totalEntities = header.manifest?.statistics?.entityCount ?? 0;
+    const totalRelationships = header.manifest?.statistics?.relationshipCount ?? 0;
+    const totalChunks = estimateChunkCount(totalEntities, totalRelationships);
     const entityConflict = options.entityConflict ?? "skip";
     let entitiesImported = 0;
     let entitiesSkipped = 0;
     let relationshipsImported = 0;
     let relationshipsSkipped = 0;
+    let chunksCompleted = 0;
     for await (const chunk of chunks) {
       if (chunk.entities) {
         for (const entity of chunk.entities) {
@@ -3745,6 +3927,16 @@ var RepositoryImporter = class {
           }
         }
       }
+      chunksCompleted++;
+      await this.onProgress?.({
+        repositoryId,
+        entitiesImported,
+        relationshipsImported,
+        totalEntities,
+        totalRelationships,
+        chunksCompleted,
+        totalChunks
+      });
     }
     const vocabExtensions = migrationResult.warnings.filter(
       (w) => w.code === "entity_type_added" || w.code === "relationship_type_added"
@@ -3969,12 +4161,53 @@ var DeepMemory = class {
   async deleteRepository(repositoryId) {
     await this.ensureInitialised();
     this.validateRepositoryId(repositoryId);
-    await this.storage.deleteRepository(repositoryId);
+    const stats = await this.storage.getRepositoryStats(repositoryId);
+    await this.globalEventBus.emit("delete:started", {
+      repositoryId,
+      totalEntities: stats.entityCount,
+      totalRelationships: stats.relationshipCount
+    });
+    await this.storage.deleteRepository(
+      repositoryId,
+      (progress) => this.globalEventBus.emit("delete:progress", { repositoryId, ...progress })
+    );
+    await this.globalEventBus.emit("delete:completed", {
+      repositoryId,
+      entitiesDeleted: stats.entityCount,
+      relationshipsDeleted: stats.relationshipCount
+    });
     await this.globalEventBus.emit("repository:deleted", { repositoryId });
   }
+  /** Delete all entities and relationships in a repository, preserving the repository and vocabulary */
+  async deleteAllContents(repositoryId) {
+    await this.ensureInitialised();
+    this.validateRepositoryId(repositoryId);
+    const stats = await this.storage.getRepositoryStats(repositoryId);
+    await this.globalEventBus.emit("delete:started", {
+      repositoryId,
+      totalEntities: stats.entityCount,
+      totalRelationships: stats.relationshipCount
+    });
+    const result = await this.storage.deleteAllContents(
+      repositoryId,
+      (progress) => this.globalEventBus.emit("delete:progress", { repositoryId, ...progress })
+    );
+    await this.globalEventBus.emit("delete:completed", {
+      repositoryId,
+      entitiesDeleted: result.deletedEntities,
+      relationshipsDeleted: result.deletedRelationships
+    });
+    return result;
+  }
   /** Export a repository to a portable archive */
   async exportRepository(repositoryId, options) {
     await this.ensureInitialised();
+    const stats = await this.storage.getRepositoryStats(repositoryId);
+    await this.globalEventBus.emit("export:started", {
+      repositoryId,
+      totalEntities: stats.entityCount,
+      totalRelationships: stats.relationshipCount
+    });
     const exporter = new RepositoryExporter({
       storage: this.storage,
       provenance: this.provenance.getContext(),
@@ -3991,9 +4224,11 @@ var DeepMemory = class {
   /** Import a repository from a portable archive */
   async importRepository(archive, options) {
     await this.ensureInitialised();
+    await this.globalEventBus.emit("import:started", { repositoryId: options.target.repositoryId });
     const importer = new RepositoryImporter({
       storage: this.storage,
-      actorId: this.provenance.getContext().actorId
+      actorId: this.provenance.getContext().actorId,
+      onProgress: (progress) => this.globalEventBus.emit("import:progress", progress)
     });
     const result = await importer.import(archive, options);
     if (result.success) {
@@ -4022,15 +4257,44 @@ var DeepMemory = class {
       provenance: this.provenance.getContext(),
       legal: options?.legal
     });
-    await this.globalEventBus.emit("export:started", { repositoryId });
+    const stats = await this.storage.getRepositoryStats(repositoryId);
+    const totalEntities = stats.entityCount;
+    const totalRelationships = stats.relationshipCount;
+    const estimatedChunkSize = 100;
+    const totalChunks = Math.max(
+      1,
+      Math.ceil(totalEntities / estimatedChunkSize) + Math.ceil(totalRelationships / estimatedChunkSize)
+    );
+    await this.globalEventBus.emit("export:started", { repositoryId, totalEntities, totalRelationships });
     let entityCount = 0;
     let relationshipCount = 0;
+    let chunksCompleted = 0;
     for await (const item of exporter.exportStream(repositoryId)) {
       yield item;
       if (item.type === "entities") {
         entityCount += item.data.length;
+        chunksCompleted++;
+        await this.globalEventBus.emit("export:progress", {
+          repositoryId,
+          entitiesExported: entityCount,
+          relationshipsExported: relationshipCount,
+          totalEntities,
+          totalRelationships,
+          chunksCompleted,
+          totalChunks
+        });
       } else if (item.type === "relationships") {
         relationshipCount += item.data.length;
+        chunksCompleted++;
+        await this.globalEventBus.emit("export:progress", {
+          repositoryId,
+          entitiesExported: entityCount,
+          relationshipsExported: relationshipCount,
+          totalEntities,
+          totalRelationships,
+          chunksCompleted,
+          totalChunks
+        });
       }
     }
     await this.globalEventBus.emit("export:completed", {
@@ -4047,7 +4311,8 @@ var DeepMemory = class {
     await this.ensureInitialised();
     const importer = new RepositoryImporter({
       storage: this.storage,
-      actorId: this.provenance.getContext().actorId
+      actorId: this.provenance.getContext().actorId,
+      onProgress: (progress) => this.globalEventBus.emit("import:progress", progress)
     });
     await this.globalEventBus.emit("import:started", { repositoryId: options.target.repositoryId });
     const result = await importer.importStream(header, chunks, options);
@@ -4171,12 +4436,21 @@ var InMemoryStorageProvider = class {
     if (updates.metadata !== void 0) repo.metadata = { ...repo.metadata, ...updates.metadata };
     return repo;
   }
-  async deleteRepository(repositoryId) {
+  async deleteRepository(repositoryId, _onProgress) {
     if (!this.stores.has(repositoryId)) {
       throw new RepositoryNotFoundError(repositoryId);
     }
     this.stores.delete(repositoryId);
   }
+  async deleteAllContents(repositoryId, _onProgress) {
+    const store = this.getStore(repositoryId);
+    const deletedEntities = store.entities.size;
+    const deletedRelationships = store.relationships.size;
+    store.entities.clear();
+    store.slugIndex.clear();
+    store.relationships.clear();
+    return { deletedEntities, deletedRelationships };
+  }
   async getRepositoryStats(repositoryId) {
     const store = this.getStore(repositoryId);
     const entityTypeBreakdown = {};
@@ -4631,7 +4905,7 @@ var InMemoryStorageProvider = class {
       yield { type: "relationships", data: [], sequence: 0, isLast: true };
     }
   }
-  async importBulk(repositoryId, data) {
+  async importBulk(repositoryId, data, _options) {
     const store = this.getStore(repositoryId);
     let entitiesImported = 0;
     let relationshipsImported = 0;