@soulcraft/brainy 3.50.0 → 3.50.2

package/CHANGELOG.md

@@ -2,6 +2,85 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/soulcraftlabs/standard-version) for commit guidelines.
 
+### [3.50.2](https://github.com/soulcraftlabs/brainy/compare/v3.50.1...v3.50.2) (2025-10-16)
+
+### 🐛 Critical Bug Fix - Emergency Hotfix for v3.50.1
+
+**Fixed: v3.50.1 Incomplete Fix - Numeric Field Names Still Being Indexed**
+
+**Issue**: v3.50.1 prevented vector fields by name ('vector', 'embedding') but missed vectors stored as objects with numeric keys:
+- Studio team diagnostic showed **212,531 chunk files** still being created
+- Files had numeric field names: `"field": "54716"`, `"field": "100000"`, `"field": "100001"`
+- Total file count: **424,837 files** (expected ~1,200)
+- Root cause: Vectors stored as objects `{0: 0.1, 1: 0.2, ...}` bypassed v3.50.1's field name check
+
+**Impact**:
+- ✅ File reduction: 424,837 → ~1,200 files (354x reduction)
+- ✅ Prevents 212K+ chunk files from being created
+- ✅ Fixes server hangs during initialization
+- ✅ Completes the metadata explosion fix started in v3.50.1
+
+**Solution**:
+- Added regex check in `extractIndexableFields()`: `if (/^\d+$/.test(key)) continue`
+- Skips ANY purely numeric field name (array indices as object keys)
+- Catches: "0", "1", "2", "100", "54716", "100000", etc.
+- Works in combination with v3.50.1's semantic field name checks
+
+**Test Results**:
+- ✅ Added new test: "should NOT index objects with numeric keys (v3.50.2 fix)"
+- ✅ 8/8 integration tests passing
+- ✅ Verifies NO chunk files have numeric field names
+
+**Files Modified**:
+- `src/utils/metadataIndex.ts` (line 1106) - Added numeric field name check
+- `tests/integration/metadata-vector-exclusion.test.ts` - Added v3.50.2 test case
+
+**For Studio Team**:
+After upgrading to v3.50.2:
+1. Delete `_system/` directory to remove corrupted chunk files
+2. Restart server - metadata index will rebuild correctly
+3. File count should normalize to ~1,200 total (from 424,837)
+
+---
+
+### [3.50.1](https://github.com/soulcraftlabs/brainy/compare/v3.50.0...v3.50.1) (2025-10-16)
+
+### 🐛 Critical Bug Fixes
+
+**Fixed: Metadata Explosion Bug - 69K Files Reduced to ~1K**
+
+**Issue**: Metadata indexing was creating 60+ chunk files per entity (69,429 files for 1,143 entities)
+- Root cause: Vector embeddings (384-dimensional arrays) were being indexed in metadata
+- Each vector dimension created a separate chunk file with numeric field names
+- Caused server hangs, VFS operations timing out, and Graph View UI failures
+
+**Impact**:
+- ✅ File reduction: 69,429 → ~1,200 files (58x reduction / 1,200x per entity)
+- ✅ Storage reduction: 3.3GB → ~10MB metadata (330x reduction)
+- ✅ Fixes server initialization hangs (loading 69K files)
+- ✅ Fixes metadata batch loading stalling at batch 23
+- ✅ Fixes VFS getDescendants() hanging indefinitely
+- ✅ Fixes Graph View UI not loading in Soulcraft Studio
+
+**Solution**:
+- Added `NEVER_INDEX` Set excluding vector field names: `['vector', 'embedding', 'embeddings', 'connections']`
+- Added safety check to skip arrays > 10 elements
+- Preserves small array indexing (tags, categories, roles)
+
+**Test Results**:
+- ✅ 7/7 integration tests passing
+- ✅ Verified: 6 chunk files for 10 entities (was 7,210 before fix)
+- ✅ 611/622 unit tests passing
+
+**Files Modified**:
+- `src/utils/metadataIndex.ts` - Core metadata explosion fix
+- `src/coreTypes.ts` - HNSWVerb type enforcement with VerbType enum
+- `src/storage/adapters/*` - Include core relational fields (verb, sourceId, targetId)
+- `src/storage/adapters/baseStorageAdapter.ts` - Type enforcement (HNSWNoun, GraphVerb)
+- `tests/integration/metadata-vector-exclusion.test.ts` - Comprehensive test coverage
+
+---
+
 ### [3.47.0](https://github.com/soulcraftlabs/brainy/compare/v3.46.0...v3.47.0) (2025-10-15)
 
 ### ✨ Features

package/dist/coreTypes.d.ts

@@ -1,6 +1,7 @@
 /**
  * Type definitions for the Soulcraft Brainy
  */
