@soulcraft/brainy 6.2.8 → 6.2.9

package/dist/storage/baseStorage.js

@@ -1276,6 +1276,42 @@ export class BaseStorage extends BaseStorageAdapter {
                     nextCursor
                 };
             }
+            // v6.2.9: Fast path for SINGLE sourceId + verbType combo (common VFS pattern)
+            // This avoids the slow type-iteration fallback for VFS operations
+            // NOTE: Only use fast path for single sourceId to avoid incomplete results
+            const isSingleSourceId = options.filter.sourceId &&
+                !Array.isArray(options.filter.sourceId);
+            if (isSingleSourceId &&
+                options.filter.verbType &&
+                !options.filter.targetId &&
+                !options.filter.service &&
+                !options.filter.metadata) {
+                const sourceId = options.filter.sourceId;
+                const verbTypes = Array.isArray(options.filter.verbType)
+                    ? options.filter.verbType
+                    : [options.filter.verbType];
+                prodLog.debug(`[BaseStorage] getVerbs: Using fast path for sourceId=${sourceId}, verbTypes=${verbTypes.join(',')}`);
+                // Get verbs by source (uses GraphAdjacencyIndex if available)
+                const verbsBySource = await this.getVerbsBySource_internal(sourceId);
+                // Filter by verbType in memory (fast - usually small number of verbs per source)
+                const filtered = verbsBySource.filter(v => verbTypes.includes(v.verb));
+                // Apply pagination
+                const paginatedVerbs = filtered.slice(offset, offset + limit);
+                const hasMore = offset + limit < filtered.length;
+                // Set next cursor if there are more items
+                let nextCursor = undefined;
+                if (hasMore && paginatedVerbs.length > 0) {
+                    const lastItem = paginatedVerbs[paginatedVerbs.length - 1];
+                    nextCursor = lastItem.id;
+                }
+                prodLog.debug(`[BaseStorage] getVerbs: Fast path returned ${filtered.length} verbs (${paginatedVerbs.length} after pagination)`);
+                return {
+                    items: paginatedVerbs,
+                    totalCount: filtered.length,
+                    hasMore,
+                    nextCursor
+                };
+            }
         }
         // For more complex filtering or no filtering, use a paginated approach
         // that avoids loading all verbs into memory at once
