@soulcraft/brainy 3.50.2 → 4.0.0

package/dist/coreTypes.d.ts

@@ -46,8 +46,9 @@ export interface PaginatedSearchResult<T = any> {
 export type DistanceFunction = (a: Vector, b: Vector) => number;
 /**
  * Embedding function for converting data to vectors
+ * v4.0.0: Now properly typed - accepts string, string array (batch), or object, no `any`
  */
-export type EmbeddingFunction = (data: any) => Promise<Vector>;
+export type EmbeddingFunction = (data: string | string[] | Record<string, unknown>) => Promise<Vector>;
 /**
  * Embedding model interface
  */
@@ -58,38 +59,49 @@ export interface EmbeddingModel {
     init(): Promise<void>;
     /**
      * Embed data into a vector
+     * v4.0.0: Now properly typed - accepts string, string array (batch), or object, no `any`
      */
-    embed(data: any): Promise<Vector>;
+    embed(data: string | string[] | Record<string, unknown>): Promise<Vector>;
     /**
      * Dispose of the model resources
      */
     dispose(): Promise<void>;
 }
 /**
- * HNSW graph noun
+ * HNSW graph noun - Pure vector structure (v4.0.0)
+ *
+ * v4.0.0 BREAKING CHANGE: metadata field removed
+ * - Stores ONLY vector data for optimal memory usage
+ * - Metadata stored separately and combined on retrieval
+ * - 25% memory reduction @ 1B scale (no in-memory metadata)
+ * - Prevents metadata explosion bugs at compile-time
  */
 export interface HNSWNoun {
     id: string;
     vector: Vector;
     connections: Map<number, Set<string>>;
     level: number;
-    metadata?: any;
 }
 /**
- * Lightweight verb for HNSW index storage
- * Contains essential data including core relational fields
+ * Lightweight verb for HNSW index storage - Core relational structure (v4.0.0)
  *
- * ARCHITECTURAL FIX (v3.50.1): verb/sourceId/targetId are now first-class fields
+ * Core fields (v3.50.1+): verb/sourceId/targetId are 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
  *
+ * v4.0.0 BREAKING CHANGE: metadata field removed
+ * - Stores ONLY vector + core relational data
+ * - User metadata (weight, custom fields) stored separately
+ * - 10x faster metadata-only updates (skip HNSW rebuild)
+ * - Prevents metadata explosion bugs at compile-time
+ *
  * Benefits:
- * - ONE file read instead of two for 90% of operations
+ * - ONE file read for graph operations (core fields always available)
  * - No type caching needed (type is always available)
  * - Faster graph traversal (source/target immediately available)
- * - Aligns with actual usage patterns
+ * - Optimal memory usage (no user metadata in HNSW)
  */
 export interface HNSWVerb {
     id: string;
@@ -98,11 +110,88 @@ export interface HNSWVerb {
     verb: VerbType;
     sourceId: string;
     targetId: string;
-    metadata?: any;
+}
+/**
+ * Noun metadata structure (v4.0.0)
+ *
+ * Stores all metadata separately from vector data.
+ * Combines with HNSWNoun to form complete entity.
+ */
+export interface NounMetadata {
+    noun: string;
+    data?: unknown;
+    createdAt?: {
+        seconds: number;
+        nanoseconds: number;
+    } | number;
+    updatedAt?: {
+        seconds: number;
+        nanoseconds: number;
+    } | number;
+    createdBy?: {
+        augmentation: string;
+        version: string;
+    };
+    service?: string;
+    [key: string]: unknown;
+}
+/**
+ * Verb metadata structure (v4.0.0)
+ *
+ * Stores all metadata separately from vector + core relational data.
+ * Core fields (verb, sourceId, targetId) remain in HNSWVerb.
+ */
+export interface VerbMetadata {
+    weight?: number;
+    data?: unknown;
+    createdAt?: {
+        seconds: number;
+        nanoseconds: number;
+    } | number;
+    updatedAt?: {
+        seconds: number;
+        nanoseconds: number;
+    } | number;
+    createdBy?: {
+        augmentation: string;
+        version: string;
+    };
+    service?: string;
+    [key: string]: unknown;
+}
+/**
+ * Combined noun structure for transport/API boundaries (v4.0.0)
+ *
+ * Combines pure HNSWNoun vector + separate NounMetadata.
+ * Used for API responses and storage retrieval.
+ */
+export interface HNSWNounWithMetadata {
+    id: string;
+    vector: Vector;
+    connections: Map<number, Set<string>>;
+    level: number;
+    metadata: NounMetadata;
+}
+/**
+ * Combined verb structure for transport/API boundaries (v4.0.0)
+ *
+ * Combines pure HNSWVerb (vector + core fields) + separate VerbMetadata.
+ * Used for API responses and storage retrieval.
+ */
+export interface HNSWVerbWithMetadata {
+    id: string;
+    vector: Vector;
+    connections: Map<number, Set<string>>;
+    verb: VerbType;
+    sourceId: string;
+    targetId: string;
+    metadata: VerbMetadata;
 }
 /**
  * Verb representing a relationship between nouns
  * Stored separately from HNSW index for lightweight performance
+ *
+ * @deprecated Will be replaced by HNSWVerbWithMetadata in future versions
  */
 export interface GraphVerb {
     id: string;
@@ -346,10 +435,41 @@ export interface StatisticsData {
      */
     distributedConfig?: import('./types/distributedTypes.js').SharedConfig;
 }
+/**
+ * Change record for getChangesSince (v4.0.0)
+ * Replaces `any[]` with properly typed structure
+ */
+export interface Change {
+    id: string;
+    type: 'noun' | 'verb';
+    operation: 'create' | 'update' | 'delete';
+    timestamp: number;
+    data?: HNSWNounWithMetadata | HNSWVerbWithMetadata;
+}
 export interface StorageAdapter {
     init(): Promise<void>;
+    /**
+     * Save noun - Pure HNSW vector data only (v4.0.0)
+     * @param noun Pure HNSW vector data (no metadata)
+     * Note: Use saveNounMetadata() to save metadata separately
+     */
     saveNoun(noun: HNSWNoun): Promise<void>;
-    getNoun(id: string): Promise<HNSWNoun | null>;
+    /**
+     * Save noun metadata separately (v4.0.0)
+     * @param id Noun ID
+     * @param metadata Noun metadata
+     */
+    saveNounMetadata(id: string, metadata: NounMetadata): Promise<void>;
+    /**
+     * Delete noun metadata (v4.0.0)
+     * @param id Noun ID
+     */
+    deleteNounMetadata(id: string): Promise<void>;
+    /**
+     * Get noun with metadata combined (v4.0.0)
+     * @returns Combined HNSWNounWithMetadata or null
+     */
+    getNoun(id: string): Promise<HNSWNounWithMetadata | null>;
     /**
      * Get nouns with pagination and filtering
      * @param options Pagination and filtering options
@@ -367,7 +487,7 @@ export interface StorageAdapter {
             metadata?: Record<string, any>;
         };
     }): Promise<{
-        items: HNSWNoun[];
+        items: HNSWNounWithMetadata[];
         totalCount?: number;
         hasMore: boolean;
         nextCursor?: string;
@@ -378,10 +498,19 @@ export interface StorageAdapter {
      * @returns Promise that resolves to an array of nouns of the specified noun type
      * @deprecated Use getNouns() with filter.nounType instead
      */
-    getNounsByNounType(nounType: string): Promise<HNSWNoun[]>;
+    getNounsByNounType(nounType: string): Promise<HNSWNounWithMetadata[]>;
     deleteNoun(id: string): Promise<void>;
-    saveVerb(verb: GraphVerb): Promise<void>;
-    getVerb(id: string): Promise<GraphVerb | null>;
+    /**
+     * Save verb - Pure HNSW verb with core fields only (v4.0.0)
+     * @param verb Pure HNSW verb data (vector + core fields, no user metadata)
+     * Note: Use saveVerbMetadata() to save metadata separately
+     */
+    saveVerb(verb: HNSWVerb): Promise<void>;
+    /**
+     * Get verb with metadata combined (v4.0.0)
+     * @returns Combined HNSWVerbWithMetadata or null
+     */
+    getVerb(id: string): Promise<HNSWVerbWithMetadata | null>;
     /**
      * Get verbs with pagination and filtering
      * @param options Pagination and filtering options
@@ -401,7 +530,7 @@ export interface StorageAdapter {
             metadata?: Record<string, any>;
         };
     }): Promise<{
-        items: GraphVerb[];
+        items: HNSWVerbWithMetadata[];
         totalCount?: number;
         hasMore: boolean;
         nextCursor?: string;
@@ -412,50 +541,93 @@ export interface StorageAdapter {
      * @returns Promise that resolves to an array of verbs with the specified source ID
      * @deprecated Use getVerbs() with filter.sourceId instead
      */
-    getVerbsBySource(sourceId: string): Promise<GraphVerb[]>;
+    getVerbsBySource(sourceId: string): Promise<HNSWVerbWithMetadata[]>;
     /**
      * Get verbs by target
      * @param targetId The target ID to filter by
      * @returns Promise that resolves to an array of verbs with the specified target ID
      * @deprecated Use getVerbs() with filter.targetId instead
      */
-    getVerbsByTarget(targetId: string): Promise<GraphVerb[]>;
+    getVerbsByTarget(targetId: string): Promise<HNSWVerbWithMetadata[]>;
     /**
      * Get verbs by type
      * @param type The verb type to filter by
      * @returns Promise that resolves to an array of verbs with the specified type
      * @deprecated Use getVerbs() with filter.verbType instead
      */
-    getVerbsByType(type: string): Promise<GraphVerb[]>;
+    getVerbsByType(type: string): Promise<HNSWVerbWithMetadata[]>;
     deleteVerb(id: string): Promise<void>;
-    saveMetadata(id: string, metadata: any): Promise<void>;
-    getMetadata(id: string): Promise<any | null>;
+    /**
+     * Save metadata (v4.0.0: now typed)
+     * @param id Entity ID
+     * @param metadata Typed noun metadata
+     */
+    saveMetadata(id: string, metadata: NounMetadata): Promise<void>;
+    /**
+     * Get metadata (v4.0.0: now typed)
+     * @param id Entity ID
+     * @returns Typed noun metadata or null
+     */
+    getMetadata(id: string): Promise<NounMetadata | null>;
     /**
      * Get multiple metadata objects in batches (prevents socket exhaustion)
      * @param ids Array of IDs to get metadata for
-     * @returns Promise that resolves to a Map of id -> metadata
+     * @returns Promise that resolves to a Map of id -> metadata (v4.0.0: typed)
      */
-    getMetadataBatch?(ids: string[]): Promise<Map<string, any>>;
+    getMetadataBatch?(ids: string[]): Promise<Map<string, NounMetadata>>;
     /**
-     * Get noun metadata from storage
+     * Get noun metadata from storage (v4.0.0: now typed)
      * @param id The ID of the noun
      * @returns Promise that resolves to the metadata or null if not found
      */
-    getNounMetadata(id: string): Promise<any | null>;
+    getNounMetadata(id: string): Promise<NounMetadata | null>;
     /**
-     * Save verb metadata to storage
+     * Save verb metadata to storage (v4.0.0: now typed)
      * @param id The ID of the verb
      * @param metadata The metadata to save
      * @returns Promise that resolves when the metadata is saved
      */
-    saveVerbMetadata(id: string, metadata: any): Promise<void>;
+    saveVerbMetadata(id: string, metadata: VerbMetadata): Promise<void>;
     /**
-     * Get verb metadata from storage
+     * Get verb metadata from storage (v4.0.0: now typed)
      * @param id The ID of the verb
      * @returns Promise that resolves to the metadata or null if not found
      */
-    getVerbMetadata(id: string): Promise<any | null>;
+    getVerbMetadata(id: string): Promise<VerbMetadata | null>;
     clear(): Promise<void>;
+    /**
+     * Batch delete multiple objects from storage (v4.0.0)
+     * Efficient deletion of large numbers of entities using cloud provider batch APIs.
+     * Significantly faster and cheaper than individual deletes (up to 1000x speedup).
+     *
+     * @param keys - Array of object keys (paths) to delete
+     * @param options - Optional configuration for batch deletion
+     * @param options.maxRetries - Maximum number of retry attempts per batch (default: 3)
+     * @param options.retryDelayMs - Base delay between retries in milliseconds (default: 1000)
+     * @param options.continueOnError - Continue processing remaining batches if one fails (default: true)
+     * @returns Promise with deletion statistics
+     *
+     * @example
+     * const result = await storage.batchDelete(
+     *   ['path1', 'path2', 'path3'],
+     *   { continueOnError: true }
+     * )
+     * console.log(`Deleted: ${result.successfulDeletes}/${result.totalRequested}`)
+     * console.log(`Failed: ${result.failedDeletes}`)
+     */
+    batchDelete?(keys: string[], options?: {
+        maxRetries?: number;
+        retryDelayMs?: number;
+        continueOnError?: boolean;
+    }): Promise<{
+        totalRequested: number;
+        successfulDeletes: number;
+        failedDeletes: number;
+        errors: Array<{
+            key: string;
+            error: string;
+        }>;
+    }>;
     /**
      * Get information about storage usage and capacity
      * @returns Promise that resolves to an object containing storage status information
@@ -513,11 +685,11 @@ export interface StorageAdapter {
      */
     flushStatisticsToStorage(): Promise<void>;
     /**
-     * Track field names from a JSON document
+     * Track field names from a JSON document (v4.0.0: now typed)
      * @param jsonDocument The JSON document to extract field names from
      * @param service The service that inserted the data
      */
-    trackFieldNames(jsonDocument: any, service: string): Promise<void>;
+    trackFieldNames(jsonDocument: Record<string, unknown>, service: string): Promise<void>;
     /**
      * Get available field names by service
      * @returns Record of field names by service
@@ -529,12 +701,12 @@ export interface StorageAdapter {
      */
     getStandardFieldMappings(): Promise<Record<string, Record<string, string[]>>>;
     /**
-     * Get changes since a specific timestamp
+     * Get changes since a specific timestamp (v4.0.0: now typed)
      * @param timestamp The timestamp to get changes since
      * @param limit Optional limit on the number of changes to return
-     * @returns Promise that resolves to an array of changes
+     * @returns Promise that resolves to an array of properly typed changes
      */
-    getChangesSince?(timestamp: number, limit?: number): Promise<any[]>;
+    getChangesSince?(timestamp: number, limit?: number): Promise<Change[]>;
     /**
      * Get total count of nouns in storage - O(1) operation
      * @returns Promise that resolves to the total number of nouns

package/dist/distributed/configManager.js

@@ -77,9 +77,10 @@ export class DistributedConfigManager {
             const configData = await this.storage.getMetadata(LEGACY_CONFIG_KEY);
             if (configData) {
                 // Migrate to new location
-                await this.migrateConfig(configData);
-                this.lastConfigVersion = configData.version;
-                return configData;
+                const config = configData;
+                await this.migrateConfig(config);
+                this.lastConfigVersion = config.version;
+                return config;
             }
         }
         catch (error) {
@@ -170,13 +171,14 @@ export class DistributedConfigManager {
             const legacyConfig = await this.storage.getMetadata(LEGACY_CONFIG_KEY);
             if (legacyConfig) {
                 console.log('Migrating distributed config from legacy location to index folder...');
+                const config = legacyConfig;
                 // Save to new location
-                await this.migrateConfig(legacyConfig);
+                await this.migrateConfig(config);
                 // Delete from old location (optional - we can keep it for rollback)
                 // await this.storage.deleteMetadata(LEGACY_CONFIG_KEY)
                 this.hasMigrated = true;
-                this.lastConfigVersion = legacyConfig.version;
-                return legacyConfig;
+                this.lastConfigVersion = config.version;
+                return config;
             }
         }
         catch (error) {

package/dist/distributed/shardMigration.js

@@ -217,6 +217,7 @@ export class ShardMigrationManager extends EventEmitter {
         // Don't delete immediately in case of rollback
         const cleanupKey = `cleanup:${shardId}:${Date.now()}`;
         await this.storage.saveMetadata(cleanupKey, {
+            noun: 'Document',
             shardId,
             scheduledFor: Date.now() + 3600000 // Delete after 1 hour
         });
@@ -236,6 +237,7 @@ export class ShardMigrationManager extends EventEmitter {
         }
         // Track progress
         const progress = {
+            noun: 'Document',
             migrationId: data.migrationId,
             shardId: data.shardId,
             received: data.offset + data.items.length,

package/dist/distributed/storageDiscovery.js

@@ -163,7 +163,7 @@ export class StorageDiscovery extends EventEmitter {
         // Remove ourselves from node registry
         try {
             // Mark as deleted rather than actually deleting
-            const deadNode = { ...this.nodeInfo, lastSeen: 0, status: 'inactive' };
+            const deadNode = { noun: 'Document', ...this.nodeInfo, lastSeen: 0, status: 'inactive' };
             await this.storage.saveMetadata(`${this.CLUSTER_PATH}/nodes/${this.nodeId}.json`, deadNode);
         }
         catch (err) {
@@ -181,7 +181,7 @@ export class StorageDiscovery extends EventEmitter {
      */
     async registerNode() {
         const path = `${this.CLUSTER_PATH}/nodes/${this.nodeId}.json`;
-        await this.storage.saveMetadata(path, this.nodeInfo);
+        await this.storage.saveMetadata(path, { noun: 'Document', ...this.nodeInfo });
         // Also update registry
         await this.updateNodeRegistry(this.nodeId);
     }
@@ -235,7 +235,8 @@ export class StorageDiscovery extends EventEmitter {
                 if (nodeId === this.nodeId)
                     continue;
                 try {
-                    const nodeInfo = await this.storage.getMetadata(`${this.CLUSTER_PATH}/nodes/${nodeId}.json`);
+                    const nodeInfoData = await this.storage.getMetadata(`${this.CLUSTER_PATH}/nodes/${nodeId}.json`);
+                    const nodeInfo = nodeInfoData;
                     // Check if node is alive
                     if (now - nodeInfo.lastSeen < this.NODE_TIMEOUT) {
                         if (!this.clusterConfig.nodes[nodeId]) {
@@ -291,6 +292,7 @@ export class StorageDiscovery extends EventEmitter {
                 registry = registry.filter(id => id !== remove);
             }
             await this.storage.saveMetadata(`${this.CLUSTER_PATH}/registry.json`, {
+                noun: 'Document',
                 nodes: registry,
                 updated: Date.now()
             });
@@ -348,7 +350,7 @@ export class StorageDiscovery extends EventEmitter {
     async saveClusterConfig() {
         if (!this.clusterConfig)
             return;
-        await this.storage.saveMetadata(`${this.CLUSTER_PATH}/config.json`, this.clusterConfig);
+        await this.storage.saveMetadata(`${this.CLUSTER_PATH}/config.json`, { noun: 'Document', ...this.clusterConfig });
     }
     /**
      * Trigger leader election (simplified - not full Raft)

package/dist/embeddings/EmbeddingManager.d.ts

@@ -52,7 +52,7 @@ export declare class EmbeddingManager {
     /**
      * Generate embeddings
      */
-    embed(text: string | string[]): Promise<Vector>;
+    embed(text: string | string[] | Record<string, unknown>): Promise<Vector>;
     /**
      * Generate mock embeddings for unit tests
      */
@@ -94,7 +94,7 @@ export declare const embeddingManager: EmbeddingManager;
 /**
  * Direct embed function
  */
-export declare function embed(text: string | string[]): Promise<Vector>;
+export declare function embed(text: string | string[] | Record<string, unknown>): Promise<Vector>;
 /**
  * Get embedding function for compatibility
  */

package/dist/embeddings/EmbeddingManager.js

@@ -174,9 +174,13 @@ export class EmbeddingManager {
         else if (typeof text === 'string') {
             input = text;
         }
+        else if (typeof text === 'object') {
+            // Convert object to string representation
+            input = JSON.stringify(text);
+        }
         else {
             // This shouldn't happen but let's be defensive
-            console.warn('EmbeddingManager.embed received non-string input:', typeof text);
+            console.warn('EmbeddingManager.embed received unexpected input type:', typeof text);
             input = String(text);
         }
         // Generate embedding

package/dist/graph/lsm/LSMTree.js

@@ -218,8 +218,11 @@ export class LSMTree {
             const data = sstable.serialize();
             const storageKey = `${this.config.storagePrefix}-${sstable.metadata.id}`;
             await this.storage.saveMetadata(storageKey, {
-                type: 'lsm-sstable',
-                data: Array.from(data) // Convert Uint8Array to number[] for JSON storage
+                noun: 'thing', // Required for NounMetadata
+                data: {
+                    type: 'lsm-sstable',
+                    data: Array.from(data) // Convert Uint8Array to number[] for JSON storage
+                }
             });
             // Add to L0 SSTables
             if (!this.sstablesByLevel.has(0)) {
@@ -269,8 +272,11 @@ export class LSMTree {
             const data = merged.serialize();
             const storageKey = `${this.config.storagePrefix}-${merged.metadata.id}`;
             await this.storage.saveMetadata(storageKey, {
-                type: 'lsm-sstable',
-                data: Array.from(data)
+                noun: 'thing', // Required for NounMetadata
+                data: {
+                    type: 'lsm-sstable',
+                    data: Array.from(data)
+                }
             });
             // Delete old SSTables from storage
             for (const sstable of sstables) {
@@ -339,8 +345,9 @@ export class LSMTree {
      */
     async loadManifest() {
         try {
-            const data = await this.storage.getMetadata(`${this.config.storagePrefix}-manifest`);
-            if (data) {
+            const metadata = await this.storage.getMetadata(`${this.config.storagePrefix}-manifest`);
+            if (metadata && metadata.data) {
+                const data = metadata.data;
                 this.manifest.sstables = new Map(Object.entries(data.sstables || {}));
                 this.manifest.lastCompaction = data.lastCompaction || Date.now();
                 this.manifest.totalRelationships = data.totalRelationships || 0;
@@ -361,15 +368,18 @@ export class LSMTree {
             const loadPromise = (async () => {
                 try {
                     const storageKey = `${this.config.storagePrefix}-${sstableId}`;
-                    const data = await this.storage.getMetadata(storageKey);
-                    if (data && data.type === 'lsm-sstable') {
-                        // Convert number[] back to Uint8Array
-                        const uint8Data = new Uint8Array(data.data);
-                        const sstable = SSTable.deserialize(uint8Data);
-                        if (!this.sstablesByLevel.has(level)) {
-                            this.sstablesByLevel.set(level, []);
+                    const metadata = await this.storage.getMetadata(storageKey);
+                    if (metadata && metadata.data) {
+                        const data = metadata.data;
+                        if (data.type === 'lsm-sstable') {
+                            // Convert number[] back to Uint8Array
+                            const uint8Data = new Uint8Array(data.data);
+                            const sstable = SSTable.deserialize(uint8Data);
+                            if (!this.sstablesByLevel.has(level)) {
+                                this.sstablesByLevel.set(level, []);
+                            }
+                            this.sstablesByLevel.get(level).push(sstable);
                         }
-                        this.sstablesByLevel.get(level).push(sstable);
                     }
                 }
                 catch (error) {
@@ -386,12 +396,14 @@ export class LSMTree {
      */
     async saveManifest() {
         try {
-            const manifestData = {
-                sstables: Object.fromEntries(this.manifest.sstables),
-                lastCompaction: this.manifest.lastCompaction,
-                totalRelationships: this.manifest.totalRelationships
-            };
-            await this.storage.saveMetadata(`${this.config.storagePrefix}-manifest`, manifestData);
+            await this.storage.saveMetadata(`${this.config.storagePrefix}-manifest`, {
+                noun: 'thing', // Required for NounMetadata
+                data: {
+                    sstables: Object.fromEntries(this.manifest.sstables),
+                    lastCompaction: this.manifest.lastCompaction,
+                    totalRelationships: this.manifest.totalRelationships
+                }
+            });
         }
         catch (error) {
             prodLog.error('LSMTree: Failed to save manifest', error);

package/dist/hnsw/typeAwareHNSWIndex.js

@@ -332,8 +332,12 @@ export class TypeAwareHNSWIndex {
             // Route each noun to its type index
             for (const nounData of result.items) {
                 try {
-                    // Determine noun type from multiple possible sources
-                    const nounType = nounData.nounType || nounData.metadata?.noun || nounData.metadata?.type;
+                    // v4.0.0: Load metadata separately to get noun type
+                    let nounType = nounData.nounType;
+                    if (!nounType) {
+                        const metadata = await this.storage.getNounMetadata(nounData.id);
+                        nounType = (metadata?.noun || metadata?.type);
+                    }
                     // Skip if type not in rebuild list
                     if (!nounType || !typesToRebuild.includes(nounType)) {
                         continue;