+import type { VerbType } from './types/graphTypes.js';
 /**
  * Vector representation - an array of numbers
  */
@@ -76,12 +77,27 @@ export interface HNSWNoun {
 }
 /**
  * Lightweight verb for HNSW index storage
- * Contains only essential data needed for vector operations
+ * Contains essential data including core relational fields
+ *
+ * ARCHITECTURAL FIX (v3.50.1): verb/sourceId/targetId are now first-class fields
+ * These are NOT metadata - they're the essence of what a verb IS:
+ * - verb: The relationship type (creates, contains, etc.) - needed for routing & display
+ * - sourceId: What entity this verb connects FROM - needed for graph traversal
+ * - targetId: What entity this verb connects TO - needed for graph traversal
+ *
+ * Benefits:
+ * - ONE file read instead of two for 90% of operations
+ * - No type caching needed (type is always available)
+ * - Faster graph traversal (source/target immediately available)
+ * - Aligns with actual usage patterns
  */
 export interface HNSWVerb {
     id: string;
     vector: Vector;
     connections: Map<number, Set<string>>;
+    verb: VerbType;
+    sourceId: string;
+    targetId: string;
     metadata?: any;
 }
 /**

package/dist/storage/adapters/baseStorageAdapter.d.ts

@@ -2,21 +2,21 @@
  * Base Storage Adapter
  * Provides common functionality for all storage adapters, including statistics tracking
  */
