@utaba/deep-memory 0.9.0 → 0.9.2

package/dist/index.js

@@ -2553,7 +2553,7 @@ var MemoryRepository = class {
 ### 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
+Graph queries include \`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\`.
@@ -2561,7 +2561,7 @@ To skip summaries and reduce response size, set \`includeRelationshipSummary: fa
 ### 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:
+category), use a graph query 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.
@@ -2570,23 +2570,23 @@ This returns only the aggregated values \u2014 no entity objects \u2014 keeping
 
 - **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
+- **Use multi-step traversals** for multi-hop patterns. A two-step traverse operation
   (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
+Semantic/concept search 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.
+discovery \u2014 use projection or entity finding 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
+- **Don't split queries by relationship type.** One traverse 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
+- **Don't use sequential single-hop traversals** when a multi-step traverse operation achieves the
   same result in one call.
 - **Don't fetch full entities when you only need property values.** Use projection.`;
   }
@@ -3431,7 +3431,7 @@ var EventBus = class {
 };
 
 // src/portability/RepositoryExporter.ts
-var LIBRARY_VERSION = true ? "0.9.0" : "0.1.0";
+var LIBRARY_VERSION = true ? "0.9.2" : "0.1.0";
 var RepositoryExporter = class {
   storage;
   provenance;
@@ -5225,9 +5225,11 @@ var InMemoryStorageProvider = class {
             group.relationships.push(rel);
           }
           nextFrontier.add(connectedEntityId);
-          visited.add(connectedEntityId);
         }
       }
+      for (const id of nextFrontier) {
+        visited.add(id);
+      }
       layers.push(layer);
       currentFrontier = nextFrontier;
       if (nextFrontier.size === 0) break;