@@ -1336,14 +1372,32 @@ export class BaseStorage extends BaseStorageAdapter {
             // Only use type-skipping optimization if counts are non-zero (reliable)
             const totalVerbCountFromArray = this.verbCountsByType.reduce((sum, c) => sum + c, 0);
             const useOptimization = totalVerbCountFromArray > 0;
+            // v6.2.9 BUG FIX: Pre-compute requested verb types to avoid skipping them
+            // When a specific verbType filter is provided, we MUST check that type
+            // even if verbCountsByType shows 0 (counts can be stale after restart)
+            const requestedVerbTypes = options?.filter?.verbType;
+            const requestedVerbTypesSet = requestedVerbTypes
+                ? new Set(Array.isArray(requestedVerbTypes) ? requestedVerbTypes : [requestedVerbTypes])
+                : null;
             // Iterate through all 127 verb types (Stage 3 CANONICAL) with early termination
             // OPTIMIZATION: Skip types with zero count (only if counts are reliable)
             for (let i = 0; i < VERB_TYPE_COUNT && collectedVerbs.length < targetCount; i++) {
-                // Skip empty types for performance (but only if optimization is enabled)
-                if (useOptimization && this.verbCountsByType[i] === 0) {
+                const type = TypeUtils.getVerbFromIndex(i);
+                // v6.2.9 FIX: Never skip a type that's explicitly requested in the filter
+                // This fixes VFS bug where Contains relationships were skipped after restart
+                // when verbCountsByType[Contains] was 0 due to stale statistics
+                const isRequestedType = requestedVerbTypesSet?.has(type) ?? false;
+                const countIsZero = this.verbCountsByType[i] === 0;
+                // Skip empty types for performance (but only if optimization is enabled AND not requested)
+                if (useOptimization && countIsZero && !isRequestedType) {
                     continue;
                 }
-                const type = TypeUtils.getVerbFromIndex(i);
+                // v6.2.9: Log when we DON'T skip a requested type that would have been skipped
+                // This helps diagnose stale statistics issues in production
+                if (useOptimization && countIsZero && isRequestedType) {
+                    prodLog.debug(`[BaseStorage] getVerbs: NOT skipping type=${type} despite count=0 (type was explicitly requested). ` +
+                        `Statistics may be stale - consider running rebuildTypeCounts().`);
+                }
                 try {
                     const verbsOfType = await this.getVerbsByType_internal(type);
                     // Apply filtering inline (memory efficient)
@@ -2169,8 +2223,11 @@ export class BaseStorage extends BaseStorageAdapter {
         this.nounCountsByType[typeIndex]++;
         // COW-aware write (v5.0.1): Use COW helper for branch isolation
         await this.writeObjectToBranch(path, noun);
-        // Periodically save statistics (every 100 saves)
-        if (this.nounCountsByType[typeIndex] % 100 === 0) {
+        // Periodically save statistics
+        // v6.2.9: Also save on first noun of each type to ensure low-count types are tracked
+        const shouldSave = this.nounCountsByType[typeIndex] === 1 || // First noun of type
+            this.nounCountsByType[typeIndex] % 100 === 0; // Every 100th
+        if (shouldSave) {
             await this.saveTypeStatistics();
         }
     }
@@ -2277,7 +2334,11 @@ export class BaseStorage extends BaseStorageAdapter {
             prodLog.warn(`[BaseStorage] graphIndex is null, cannot update index for verb ${verb.id}`);
         }
         // Periodically save statistics
-        if (this.verbCountsByType[typeIndex] % 100 === 0) {
+        // v6.2.9: Also save on first verb of each type to ensure low-count types are tracked
+        // This prevents stale statistics after restart for types with < 100 verbs (common for VFS)
+        const shouldSave = this.verbCountsByType[typeIndex] === 1 || // First verb of type
+            this.verbCountsByType[typeIndex] % 100 === 0; // Every 100th
+        if (shouldSave) {
             await this.saveTypeStatistics();
         }
     }

package/dist/utils/unifiedCache.d.ts

@@ -92,6 +92,13 @@ export declare class UnifiedCache {
      * Delete specific item from cache
      */
     delete(key: string): boolean;
+    /**
+     * Delete all items with keys starting with the given prefix
+     * v6.2.9: Added for VFS cache invalidation (fixes stale parent ID bug)
+     * @param prefix - The key prefix to match
+     * @returns Number of items deleted
+     */
+    deleteByPrefix(prefix: string): number;
     /**
      * Clear cache or specific type
      */

package/dist/utils/unifiedCache.js

@@ -304,6 +304,23 @@ export class UnifiedCache {
         }
         return false;
     }
+    /**
+     * Delete all items with keys starting with the given prefix
+     * v6.2.9: Added for VFS cache invalidation (fixes stale parent ID bug)
+     * @param prefix - The key prefix to match
+     * @returns Number of items deleted
+     */
+    deleteByPrefix(prefix) {
+        let deleted = 0;
+        for (const [key, item] of this.cache) {
+            if (key.startsWith(prefix)) {
+                this.currentSize -= item.size;
+                this.cache.delete(key);
+                deleted++;
+            }
+        }
+        return deleted;
+    }
     /**
      * Clear cache or specific type
      */

package/dist/vfs/PathResolver.d.ts

@@ -64,6 +64,8 @@ export declare class PathResolver {
     createPath(path: string, entityId: string): Promise<void>;
     /**
      * Invalidate cache entries for a path and its children
+     * v6.2.9 FIX: Also invalidates UnifiedCache to prevent stale entity IDs
+     * This fixes the "Source entity not found" bug after delete+recreate operations
      */
     invalidatePath(path: string, recursive?: boolean): void;
     /**

package/dist/vfs/PathResolver.js

@@ -254,26 +254,38 @@ export class PathResolver {
     }
     /**
      * Invalidate cache entries for a path and its children
+     * v6.2.9 FIX: Also invalidates UnifiedCache to prevent stale entity IDs
+     * This fixes the "Source entity not found" bug after delete+recreate operations
      */
     invalidatePath(path, recursive = false) {
         const normalizedPath = this.normalizePath(path);
-        // Remove from all caches
+        // v6.2.9 FIX: Clear parent cache BEFORE deleting from pathCache
+        // (we need the entityId from the cache entry)
+        const cached = this.pathCache.get(normalizedPath);
+        if (cached) {
+            this.parentCache.delete(cached.entityId);
+        }
+        // Remove from local caches
         this.pathCache.delete(normalizedPath);
         this.hotPaths.delete(normalizedPath);
+        // v6.2.9 CRITICAL FIX: Also invalidate UnifiedCache (global LRU cache)
+        // This was missing before, causing stale entity IDs to be returned after delete
+        const cacheKey = `vfs:path:${normalizedPath}`;
+        getGlobalCache().delete(cacheKey);
         if (recursive) {
             // Remove all paths that start with this path
             const prefix = normalizedPath.endsWith('/') ? normalizedPath : normalizedPath + '/';
-            for (const [cachedPath] of this.pathCache) {
+            for (const [cachedPath, entry] of this.pathCache) {
                 if (cachedPath.startsWith(prefix)) {
                     this.pathCache.delete(cachedPath);
                     this.hotPaths.delete(cachedPath);
+                    // v6.2.9: Also clear parent cache for this entry
+                    this.parentCache.delete(entry.entityId);
                 }
             }
-        }
-        // Clear parent cache for the entity
-        const cached = this.pathCache.get(normalizedPath);
-        if (cached) {
-            this.parentCache.delete(cached.entityId);
+            // v6.2.9 CRITICAL FIX: Also invalidate UnifiedCache entries with this prefix
+            const globalCachePrefix = `vfs:path:${prefix}`;
+            getGlobalCache().deleteByPrefix(globalCachePrefix);
         }
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "6.2.8",
+  "version": "6.2.9",
   "description": "Universal Knowledge Protocol™ - World's first Triple Intelligence database unifying vector, graph, and document search in one API. Stage 3 CANONICAL: 42 nouns × 127 verbs covering 96-97% of all human knowledge.",
   "main": "dist/index.js",
   "module": "dist/index.js",