-import { StatisticsData, StorageAdapter } from '../../coreTypes.js';
+import { StatisticsData, StorageAdapter, HNSWNoun, GraphVerb } from '../../coreTypes.js';
 /**
  * Base class for storage adapters that implements statistics tracking
  */
 export declare abstract class BaseStorageAdapter implements StorageAdapter {
     abstract init(): Promise<void>;
-    abstract saveNoun(noun: any): Promise<void>;
-    abstract getNoun(id: string): Promise<any | null>;
-    abstract getNounsByNounType(nounType: string): Promise<any[]>;
+    abstract saveNoun(noun: HNSWNoun): Promise<void>;
+    abstract getNoun(id: string): Promise<HNSWNoun | null>;
+    abstract getNounsByNounType(nounType: string): Promise<HNSWNoun[]>;
     abstract deleteNoun(id: string): Promise<void>;
-    abstract saveVerb(verb: any): Promise<void>;
-    abstract getVerb(id: string): Promise<any | null>;
-    abstract getVerbsBySource(sourceId: string): Promise<any[]>;
-    abstract getVerbsByTarget(targetId: string): Promise<any[]>;
-    abstract getVerbsByType(type: string): Promise<any[]>;
+    abstract saveVerb(verb: GraphVerb): Promise<void>;
+    abstract getVerb(id: string): Promise<GraphVerb | null>;
+    abstract getVerbsBySource(sourceId: string): Promise<GraphVerb[]>;
+    abstract getVerbsByTarget(targetId: string): Promise<GraphVerb[]>;
+    abstract getVerbsByType(type: string): Promise<GraphVerb[]>;
     abstract deleteVerb(id: string): Promise<void>;
     abstract saveMetadata(id: string, metadata: any): Promise<void>;
     abstract getMetadata(id: string): Promise<any | null>;
@@ -64,7 +64,7 @@ export declare abstract class BaseStorageAdapter implements StorageAdapter {
             metadata?: Record<string, any>;
         };
     }): Promise<{
-        items: any[];
+        items: HNSWNoun[];
         totalCount?: number;
         hasMore: boolean;
         nextCursor?: string;
@@ -88,7 +88,7 @@ export declare abstract class BaseStorageAdapter implements StorageAdapter {
             metadata?: Record<string, any>;
         };
     }): Promise<{
-        items: any[];
+        items: GraphVerb[];
         totalCount?: number;
         hasMore: boolean;
         nextCursor?: string;
@@ -108,7 +108,7 @@ export declare abstract class BaseStorageAdapter implements StorageAdapter {
             metadata?: Record<string, any>;
         };
     }): Promise<{
-        items: any[];
+        items: HNSWNoun[];
         totalCount?: number;
         hasMore: boolean;
         nextCursor?: string;
@@ -130,7 +130,7 @@ export declare abstract class BaseStorageAdapter implements StorageAdapter {
             metadata?: Record<string, any>;
         };
     }): Promise<{
-        items: any[];
+        items: GraphVerb[];
         totalCount?: number;
         hasMore: boolean;
         nextCursor?: string;

package/dist/storage/adapters/fileSystemStorage.js

@@ -341,13 +341,18 @@ export class FileSystemStorage extends BaseStorage {
         // Check if this is a new edge to update counts
         const isNew = !(await this.fileExists(this.getVerbPath(edge.id)));
         // Convert connections Map to a serializable format
-        // CRITICAL: Only save lightweight vector data (no metadata)
-        // Metadata is saved separately via saveVerbMetadata() (2-file system)
+        // ARCHITECTURAL FIX (v3.50.1): Include core relational fields in verb vector file
+        // These fields are essential for 90% of operations - no metadata lookup needed
         const serializableEdge = {
             id: edge.id,
             vector: edge.vector,
-            connections: this.mapToObject(edge.connections, (set) => Array.from(set))
-            // NO metadata field - saved separately for scalability
+            connections: this.mapToObject(edge.connections, (set) => Array.from(set)),
+            // CORE RELATIONAL DATA (v3.50.1+)
+            verb: edge.verb,
+            sourceId: edge.sourceId,
+            targetId: edge.targetId,
+            // User metadata (if any) - saved separately for scalability
+            // metadata field is saved separately via saveVerbMetadata()
         };
         const filePath = this.getVerbPath(edge.id);
         await this.ensureDirectoryExists(path.dirname(filePath));
@@ -375,10 +380,17 @@ export class FileSystemStorage extends BaseStorage {
             for (const [level, nodeIds] of Object.entries(parsedEdge.connections)) {
                 connections.set(Number(level), new Set(nodeIds));
             }
+            // ARCHITECTURAL FIX (v3.50.1): Return HNSWVerb with core relational fields
             return {
                 id: parsedEdge.id,
                 vector: parsedEdge.vector,
-                connections
+                connections,
+                // CORE RELATIONAL DATA (read from vector file)
+                verb: parsedEdge.verb,
+                sourceId: parsedEdge.sourceId,
+                targetId: parsedEdge.targetId,
+                // User metadata (retrieved separately via getVerbMetadata())
+                metadata: parsedEdge.metadata
             };
         }
         catch (error) {
@@ -411,10 +423,17 @@ export class FileSystemStorage extends BaseStorage {
                 for (const [level, nodeIds] of Object.entries(parsedEdge.connections)) {
                     connections.set(Number(level), new Set(nodeIds));
                 }
+                // ARCHITECTURAL FIX (v3.50.1): Include core relational fields
                 allEdges.push({
                     id: parsedEdge.id,
                     vector: parsedEdge.vector,
-                    connections
+                    connections,
+                    // CORE RELATIONAL DATA
+                    verb: parsedEdge.verb,
+                    sourceId: parsedEdge.sourceId,
+                    targetId: parsedEdge.targetId,
+                    // User metadata
+                    metadata: parsedEdge.metadata
                 });
             }
         }

package/dist/storage/adapters/gcsStorage.js

@@ -636,16 +636,21 @@ export class GcsStorage extends BaseStorage {
         try {
             this.logger.trace(`Saving edge ${edge.id}`);
             // Convert connections Map to serializable format
-            // CRITICAL: Only save lightweight vector data (no metadata)
-            // Metadata is saved separately via saveVerbMetadata() (2-file system)
+            // ARCHITECTURAL FIX (v3.50.1): Include core relational fields in verb vector file
+            // These fields are essential for 90% of operations - no metadata lookup needed
             const serializableEdge = {
                 id: edge.id,
                 vector: edge.vector,
                 connections: Object.fromEntries(Array.from(edge.connections.entries()).map(([level, verbIds]) => [
                     level,
                     Array.from(verbIds)
-                ]))
-                // NO metadata field - saved separately for scalability
+                ])),
+                // CORE RELATIONAL DATA (v3.50.1+)
+                verb: edge.verb,
+                sourceId: edge.sourceId,
+                targetId: edge.targetId,
+                // User metadata (if any) - saved separately for scalability
+                // metadata field is saved separately via saveVerbMetadata()
             };
             // Get the GCS key with UUID-based sharding
             const key = this.getVerbKey(edge.id);
@@ -719,10 +724,17 @@ export class GcsStorage extends BaseStorage {
             for (const [level, verbIds] of Object.entries(data.connections || {})) {
                 connections.set(Number(level), new Set(verbIds));
             }
+            // ARCHITECTURAL FIX (v3.50.1): Return HNSWVerb with core relational fields
             const edge = {
                 id: data.id,
                 vector: data.vector,
-                connections
+                connections,
+                // CORE RELATIONAL DATA (read from vector file)
+                verb: data.verb,
+                sourceId: data.sourceId,
+                targetId: data.targetId,
+                // User metadata (retrieved separately via getVerbMetadata())
+                metadata: data.metadata
             };
             // Update cache
             this.verbCacheManager.set(id, edge);

package/dist/storage/adapters/memoryStorage.js

@@ -226,10 +226,17 @@ export class MemoryStorage extends BaseStorage {
     async saveVerb_internal(verb) {
         const isNew = !this.verbs.has(verb.id);
         // Create a deep copy to avoid reference issues
+        // ARCHITECTURAL FIX (v3.50.1): Include core relational fields
         const verbCopy = {
             id: verb.id,
             vector: [...verb.vector],
-            connections: new Map()
+            connections: new Map(),
+            // CORE RELATIONAL DATA
+            verb: verb.verb,
+            sourceId: verb.sourceId,
+            targetId: verb.targetId,
+            // User metadata (if any)
+            metadata: verb.metadata
         };
         // Copy connections
         for (const [level, connections] of verb.connections.entries()) {
@@ -252,22 +259,23 @@ export class MemoryStorage extends BaseStorage {
             return null;
         }
         // Return a deep copy of the HNSWVerb
+        // ARCHITECTURAL FIX (v3.50.1): Include core relational fields
         const verbCopy = {
             id: verb.id,
             vector: [...verb.vector],
-            connections: new Map()
+            connections: new Map(),
+            // CORE RELATIONAL DATA
+            verb: verb.verb,
+            sourceId: verb.sourceId,
+            targetId: verb.targetId,
+            // User metadata
+            metadata: verb.metadata
         };
         // Copy connections
         for (const [level, connections] of verb.connections.entries()) {
             verbCopy.connections.set(level, new Set(connections));
         }
-        // Get metadata (relationship data in 2-file system)
-        const metadata = await this.getVerbMetadata(id);
-        // Combine into complete verb object
-        return {
-            ...verbCopy,
-            metadata: metadata || {}
-        };
+        return verbCopy;
     }
     /**
      * Get verbs with pagination and filtering

package/dist/storage/adapters/opfsStorage.js

@@ -311,13 +311,18 @@ export class OPFSStorage extends BaseStorage {
     async saveEdge(edge) {
         await this.ensureInitialized();
         try {
-            // CRITICAL: Only save lightweight vector data (no metadata)
-            // Metadata is saved separately via saveVerbMetadata() (2-file system)
+            // ARCHITECTURAL FIX (v3.50.1): Include core relational fields in verb vector file
+            // These fields are essential for 90% of operations - no metadata lookup needed
             const serializableEdge = {
                 id: edge.id,
                 vector: edge.vector,
-                connections: this.mapToObject(edge.connections, (set) => Array.from(set))
-                // NO metadata field - saved separately for scalability
+                connections: this.mapToObject(edge.connections, (set) => Array.from(set)),
+                // CORE RELATIONAL DATA (v3.50.1+)
+                verb: edge.verb,
+                sourceId: edge.sourceId,
+                targetId: edge.targetId,
+                // User metadata (if any) - saved separately for scalability
+                // metadata field is saved separately via saveVerbMetadata()
             };
             // Use UUID-based sharding for verbs
             const shardId = getShardIdFromUuid(edge.id);
@@ -388,10 +393,17 @@ export class OPFSStorage extends BaseStorage {
                 augmentation: 'unknown',
                 version: '1.0'
             };
+            // ARCHITECTURAL FIX (v3.50.1): Return HNSWVerb with core relational fields
             return {
                 id: data.id,
                 vector: data.vector,
-                connections
+                connections,
+                // CORE RELATIONAL DATA (read from vector file)
+                verb: data.verb,
+                sourceId: data.sourceId,
+                targetId: data.targetId,
+                // User metadata (retrieved separately via getVerbMetadata())
+                metadata: data.metadata
             };
         }
         catch (error) {
@@ -433,10 +445,17 @@ export class OPFSStorage extends BaseStorage {
                                     augmentation: 'unknown',
                                     version: '1.0'
                                 };
+                                // ARCHITECTURAL FIX (v3.50.1): Include core relational fields
                                 allEdges.push({
                                     id: data.id,
                                     vector: data.vector,
-                                    connections
+                                    connections,
+                                    // CORE RELATIONAL DATA
+                                    verb: data.verb,
+                                    sourceId: data.sourceId,
+                                    targetId: data.targetId,
+                                    // User metadata
+                                    metadata: data.metadata
                                 });
                             }
                             catch (error) {

package/dist/storage/adapters/r2Storage.js

@@ -549,13 +549,21 @@ export class R2Storage extends BaseStorage {
     async saveEdgeDirect(edge) {
         const requestId = await this.applyBackpressure();
         try {
+            // ARCHITECTURAL FIX (v3.50.1): Include core relational fields in verb vector file
+            // These fields are essential for 90% of operations - no metadata lookup needed
             const serializableEdge = {
                 id: edge.id,
                 vector: edge.vector,
                 connections: Object.fromEntries(Array.from(edge.connections.entries()).map(([level, verbIds]) => [
                     level,
                     Array.from(verbIds)
-                ]))
+                ])),
+                // CORE RELATIONAL DATA (v3.50.1+)
+                verb: edge.verb,
+                sourceId: edge.sourceId,
+                targetId: edge.targetId,
+                // User metadata (if any) - saved separately for scalability
+                // metadata field is saved separately via saveVerbMetadata()
             };
             const key = this.getVerbKey(edge.id);
             const { PutObjectCommand } = await import('@aws-sdk/client-s3');
@@ -612,10 +620,17 @@ export class R2Storage extends BaseStorage {
             for (const [level, verbIds] of Object.entries(data.connections || {})) {
                 connections.set(Number(level), new Set(verbIds));
             }
+            // ARCHITECTURAL FIX (v3.50.1): Return HNSWVerb with core relational fields
             const edge = {
                 id: data.id,
                 vector: data.vector,
-                connections
+                connections,
+                // CORE RELATIONAL DATA (read from vector file)
+                verb: data.verb,
+                sourceId: data.sourceId,
+                targetId: data.targetId,
+                // User metadata (retrieved separately via getVerbMetadata())
+                metadata: data.metadata
             };
             this.verbCacheManager.set(id, edge);
             this.releaseBackpressure(true, requestId);

package/dist/storage/adapters/s3CompatibleStorage.js

@@ -1179,10 +1179,15 @@ export class S3CompatibleStorage extends BaseStorage {
             // Convert connections Map to a serializable format
             // CRITICAL: Only save lightweight vector data (no metadata)
             // Metadata is saved separately via saveVerbMetadata() (2-file system)
+            // ARCHITECTURAL FIX (v3.50.1): Include core relational fields in verb vector file
             const serializableEdge = {
                 id: edge.id,
                 vector: edge.vector,
-                connections: this.mapToObject(edge.connections, (set) => Array.from(set))
+                connections: this.mapToObject(edge.connections, (set) => Array.from(set)),
+                // CORE RELATIONAL DATA (v3.50.1+)
+                verb: edge.verb,
+                sourceId: edge.sourceId,
+                targetId: edge.targetId,
                 // NO metadata field - saved separately for scalability
             };
             // Import the PutObjectCommand only when needed
@@ -1279,10 +1284,17 @@ export class S3CompatibleStorage extends BaseStorage {
                 for (const [level, nodeIds] of Object.entries(parsedEdge.connections)) {
                     connections.set(Number(level), new Set(nodeIds));
                 }
+                // ARCHITECTURAL FIX (v3.50.1): Return HNSWVerb with core relational fields
                 const edge = {
                     id: parsedEdge.id,
                     vector: parsedEdge.vector,
-                    connections
+                    connections,
+                    // CORE RELATIONAL DATA (read from vector file)
+                    verb: parsedEdge.verb,
+                    sourceId: parsedEdge.sourceId,
+                    targetId: parsedEdge.targetId,
+                    // User metadata (retrieved separately via getVerbMetadata())
+                    metadata: parsedEdge.metadata
                 };
                 this.logger.trace(`Successfully retrieved edge ${id}`);
                 return edge;

package/dist/storage/adapters/typeAwareStorageAdapter.d.ts

@@ -72,7 +72,9 @@ export declare class TypeAwareStorageAdapter extends BaseStorage {
      */
     private getNounType;
     /**
-     * Get verb type from verb object or cache
+     * Get verb type from verb object
+     *
+     * ARCHITECTURAL FIX (v3.50.1): Simplified - verb field is now always present
      */
     private getVerbType;
     /**
@@ -93,10 +95,16 @@ export declare class TypeAwareStorageAdapter extends BaseStorage {
     protected deleteNoun_internal(id: string): Promise<void>;
     /**
      * Save verb (type-first path)
+     *
+     * ARCHITECTURAL FIX (v3.50.1): No more caching hack needed!
+     * HNSWVerb now includes verb field, so type is always available
      */
     protected saveVerb_internal(verb: HNSWVerb): Promise<void>;
     /**
      * Get verb (type-first path)
+     *
+     * ARCHITECTURAL FIX (v3.50.1): Cache still useful for performance
+     * Once we know where a verb is, we can retrieve it O(1) instead of searching all types
      */
     protected getVerb_internal(id: string): Promise<HNSWVerb | null>;
     /**
@@ -109,6 +117,8 @@ export declare class TypeAwareStorageAdapter extends BaseStorage {
     protected getVerbsByTarget_internal(targetId: string): Promise<GraphVerb[]>;
     /**
      * Get verbs by type (O(1) with type-first paths!)
+     *
+     * ARCHITECTURAL FIX (v3.50.1): Type is now in HNSWVerb, cached on read
      */
     protected getVerbsByType_internal(verbType: string): Promise<GraphVerb[]>;
     /**

package/dist/storage/adapters/typeAwareStorageAdapter.js

@@ -153,24 +153,21 @@ export class TypeAwareStorageAdapter extends BaseStorage {
         return 'thing';
     }
     /**
-     * Get verb type from verb object or cache
+     * Get verb type from verb object
+     *
+     * ARCHITECTURAL FIX (v3.50.1): Simplified - verb field is now always present
      */
     getVerbType(verb) {
-        // Try verb property first
+        // v3.50.1+: verb is a required field in HNSWVerb
         if ('verb' in verb && verb.verb) {
             return verb.verb;
         }
-        // Try type property
+        // Fallback for GraphVerb (type alias)
         if ('type' in verb && verb.type) {
             return verb.type;
         }
-        // Try cache
-        const cached = this.verbTypeCache.get(verb.id);
-        if (cached) {
-            return cached;
-        }
-        // Default to 'relatedTo' if unknown
-        console.warn(`[TypeAwareStorage] Unknown verb type for ${verb.id}, defaulting to 'relatedTo'`);
+        // This should never happen with v3.50.1+ data
+        console.warn(`[TypeAwareStorage] Verb missing type field for ${verb.id}, defaulting to 'relatedTo'`);
         return 'relatedTo';
     }
     // ============================================================================
@@ -283,9 +280,13 @@ export class TypeAwareStorageAdapter extends BaseStorage {
     }
     /**
      * Save verb (type-first path)
+     *
+     * ARCHITECTURAL FIX (v3.50.1): No more caching hack needed!
+     * HNSWVerb now includes verb field, so type is always available
      */
     async saveVerb_internal(verb) {
-        const type = this.getVerbType(verb);
+        // Type is now a first-class field in HNSWVerb - no caching needed!
+        const type = verb.verb;
         const path = getVerbVectorPath(type, verb.id);
         // Update type tracking
         const typeIndex = TypeUtils.getVerbIndex(type);
@@ -300,22 +301,27 @@ export class TypeAwareStorageAdapter extends BaseStorage {
     }
     /**
      * Get verb (type-first path)
+     *
+     * ARCHITECTURAL FIX (v3.50.1): Cache still useful for performance
+     * Once we know where a verb is, we can retrieve it O(1) instead of searching all types
      */
     async getVerb_internal(id) {
-        // Try cache first
+        // Try cache first for O(1) retrieval
         const cachedType = this.verbTypeCache.get(id);
         if (cachedType) {
             const path = getVerbVectorPath(cachedType, id);
-            return await this.u.readObjectFromPath(path);
+            const verb = await this.u.readObjectFromPath(path);
+            return verb;
         }
-        // Search across all types
+        // Search across all types (only on first access)
         for (let i = 0; i < VERB_TYPE_COUNT; i++) {
             const type = TypeUtils.getVerbFromIndex(i);
             const path = getVerbVectorPath(type, id);
             try {
                 const verb = await this.u.readObjectFromPath(path);
                 if (verb) {
-                    this.verbTypeCache.set(id, type);
+                    // Cache the type for next time (read from verb.verb field)
+                    this.verbTypeCache.set(id, verb.verb);
                     return verb;
                 }
             }
@@ -389,6 +395,8 @@ export class TypeAwareStorageAdapter extends BaseStorage {
     }
     /**
      * Get verbs by type (O(1) with type-first paths!)
+     *
+     * ARCHITECTURAL FIX (v3.50.1): Type is now in HNSWVerb, cached on read
      */
     async getVerbsByType_internal(verbType) {
         const type = verbType;
@@ -399,11 +407,12 @@ export class TypeAwareStorageAdapter extends BaseStorage {
             try {
                 const hnswVerb = await this.u.readObjectFromPath(path);
                 if (hnswVerb) {
+                    // Cache type from HNSWVerb for future O(1) retrievals
+                    this.verbTypeCache.set(hnswVerb.id, hnswVerb.verb);
                     // Convert to GraphVerb
                     const graphVerb = await this.convertHNSWVerbToGraphVerb(hnswVerb);
                     if (graphVerb) {
                         verbs.push(graphVerb);
-                        this.verbTypeCache.set(hnswVerb.id, type);
                     }
                 }
             }

package/dist/storage/baseStorage.d.ts

@@ -71,6 +71,10 @@ export declare abstract class BaseStorage extends BaseStorageAdapter {
     deleteNoun(id: string): Promise<void>;
     /**
      * Save a verb to storage
+     *
+     * ARCHITECTURAL FIX (v3.50.1): HNSWVerb now includes verb/sourceId/targetId
+     * These are core relational fields, not metadata. They're stored in the vector
+     * file for fast access and to align with actual usage patterns.
      */
     saveVerb(verb: GraphVerb): Promise<void>;
     /**
@@ -79,6 +83,9 @@ export declare abstract class BaseStorage extends BaseStorageAdapter {
     getVerb(id: string): Promise<GraphVerb | null>;
     /**
      * Convert HNSWVerb to GraphVerb by combining with metadata
+     *
+     * ARCHITECTURAL FIX (v3.50.1): Core fields (verb/sourceId/targetId) are now in HNSWVerb
+     * Only optional fields (weight, timestamps, etc.) come from metadata file
      */
     protected convertHNSWVerbToGraphVerb(hnswVerb: HNSWVerb): Promise<GraphVerb | null>;
     /**

package/dist/storage/baseStorage.js

@@ -205,6 +205,10 @@ export class BaseStorage extends BaseStorageAdapter {
     }
     /**
      * Save a verb to storage
+     *
+     * ARCHITECTURAL FIX (v3.50.1): HNSWVerb now includes verb/sourceId/targetId
+     * These are core relational fields, not metadata. They're stored in the vector
+     * file for fast access and to align with actual usage patterns.
      */
     async saveVerb(verb) {
         await this.ensureInitialized();
@@ -212,27 +216,29 @@ export class BaseStorage extends BaseStorageAdapter {
         if (verb.verb) {
             validateVerbType(verb.verb);
         }
-        // Extract the lightweight HNSWVerb data
+        // Extract HNSWVerb with CORE relational fields included
         const hnswVerb = {
             id: verb.id,
             vector: verb.vector,
-            connections: verb.connections || new Map()
+            connections: verb.connections || new Map(),
+            // CORE RELATIONAL DATA (v3.50.1+)
+            verb: (verb.verb || verb.type || 'relatedTo'),
+            sourceId: verb.sourceId || verb.source || '',
+            targetId: verb.targetId || verb.target || '',
+            // User metadata (if any)
+            metadata: verb.metadata
         };
-        // Extract and save the metadata separately
+        // Extract lightweight metadata for separate file (optional fields only)
         const metadata = {
-            sourceId: verb.sourceId || verb.source,
-            targetId: verb.targetId || verb.target,
-            source: verb.source || verb.sourceId,
-            target: verb.target || verb.targetId,
-            type: verb.type || verb.verb,
-            verb: verb.verb || verb.type,
             weight: verb.weight,
-            metadata: verb.metadata,
             data: verb.data,
             createdAt: verb.createdAt,
             updatedAt: verb.updatedAt,
             createdBy: verb.createdBy,
-            embedding: verb.embedding
+            // Legacy aliases for backward compatibility
+            source: verb.source || verb.sourceId,
+            target: verb.target || verb.targetId,
+            type: verb.type || verb.verb
         };
         // Save both the HNSWVerb and metadata atomically
         try {
@@ -273,13 +279,14 @@ export class BaseStorage extends BaseStorageAdapter {
     }
     /**
      * Convert HNSWVerb to GraphVerb by combining with metadata
+     *
+     * ARCHITECTURAL FIX (v3.50.1): Core fields (verb/sourceId/targetId) are now in HNSWVerb
+     * Only optional fields (weight, timestamps, etc.) come from metadata file
      */
     async convertHNSWVerbToGraphVerb(hnswVerb) {
         try {
+            // Metadata file is now optional - contains only weight, timestamps, etc.
             const metadata = await this.getVerbMetadata(hnswVerb.id);
-            if (!metadata) {
-                return null;
-            }
             // Create default timestamp if not present
             const defaultTimestamp = {
                 seconds: Math.floor(Date.now() / 1000),
@@ -293,18 +300,21 @@ export class BaseStorage extends BaseStorageAdapter {
             return {
                 id: hnswVerb.id,
                 vector: hnswVerb.vector,
-                sourceId: metadata.sourceId,
-                targetId: metadata.targetId,
-                source: metadata.source,
-                target: metadata.target,
-                verb: metadata.verb,
-                type: metadata.type,
-                weight: metadata.weight || 1.0,
-                metadata: metadata.metadata || {},
-                createdAt: metadata.createdAt || defaultTimestamp,
-                updatedAt: metadata.updatedAt || defaultTimestamp,
-                createdBy: metadata.createdBy || defaultCreatedBy,
-                data: metadata.data,
+                // CORE FIELDS from HNSWVerb (v3.50.1+)
+                verb: hnswVerb.verb,
+                sourceId: hnswVerb.sourceId,
+                targetId: hnswVerb.targetId,
+                // Aliases for backward compatibility
+                type: hnswVerb.verb,
+                source: hnswVerb.sourceId,
+                target: hnswVerb.targetId,
+                // Optional fields from metadata file
+                weight: metadata?.weight || 1.0,
+                metadata: hnswVerb.metadata || {},
+                createdAt: metadata?.createdAt || defaultTimestamp,
+                updatedAt: metadata?.updatedAt || defaultTimestamp,
+                createdBy: metadata?.createdBy || defaultCreatedBy,
+                data: metadata?.data,
                 embedding: hnswVerb.vector
             };
         }
@@ -324,12 +334,19 @@ export class BaseStorage extends BaseStorageAdapter {
             pagination: { limit: Number.MAX_SAFE_INTEGER }
         });
         // Convert GraphVerbs back to HNSWVerbs for internal use
+        // ARCHITECTURAL FIX (v3.50.1): Include core relational fields
         const hnswVerbs = [];
         for (const graphVerb of result.items) {
             const hnswVerb = {
                 id: graphVerb.id,
                 vector: graphVerb.vector,
-                connections: new Map()
+                connections: new Map(),
+                // CORE RELATIONAL DATA
+                verb: (graphVerb.verb || graphVerb.type || 'relatedTo'),
+                sourceId: graphVerb.sourceId || graphVerb.source || '',
+                targetId: graphVerb.targetId || graphVerb.target || '',
+                // User metadata
+                metadata: graphVerb.metadata
             };
             hnswVerbs.push(hnswVerb);
         }

package/dist/utils/metadataIndex.d.ts

@@ -228,6 +228,11 @@ export declare class MetadataIndexManager {
     private shouldIndexField;
     /**
      * Extract indexable field-value pairs from metadata
+     *
+     * BUG FIX (v3.50.1): Exclude vector embeddings and large arrays from indexing
+     * BUG FIX (v3.50.2): Also exclude purely numeric field names (array indices)
+     * - Vector fields (384+ dimensions) were creating 825K chunk files for 1,144 entities
+     * - Arrays converted to objects with numeric keys were still being indexed
      */
     private extractIndexableFields;
     /**

package/dist/utils/metadataIndex.js

@@ -849,28 +849,51 @@ export class MetadataIndexManager {
     }
     /**
      * Extract indexable field-value pairs from metadata
+     *
+     * BUG FIX (v3.50.1): Exclude vector embeddings and large arrays from indexing
+     * BUG FIX (v3.50.2): Also exclude purely numeric field names (array indices)
+     * - Vector fields (384+ dimensions) were creating 825K chunk files for 1,144 entities
+     * - Arrays converted to objects with numeric keys were still being indexed
      */
     extractIndexableFields(metadata) {
         const fields = [];
+        // Fields that should NEVER be indexed (vectors, embeddings, large arrays)
+        const NEVER_INDEX = new Set(['vector', 'embedding', 'embeddings', 'connections']);
         const extract = (obj, prefix = '') => {
             for (const [key, value] of Object.entries(obj)) {
                 const fullKey = prefix ? `${prefix}.${key}` : key;
+                // Skip fields in never-index list (CRITICAL: prevents vector indexing bug)
+                if (NEVER_INDEX.has(key))
+                    continue;
+                // Skip purely numeric field names (array indices converted to object keys)
+                // Legitimate field names should never be purely numeric
+                // This catches vectors stored as objects: {0: 0.1, 1: 0.2, ...}
+                if (/^\d+$/.test(key))
+                    continue;
+                // Skip fields based on user configuration
                 if (!this.shouldIndexField(fullKey))
                     continue;
+                // Skip large arrays (> 10 elements) - likely vectors or bulk data
+                if (Array.isArray(value) && value.length > 10)
+                    continue;
                 if (value && typeof value === 'object' && !Array.isArray(value)) {
-                    // Recurse into nested objects
+                    // Recurse into nested objects (but not arrays)
                     extract(value, fullKey);
                 }
-                else {
-                    // Index this field
-                    fields.push({ field: fullKey, value });
-                    // If it's an array, also index each element
-                    if (Array.isArray(value)) {
-                        for (const item of value) {
+                else if (Array.isArray(value) && value.length <= 10) {
+                    // Small arrays: index as multi-value field (all with same field name)
+                    // Example: tags: ["javascript", "node"] → field="tags", value="javascript" + field="tags", value="node"
+                    for (const item of value) {
+                        // Only index primitive values (not nested objects/arrays)
+                        if (item !== null && typeof item !== 'object') {
                             fields.push({ field: fullKey, value: item });
                         }
                     }
                 }
+                else {
+                    // Primitive value: index it
+                    fields.push({ field: fullKey, value });
+                }
             }
         };
         if (metadata && typeof metadata === 'object') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "3.50.0",
+  "version": "3.50.2",
   "description": "Universal Knowledge Protocol™ - World's first Triple Intelligence database unifying vector, graph, and document search in one API. 31 nouns × 40 verbs for infinite expressiveness.",
   "main": "dist/index.js",
   "module": "dist/index.js",