@soulcraft/brainy 3.50.2 → 4.0.0

package/dist/storage/baseStorage.js

@@ -138,45 +138,41 @@ export class BaseStorage extends BaseStorageAdapter {
         }
     }
     /**
-     * Save a noun to storage
+     * Save a noun to storage (v4.0.0: vector only, metadata saved separately)
+     * @param noun Pure HNSW vector data (no metadata)
      */
     async saveNoun(noun) {
         await this.ensureInitialized();
-        // Validate noun type before saving - storage boundary protection
-        if (noun.metadata?.noun) {
-            validateNounType(noun.metadata.noun);
-        }
-        // Save both the HNSWNoun vector data and metadata separately (2-file system)
-        try {
-            // Save the lightweight HNSWNoun vector file first
-            await this.saveNoun_internal(noun);
-            // Then save the metadata to separate file (if present)
-            if (noun.metadata) {
-                await this.saveNounMetadata(noun.id, noun.metadata);
-            }
-        }
-        catch (error) {
-            console.error(`[ERROR] Failed to save noun ${noun.id}:`, error);
-            // Attempt cleanup - remove noun file if metadata failed
-            try {
-                const nounExists = await this.getNoun_internal(noun.id);
-                if (nounExists) {
-                    console.log(`[CLEANUP] Attempting to remove orphaned noun file ${noun.id}`);
-                    await this.deleteNoun_internal(noun.id);
-                }
-            }
-            catch (cleanupError) {
-                console.error(`[ERROR] Failed to cleanup orphaned noun ${noun.id}:`, cleanupError);
-            }
-            throw new Error(`Failed to save noun ${noun.id}: ${error instanceof Error ? error.message : String(error)}`);
-        }
+        // Save the HNSWNoun vector data only
+        // Metadata must be saved separately via saveNounMetadata()
+        await this.saveNoun_internal(noun);
     }
     /**
-     * Get a noun from storage
+     * Get a noun from storage (v4.0.0: returns combined HNSWNounWithMetadata)
+     * @param id Entity ID
+     * @returns Combined vector + metadata or null
      */
     async getNoun(id) {
         await this.ensureInitialized();
-        return this.getNoun_internal(id);
+        // Load vector and metadata separately
+        const vector = await this.getNoun_internal(id);
+        if (!vector) {
+            return null;
+        }
+        // Load metadata
+        const metadata = await this.getNounMetadata(id);
+        if (!metadata) {
+            console.warn(`[Storage] Noun ${id} has vector but no metadata - this should not happen in v4.0.0`);
+            return null;
+        }
+        // Combine into HNSWNounWithMetadata
+        return {
+            id: vector.id,
+            vector: vector.vector,
+            connections: vector.connections,
+            level: vector.level,
+            metadata
+        };
     }
     /**
      * Get nouns by noun type
@@ -185,7 +181,20 @@ export class BaseStorage extends BaseStorageAdapter {
      */
     async getNounsByNounType(nounType) {
         await this.ensureInitialized();
-        return this.getNounsByNounType_internal(nounType);
+        // Internal method returns HNSWNoun[], need to combine with metadata
+        const nouns = await this.getNounsByNounType_internal(nounType);
+        // Combine each noun with its metadata
+        const nounsWithMetadata = [];
+        for (const noun of nouns) {
+            const metadata = await this.getNounMetadata(noun.id);
+            if (metadata) {
+                nounsWithMetadata.push({
+                    ...noun,
+                    metadata
+                });
+            }
+        }
+        return nounsWithMetadata;
     }
     /**
      * Delete a noun from storage
@@ -204,90 +213,58 @@ export class BaseStorage extends BaseStorageAdapter {
         }
     }
     /**
-     * Save a verb to storage
+     * Save a verb to storage (v4.0.0: verb only, metadata saved separately)
      *
-     * 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.
+     * @param verb Pure HNSW verb with core relational fields (verb, sourceId, targetId)
      */
     async saveVerb(verb) {
         await this.ensureInitialized();
         // Validate verb type before saving - storage boundary protection
-        if (verb.verb) {
-            validateVerbType(verb.verb);
-        }
-        // Extract HNSWVerb with CORE relational fields included
-        const hnswVerb = {
-            id: verb.id,
-            vector: verb.vector,
-            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 lightweight metadata for separate file (optional fields only)
-        const metadata = {
-            weight: verb.weight,
-            data: verb.data,
-            createdAt: verb.createdAt,
-            updatedAt: verb.updatedAt,
-            createdBy: verb.createdBy,
-            // 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 {
-            console.log(`[DEBUG] Saving verb ${verb.id}: sourceId=${verb.sourceId}, targetId=${verb.targetId}`);
-            // Save the HNSWVerb first
-            await this.saveVerb_internal(hnswVerb);
-            console.log(`[DEBUG] Successfully saved HNSWVerb file for ${verb.id}`);
-            // Then save the metadata
-            await this.saveVerbMetadata(verb.id, metadata);
-            console.log(`[DEBUG] Successfully saved metadata file for ${verb.id}`);
-        }
-        catch (error) {
-            console.error(`[ERROR] Failed to save verb ${verb.id}:`, error);
-            // Attempt cleanup - remove verb file if metadata failed
-            try {
-                const verbExists = await this.getVerb_internal(verb.id);
-                if (verbExists) {
-                    console.log(`[CLEANUP] Attempting to remove orphaned verb file ${verb.id}`);
-                    await this.deleteVerb_internal(verb.id);
-                }
-            }
-            catch (cleanupError) {
-                console.error(`[ERROR] Failed to cleanup orphaned verb ${verb.id}:`, cleanupError);
-            }
-            throw new Error(`Failed to save verb ${verb.id}: ${error instanceof Error ? error.message : String(error)}`);
-        }
+        validateVerbType(verb.verb);
+        // Save the HNSWVerb vector and core fields only
+        // Metadata must be saved separately via saveVerbMetadata()
+        await this.saveVerb_internal(verb);
     }
     /**
-     * Get a verb from storage
+     * Get a verb from storage (v4.0.0: returns combined HNSWVerbWithMetadata)
+     * @param id Entity ID
+     * @returns Combined verb + metadata or null
      */
     async getVerb(id) {
         await this.ensureInitialized();
-        const hnswVerb = await this.getVerb_internal(id);
-        if (!hnswVerb) {
+        // Load verb vector and core fields
+        const verb = await this.getVerb_internal(id);
+        if (!verb) {
             return null;
         }
-        return this.convertHNSWVerbToGraphVerb(hnswVerb);
+        // Load metadata
+        const metadata = await this.getVerbMetadata(id);
+        if (!metadata) {
+            console.warn(`[Storage] Verb ${id} has vector but no metadata - this should not happen in v4.0.0`);
+            return null;
+        }
+        // Combine into HNSWVerbWithMetadata
+        return {
+            id: verb.id,
+            vector: verb.vector,
+            connections: verb.connections,
+            verb: verb.verb,
+            sourceId: verb.sourceId,
+            targetId: verb.targetId,
+            metadata
+        };
     }
     /**
      * Convert HNSWVerb to GraphVerb by combining with metadata
+     * DEPRECATED: For backward compatibility only. Use getVerb() which returns HNSWVerbWithMetadata.
      *
-     * ARCHITECTURAL FIX (v3.50.1): Core fields (verb/sourceId/targetId) are now in HNSWVerb
-     * Only optional fields (weight, timestamps, etc.) come from metadata file
+     * @deprecated Use getVerb() instead which returns HNSWVerbWithMetadata
      */
     async convertHNSWVerbToGraphVerb(hnswVerb) {
         try {
-            // Metadata file is now optional - contains only weight, timestamps, etc.
+            // Load metadata
             const metadata = await this.getVerbMetadata(hnswVerb.id);
-            // Create default timestamp if not present
+            // Create default timestamp in Firestore format
             const defaultTimestamp = {
                 seconds: Math.floor(Date.now() / 1000),
                 nanoseconds: (Date.now() % 1000) * 1000000
@@ -297,10 +274,22 @@ export class BaseStorage extends BaseStorageAdapter {
                 augmentation: 'unknown',
                 version: '1.0'
             };
+            // Convert flexible timestamp to Firestore format for GraphVerb
+            const normalizeTimestamp = (ts) => {
+                if (!ts)
+                    return defaultTimestamp;
+                if (typeof ts === 'number') {
+                    return {
+                        seconds: Math.floor(ts / 1000),
+                        nanoseconds: (ts % 1000) * 1000000
+                    };
+                }
+                return ts;
+            };
             return {
                 id: hnswVerb.id,
                 vector: hnswVerb.vector,
-                // CORE FIELDS from HNSWVerb (v3.50.1+)
+                // CORE FIELDS from HNSWVerb
                 verb: hnswVerb.verb,
                 sourceId: hnswVerb.sourceId,
                 targetId: hnswVerb.targetId,
@@ -310,9 +299,9 @@ export class BaseStorage extends BaseStorageAdapter {
                 target: hnswVerb.targetId,
                 // Optional fields from metadata file
                 weight: metadata?.weight || 1.0,
-                metadata: hnswVerb.metadata || {},
-                createdAt: metadata?.createdAt || defaultTimestamp,
-                updatedAt: metadata?.updatedAt || defaultTimestamp,
+                metadata: metadata || {},
+                createdAt: normalizeTimestamp(metadata?.createdAt),
+                updatedAt: normalizeTimestamp(metadata?.updatedAt),
                 createdBy: metadata?.createdBy || defaultCreatedBy,
                 data: metadata?.data,
                 embedding: hnswVerb.vector
@@ -333,23 +322,15 @@ export class BaseStorage extends BaseStorageAdapter {
         const result = await this.getVerbs({
             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(),
-                // 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);
-        }
+        // v4.0.0: Convert HNSWVerbWithMetadata to HNSWVerb (strip metadata)
+        const hnswVerbs = result.items.map(verbWithMetadata => ({
+            id: verbWithMetadata.id,
+            vector: verbWithMetadata.vector,
+            connections: verbWithMetadata.connections,
+            verb: verbWithMetadata.verb,
+            sourceId: verbWithMetadata.sourceId,
+            targetId: verbWithMetadata.targetId
+        }));
         return hnswVerbs;
     }
     /**
@@ -423,8 +404,8 @@ export class BaseStorage extends BaseStorageAdapter {
                 const nounType = Array.isArray(options.filter.nounType)
                     ? options.filter.nounType[0]
                     : options.filter.nounType;
-                // Get nouns by type directly
-                const nounsByType = await this.getNounsByNounType_internal(nounType);
+                // Get nouns by type directly (already combines with metadata)
+                const nounsByType = await this.getNounsByNounType(nounType);
                 // Apply pagination
                 const paginatedNouns = nounsByType.slice(offset, offset + limit);
                 const hasMore = offset + limit < nounsByType.length;
@@ -696,7 +677,7 @@ export class BaseStorage extends BaseStorageAdapter {
         return this.graphIndex;
     }
     /**
-     * Save metadata to storage
+     * Save metadata to storage (v4.0.0: now typed)
      * Routes to correct location (system or entity) based on key format
      */
     async saveMetadata(id, metadata) {
@@ -705,7 +686,7 @@ export class BaseStorage extends BaseStorageAdapter {
         return this.writeObjectToPath(keyInfo.fullPath, metadata);
     }
     /**
-     * Get metadata from storage
+     * Get metadata from storage (v4.0.0: now typed)
      * Routes to correct location (system or entity) based on key format
      */
     async getMetadata(id) {
@@ -714,18 +695,16 @@ export class BaseStorage extends BaseStorageAdapter {
         return this.readObjectFromPath(keyInfo.fullPath);
     }
     /**
-     * Save noun metadata to storage
+     * Save noun metadata to storage (v4.0.0: now typed)
      * Routes to correct sharded location based on UUID
      */
     async saveNounMetadata(id, metadata) {
         // Validate noun type in metadata - storage boundary protection
-        if (metadata?.noun) {
-            validateNounType(metadata.noun);
-        }
+        validateNounType(metadata.noun);
         return this.saveNounMetadata_internal(id, metadata);
     }
     /**
-     * Internal method for saving noun metadata
+     * Internal method for saving noun metadata (v4.0.0: now typed)
      * Uses routing logic to handle both UUIDs (sharded) and system keys (unsharded)
      * @protected
      */
@@ -735,7 +714,7 @@ export class BaseStorage extends BaseStorageAdapter {
         return this.writeObjectToPath(keyInfo.fullPath, metadata);
     }
     /**
-     * Get noun metadata from storage
+     * Get noun metadata from storage (v4.0.0: now typed)
      * Uses routing logic to handle both UUIDs (sharded) and system keys (unsharded)
      */
     async getNounMetadata(id) {
@@ -753,18 +732,15 @@ export class BaseStorage extends BaseStorageAdapter {
         return this.deleteObjectFromPath(keyInfo.fullPath);
     }
     /**
-     * Save verb metadata to storage
+     * Save verb metadata to storage (v4.0.0: now typed)
      * Routes to correct sharded location based on UUID
      */
     async saveVerbMetadata(id, metadata) {
-        // Validate verb type in metadata - storage boundary protection
-        if (metadata?.verb) {
-            validateVerbType(metadata.verb);
-        }
+        // Note: verb type is in HNSWVerb, not metadata
         return this.saveVerbMetadata_internal(id, metadata);
     }
     /**
-     * Internal method for saving verb metadata
+     * Internal method for saving verb metadata (v4.0.0: now typed)
      * Uses routing logic to handle both UUIDs (sharded) and system keys (unsharded)
      * @protected
      */
@@ -774,7 +750,7 @@ export class BaseStorage extends BaseStorageAdapter {
         return this.writeObjectToPath(keyInfo.fullPath, metadata);
     }
     /**
-     * Get verb metadata from storage
+     * Get verb metadata from storage (v4.0.0: now typed)
      * Uses routing logic to handle both UUIDs (sharded) and system keys (unsharded)
      */
     async getVerbMetadata(id) {

package/dist/storage/storageFactory.d.ts

@@ -8,6 +8,7 @@ import { OPFSStorage } from './adapters/opfsStorage.js';
 import { S3CompatibleStorage } from './adapters/s3CompatibleStorage.js';
 import { R2Storage } from './adapters/r2Storage.js';
 import { GcsStorage } from './adapters/gcsStorage.js';
+import { AzureBlobStorage } from './adapters/azureBlobStorage.js';
 import { TypeAwareStorageAdapter } from './adapters/typeAwareStorageAdapter.js';
 import { OperationConfig } from '../utils/operationUtils.js';
 /**
@@ -24,9 +25,10 @@ export interface StorageOptions {
      * - 'r2': Use Cloudflare R2 storage
      * - 'gcs': Use Google Cloud Storage (S3-compatible with HMAC keys)
      * - 'gcs-native': Use Google Cloud Storage (native SDK with ADC)
+     * - 'azure': Use Azure Blob Storage (native SDK with Managed Identity)
      * - 'type-aware': Use type-first storage adapter (wraps another adapter)
      */
-    type?: 'auto' | 'memory' | 'opfs' | 'filesystem' | 's3' | 'r2' | 'gcs' | 'gcs-native' | 'type-aware';
+    type?: 'auto' | 'memory' | 'opfs' | 'filesystem' | 's3' | 'r2' | 'gcs' | 'gcs-native' | 'azure' | 'type-aware';
     /**
      * Force the use of memory storage even if other storage types are available
      */
@@ -148,6 +150,31 @@ export interface StorageOptions {
          */
         secretAccessKey?: string;
     };
+    /**
+     * Configuration for Azure Blob Storage (native SDK with Managed Identity)
+     */
+    azureStorage?: {
+        /**
+         * Azure container name
+         */
+        containerName: string;
+        /**
+         * Azure Storage account name (for Managed Identity or SAS)
+         */
+        accountName?: string;
+        /**
+         * Azure Storage account key (optional, uses Managed Identity if not provided)
+         */
+        accountKey?: string;
+        /**
+         * Azure connection string (highest priority if provided)
+         */
+        connectionString?: string;
+        /**
+         * SAS token (optional, alternative to account key)
+         */
+        sasToken?: string;
+    };
     /**
      * Configuration for Type-Aware Storage (type-first architecture)
      * Wraps another storage adapter and adds type-first routing
@@ -254,4 +281,4 @@ export declare function createStorage(options?: StorageOptions): Promise<Storage
 /**
  * Export storage adapters
  */
-export { MemoryStorage, OPFSStorage, S3CompatibleStorage, R2Storage, GcsStorage, TypeAwareStorageAdapter };
+export { MemoryStorage, OPFSStorage, S3CompatibleStorage, R2Storage, GcsStorage, AzureBlobStorage, TypeAwareStorageAdapter };

package/dist/storage/storageFactory.js

@@ -7,6 +7,7 @@ import { OPFSStorage } from './adapters/opfsStorage.js';
 import { S3CompatibleStorage } from './adapters/s3CompatibleStorage.js';
 import { R2Storage } from './adapters/r2Storage.js';
 import { GcsStorage } from './adapters/gcsStorage.js';
+import { AzureBlobStorage } from './adapters/azureBlobStorage.js';
 import { TypeAwareStorageAdapter } from './adapters/typeAwareStorageAdapter.js';
 // FileSystemStorage is dynamically imported to avoid issues in browser environments
 import { isBrowser } from '../utils/environment.js';
@@ -157,6 +158,22 @@ export async function createStorage(options = {}) {
                     console.warn('GCS native storage configuration is missing, falling back to memory storage');
                     return new MemoryStorage();
                 }
+            case 'azure':
+                if (options.azureStorage) {
+                    console.log('Using Azure Blob Storage (native SDK)');
+                    return new AzureBlobStorage({
+                        containerName: options.azureStorage.containerName,
+                        accountName: options.azureStorage.accountName,
+                        accountKey: options.azureStorage.accountKey,
+                        connectionString: options.azureStorage.connectionString,
+                        sasToken: options.azureStorage.sasToken,
+                        cacheConfig: options.cacheConfig
+                    });
+                }
+                else {
+                    console.warn('Azure storage configuration is missing, falling back to memory storage');
+                    return new MemoryStorage();
+                }
             case 'type-aware': {
                 console.log('Using Type-Aware Storage (type-first architecture)');
                 // Create underlying storage adapter
@@ -241,6 +258,18 @@ export async function createStorage(options = {}) {
             cacheConfig: options.cacheConfig
         });
     }
+    // If Azure storage is specified, use it
+    if (options.azureStorage) {
+        console.log('Using Azure Blob Storage (native SDK)');
+        return new AzureBlobStorage({
+            containerName: options.azureStorage.containerName,
+            accountName: options.azureStorage.accountName,
+            accountKey: options.azureStorage.accountKey,
+            connectionString: options.azureStorage.connectionString,
+            sasToken: options.azureStorage.sasToken,
+            cacheConfig: options.cacheConfig
+        });
+    }
     // Auto-detect the best storage adapter based on the environment
     // First, check if we're in Node.js (prioritize for test environments)
     if (!isBrowser()) {
@@ -286,7 +315,7 @@ export async function createStorage(options = {}) {
 /**
  * Export storage adapters
  */
-export { MemoryStorage, OPFSStorage, S3CompatibleStorage, R2Storage, GcsStorage, TypeAwareStorageAdapter };
+export { MemoryStorage, OPFSStorage, S3CompatibleStorage, R2Storage, GcsStorage, AzureBlobStorage, TypeAwareStorageAdapter };
 // Export FileSystemStorage conditionally
 // NOTE: FileSystemStorage is now only imported dynamically to avoid fs imports in browser builds
 // export { FileSystemStorage } from './adapters/fileSystemStorage.js'

package/dist/utils/entityIdMapper.js

@@ -32,8 +32,9 @@ export class EntityIdMapper {
      */
     async init() {
         try {
-            const data = await this.storage.getMetadata(this.storageKey);
-            if (data) {
+            const metadata = await this.storage.getMetadata(this.storageKey);
+            if (metadata && metadata.data) {
+                const data = metadata.data;
                 this.nextId = data.nextId;
                 // Rebuild maps from serialized data
                 this.uuidToInt = new Map(Object.entries(data.uuidToInt).map(([k, v]) => [k, Number(v)]));
@@ -136,7 +137,9 @@ export class EntityIdMapper {
             return;
         }
         // Convert maps to plain objects for serialization
+        // v4.0.0: Add required 'noun' property for NounMetadata
         const data = {
+            noun: 'EntityIdMapper',
             nextId: this.nextId,
             uuidToInt: Object.fromEntries(this.uuidToInt),
             intToUuid: Object.fromEntries(this.intToUuid)

package/dist/utils/fieldTypeInference.js

@@ -298,6 +298,7 @@ export class FieldTypeInference {
             const cacheKey = `${this.CACHE_STORAGE_PREFIX}${field}`;
             const data = await this.storage.getMetadata(cacheKey);
             if (data) {
+                // v4.0.0: Double cast for type boundary crossing
                 return data;
             }
         }
@@ -313,8 +314,13 @@ export class FieldTypeInference {
         // Save to in-memory cache
         this.typeCache.set(field, typeInfo);
         // Save to persistent storage (async, non-blocking)
+        // v4.0.0: Add required 'noun' property for NounMetadata
         const cacheKey = `${this.CACHE_STORAGE_PREFIX}${field}`;
-        await this.storage.saveMetadata(cacheKey, typeInfo).catch(error => {
+        const metadataObj = {
+            noun: 'FieldTypeCache',
+            ...typeInfo
+        };
+        await this.storage.saveMetadata(cacheKey, metadataObj).catch(error => {
             prodLog.warn(`Failed to save field type cache for '${field}':`, error);
         });
     }
@@ -377,6 +383,7 @@ export class FieldTypeInference {
         if (field) {
             this.typeCache.delete(field);
             const cacheKey = `${this.CACHE_STORAGE_PREFIX}${field}`;
+            // v4.0.0: null signals deletion to storage adapter
             await this.storage.saveMetadata(cacheKey, null);
         }
         else {

package/dist/utils/metadataFilter.d.ts

@@ -3,7 +3,7 @@
  * Filters DURING search to ensure relevant results
  * Simple API that just works without configuration
  */
-import { SearchResult, HNSWNoun } from '../coreTypes.js';
+import { SearchResult, HNSWNounWithMetadata } from '../coreTypes.js';
 /**
  * Brainy Field Operators (BFO) - Our own field query system
  * Designed for performance, clarity, and patent independence
@@ -74,8 +74,9 @@ export declare function applyCompoundScoring<T>(results: SearchResult<T>[], filt
 export declare function filterSearchResultsByMetadata<T>(results: SearchResult<T>[], filter: MetadataFilter): SearchResult<T>[];
 /**
  * Filter nouns by metadata before search
+ * v4.0.0: Takes HNSWNounWithMetadata which includes metadata field
  */
-export declare function filterNounsByMetadata(nouns: HNSWNoun[], filter: MetadataFilter): HNSWNoun[];
+export declare function filterNounsByMetadata(nouns: HNSWNounWithMetadata[], filter: MetadataFilter): HNSWNounWithMetadata[];
 /**
  * Aggregate search results for faceted search
  */

package/dist/utils/metadataFilter.js

@@ -237,6 +237,7 @@ export function filterSearchResultsByMetadata(results, filter) {
 }
 /**
  * Filter nouns by metadata before search
+ * v4.0.0: Takes HNSWNounWithMetadata which includes metadata field
  */
 export function filterNounsByMetadata(nouns, filter) {
     if (!filter || Object.keys(filter).length === 0) {

package/dist/utils/metadataIndex.js

@@ -1462,7 +1462,9 @@ export class MetadataIndexManager {
         try {
             const indexId = `__metadata_field_index__${filename}`;
             const unifiedKey = `metadata:field:${filename}`;
+            // v4.0.0: Add required 'noun' property for NounMetadata
             await this.storage.saveMetadata(indexId, {
+                noun: 'MetadataFieldIndex',
                 values: fieldIndex.values,
                 lastUpdated: fieldIndex.lastUpdated
             });

package/dist/utils/metadataIndexChunking.js

@@ -460,11 +460,13 @@ export class ChunkManager {
             const chunkPath = this.getChunkPath(field, chunkId);
             const data = await this.storage.getMetadata(chunkPath);
             if (data) {
+                // v4.0.0: Cast NounMetadata to chunk data structure
+                const chunkData = data;
                 // Deserialize: convert serialized roaring bitmaps back to RoaringBitmap32 objects
                 const chunk = {
-                    chunkId: data.chunkId,
-                    field: data.field,
-                    entries: new Map(Object.entries(data.entries).map(([value, serializedBitmap]) => {
+                    chunkId: chunkData.chunkId,
+                    field: chunkData.field,
+                    entries: new Map(Object.entries(chunkData.entries).map(([value, serializedBitmap]) => {
                         // Deserialize roaring bitmap from portable format
                         const bitmap = new RoaringBitmap32();
                         if (serializedBitmap && typeof serializedBitmap === 'object' && serializedBitmap.buffer) {
@@ -473,7 +475,7 @@ export class ChunkManager {
                         }
                         return [value, bitmap];
                     })),
-                    lastUpdated: data.lastUpdated
+                    lastUpdated: chunkData.lastUpdated
                 };
                 this.chunkCache.set(cacheKey, chunk);
                 return chunk;
@@ -492,7 +494,9 @@ export class ChunkManager {
         // Update cache
         this.chunkCache.set(cacheKey, chunk);
         // Serialize: convert RoaringBitmap32 to portable format (Buffer)
+        // v4.0.0: Add required 'noun' property for NounMetadata
         const serializable = {
+            noun: 'IndexChunk', // Required by NounMetadata interface
             chunkId: chunk.chunkId,
             field: chunk.field,
             entries: Object.fromEntries(Array.from(chunk.entries.entries()).map(([value, bitmap]) => [
@@ -652,6 +656,7 @@ export class ChunkManager {
         const cacheKey = `${field}:${chunkId}`;
         this.chunkCache.delete(cacheKey);
         const chunkPath = this.getChunkPath(field, chunkId);
+        // v4.0.0: null signals deletion to storage adapter
         await this.storage.saveMetadata(chunkPath, null);
     }
     /**

package/dist/utils/periodicCleanup.js

@@ -153,6 +153,7 @@ export class PeriodicCleanup {
             });
             for (const noun of nounsResult.items) {
                 try {
+                    // v4.0.0: Cast NounMetadata to NamespacedMetadata for isDeleted check
                     if (!noun.metadata || !isDeleted(noun.metadata)) {
                         continue; // Not deleted, skip
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "3.50.2",
+  "version": "4.0.0",
   "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",
@@ -163,6 +163,8 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.540.0",
+    "@azure/identity": "^4.0.0",
+    "@azure/storage-blob": "^12.17.0",
     "@google-cloud/storage": "^7.14.0",
     "@huggingface/transformers": "^3.7.2",
     "@msgpack/msgpack": "^3.1.2",