@soulcraft/brainy 0.26.0 → 0.28.0

package/dist/unified.js

@@ -8849,8 +8849,11 @@ class S3CompatibleStorage extends BaseStorage {
                 }
             }
             catch (error) {
-                // If HeadObject fails with NoSuchKey, the lock doesn't exist, which is good
-                if (error.name !== 'NoSuchKey' && !error.message?.includes('NoSuchKey')) {
+                // If HeadObject fails with NoSuchKey or NotFound, the lock doesn't exist, which is good
+                if (error.name !== 'NoSuchKey' &&
+                    !error.message?.includes('NoSuchKey') &&
+                    error.name !== 'NotFound' &&
+                    !error.message?.includes('NotFound')) {
                     throw error;
                 }
             }
@@ -8907,7 +8910,10 @@ class S3CompatibleStorage extends BaseStorage {
                 }
                 catch (error) {
                     // If lock doesn't exist, that's fine
-                    if (error.name === 'NoSuchKey' || error.message?.includes('NoSuchKey')) {
+                    if (error.name === 'NoSuchKey' ||
+                        error.message?.includes('NoSuchKey') ||
+                        error.name === 'NotFound' ||
+                        error.message?.includes('NotFound')) {
                         return;
                     }
                     throw error;
@@ -9916,40 +9922,251 @@ async function createStorage(options = {}) {
     return new MemoryStorage();
 }
 
+/**
+ * Graph Types - Standardized Noun and Verb Type System
+ *
+ * This module defines a comprehensive, standardized set of noun and verb types
+ * that can be used to model any kind of graph, semantic network, or data model.
+ *
+ * ## Purpose and Design Philosophy
+ *
+ * The type system is designed to be:
+ * - **Universal**: Capable of representing any domain or use case
+ * - **Hierarchical**: Organized into logical categories for easy navigation
+ * - **Extensible**: Additional metadata can be attached to any entity or relationship
+ * - **Semantic**: Types carry meaning that can be used for reasoning and inference
+ *
+ * ## Noun Types (Entities)
+ *
+ * Noun types represent entities in the graph and are organized into categories:
+ *
+ * ### Core Entity Types
+ * - **Person**: Human entities and individuals
+ * - **Organization**: Formal organizations, companies, institutions
+ * - **Location**: Geographic locations, places, addresses
+ * - **Thing**: Physical objects and tangible items
+ * - **Concept**: Abstract ideas, concepts, and intangible entities
+ * - **Event**: Occurrences with time and place dimensions
+ *
+ * ### Digital/Content Types
+ * - **Document**: Text-based files and documents
+ * - **Media**: Non-text media files (images, videos, audio)
+ * - **File**: Generic digital files
+ * - **Message**: Communication content
+ * - **Content**: Generic content that doesn't fit other categories
+ *
+ * ### Collection Types
+ * - **Collection**: Generic groupings of items
+ * - **Dataset**: Structured collections of data
+ *
+ * ### Business/Application Types
+ * - **Product**: Commercial products and offerings
+ * - **Service**: Services and offerings
+ * - **User**: User accounts and profiles
+ * - **Task**: Actions, todos, and workflow items
+ * - **Project**: Organized initiatives with goals and timelines
+ *
+ * ### Descriptive Types
+ * - **Process**: Workflows, procedures, and sequences
+ * - **State**: States, conditions, or statuses
+ * - **Role**: Roles, positions, or responsibilities
+ * - **Topic**: Subjects or themes
+ * - **Language**: Languages or linguistic entities
+ * - **Currency**: Currencies and monetary units
+ * - **Measurement**: Measurements, metrics, or quantities
+ *
+ * ## Verb Types (Relationships)
+ *
+ * Verb types represent relationships between entities and are organized into categories:
+ *
+ * ### Core Relationship Types
+ * - **RelatedTo**: Generic relationship (default fallback)
+ * - **Contains**: Containment relationship
+ * - **PartOf**: Part-whole relationship
+ * - **LocatedAt**: Spatial relationship
+ * - **References**: Reference or citation relationship
+ *
+ * ### Temporal/Causal Types
+ * - **Precedes/Succeeds**: Temporal sequence relationships
+ * - **Causes**: Causal relationships
+ * - **DependsOn**: Dependency relationships
+ * - **Requires**: Necessity relationships
+ *
+ * ### Creation/Transformation Types
+ * - **Creates**: Creation relationships
+ * - **Transforms**: Transformation relationships
+ * - **Becomes**: State change relationships
+ * - **Modifies**: Modification relationships
+ * - **Consumes**: Consumption relationships
+ *
+ * ### Ownership/Attribution Types
+ * - **Owns**: Ownership relationships
+ * - **AttributedTo**: Attribution or authorship
+ * - **CreatedBy**: Creation attribution
+ * - **BelongsTo**: Belonging relationships
+ *
+ * ### Social/Organizational Types
+ * - **MemberOf**: Membership or affiliation
+ * - **WorksWith**: Professional relationships
+ * - **FriendOf**: Friendship relationships
+ * - **Follows**: Following relationships
+ * - **Likes**: Liking relationships
+ * - **ReportsTo**: Reporting relationships
+ * - **Supervises**: Supervisory relationships
+ * - **Mentors**: Mentorship relationships
+ * - **Communicates**: Communication relationships
+ *
+ * ### Descriptive/Functional Types
+ * - **Describes**: Descriptive relationships
+ * - **Defines**: Definition relationships
+ * - **Categorizes**: Categorization relationships
+ * - **Measures**: Measurement relationships
+ * - **Evaluates**: Evaluation or assessment relationships
+ * - **Uses**: Utilization relationships
+ * - **Implements**: Implementation relationships
+ * - **Extends**: Extension relationships
+ *
+ * ## Usage with Additional Metadata
+ *
+ * While the type system provides a standardized vocabulary, additional metadata
+ * can be attached to any entity or relationship to capture domain-specific
+ * information:
+ *
+ * ```typescript
+ * const person: GraphNoun = {
+ *   id: 'person-123',
+ *   noun: NounType.Person,
+ *   data: {
+ *     name: 'John Doe',
+ *     age: 30,
+ *     profession: 'Engineer'
+ *   }
+ * }
+ *
+ * const worksFor: GraphVerb = {
+ *   id: 'verb-456',
+ *   source: 'person-123',
+ *   target: 'org-789',
+ *   verb: VerbType.MemberOf,
+ *   data: {
+ *     role: 'Senior Engineer',
+ *     startDate: '2020-01-01',
+ *     department: 'Engineering'
+ *   }
+ * }
+ * ```
+ *
+ * ## Modeling Different Graph Types
+ *
+ * This type system can model various graph structures:
+ *
+ * ### Knowledge Graphs
+ * Use Person, Organization, Location, Concept entities with semantic relationships
+ * like AttributedTo, LocatedAt, RelatedTo
+ *
+ * ### Social Networks
+ * Use Person, User entities with social relationships like FriendOf, Follows,
+ * WorksWith, Communicates
+ *
+ * ### Content Networks
+ * Use Document, Media, Content entities with relationships like References,
+ * CreatedBy, Contains, Categorizes
+ *
+ * ### Business Process Models
+ * Use Task, Process, Role entities with relationships like Precedes, Requires,
+ * DependsOn, Transforms
+ *
+ * ### Organizational Charts
+ * Use Person, Role, Organization entities with relationships like ReportsTo,
+ * Supervises, MemberOf
+ *
+ * The flexibility of this system allows it to represent any domain while
+ * maintaining semantic consistency and enabling powerful graph operations
+ * and reasoning capabilities.
+ */
 /**
  * Defines valid noun types for graph entities
  * Used for categorizing different types of nodes
  */
 const NounType = {
-    Person: 'person', // Person entities
-    Place: 'place', // Physical locations
-    Thing: 'thing', // Physical or virtual objects
-    Event: 'event', // Events or occurrences
-    Concept: 'concept', // Abstract concepts or ideas
-    Content: 'content', // Content items
-    Group: 'group', // Groups of related entities
-    List: 'list', // Ordered collections of entities
-    Category: 'category' // Categories for content items including tags
+    // Core Entity Types
+    Person: 'person', // Human entities
+    Organization: 'organization', // Formal organizations (companies, institutions, etc.)
+    Location: 'location', // Geographic locations (merges previous Place and Location)
+    Thing: 'thing', // Physical objects
+    Concept: 'concept', // Abstract ideas, concepts, and intangible entities
+    Event: 'event', // Occurrences with time and place
+    // Digital/Content Types
+    Document: 'document', // Text-based files and documents (reports, articles, etc.)
+    Media: 'media', // Non-text media files (images, videos, audio)
+    File: 'file', // Generic digital files (merges aspects of Digital with file-specific focus)
+    Message: 'message', // Communication content (emails, chat messages, posts)
+    Content: 'content', // Generic content that doesn't fit other categories
+    // Collection Types
+    Collection: 'collection', // Generic grouping of items (merges Group, List, and Category)
+    Dataset: 'dataset', // Structured collections of data
+    // Business/Application Types
+    Product: 'product', // Commercial products and offerings
+    Service: 'service', // Services and offerings
+    User: 'user', // User accounts and profiles
+    Task: 'task', // Actions, todos, and workflow items
+    Project: 'project', // Organized initiatives with goals and timelines
+    // Descriptive Types
+    Process: 'process', // Workflows, procedures, and sequences
+    State: 'state', // States, conditions, or statuses
+    Role: 'role', // Roles, positions, or responsibilities
+    Topic: 'topic', // Subjects or themes
+    Language: 'language', // Languages or linguistic entities
+    Currency: 'currency', // Currencies and monetary units
+    Measurement: 'measurement' // Measurements, metrics, or quantities
 };
 /**
  * Defines valid verb types for relationships
  * Used for categorizing different types of connections
  */
 const VerbType = {
-    AttributedTo: 'attributedTo', // Indicates attribution or authorship
-    Controls: 'controls', // Indicates control or ownership
-    Created: 'created', // Indicates creation or authorship
-    Earned: 'earned', // Indicates achievement or acquisition
-    Owns: 'owns', // Indicates ownership
-    MemberOf: 'memberOf', // Indicates membership or affiliation
-    RelatedTo: 'relatedTo', // Indicates family relationship
-    WorksWith: 'worksWith', // Indicates professional relationship
-    FriendOf: 'friendOf', // Indicates friendship
-    ReportsTo: 'reportsTo', // Indicates reporting relationship
-    Supervises: 'supervises', // Indicates supervisory relationship
-    Mentors: 'mentors', // Indicates mentorship relationship
-    Follows: 'follows', // Indicates the following relationship
-    Likes: 'likes' // Indicates liking relationship
+    // Core Relationship Types
+    RelatedTo: 'relatedTo', // Generic relationship (default fallback)
+    Contains: 'contains', // Containment relationship (parent contains child)
+    PartOf: 'partOf', // Part-whole relationship (child is part of parent)
+    LocatedAt: 'locatedAt', // Spatial relationship
+    References: 'references', // Reference or citation relationship
+    // Temporal/Causal Types
+    Precedes: 'precedes', // Temporal sequence (comes before)
+    Succeeds: 'succeeds', // Temporal sequence (comes after)
+    Causes: 'causes', // Causal relationship (merges Influences and Causes)
+    DependsOn: 'dependsOn', // Dependency relationship
+    Requires: 'requires', // Necessity relationship (new)
+    // Creation/Transformation Types
+    Creates: 'creates', // Creation relationship (merges Created and Produces)
+    Transforms: 'transforms', // Transformation relationship
+    Becomes: 'becomes', // State change relationship
+    Modifies: 'modifies', // Modification relationship
+    Consumes: 'consumes', // Consumption relationship
+    // Ownership/Attribution Types
+    Owns: 'owns', // Ownership relationship (merges Controls and Owns)
+    AttributedTo: 'attributedTo', // Attribution or authorship
+    CreatedBy: 'createdBy', // Creation attribution (new, distinct from Creates)
+    BelongsTo: 'belongsTo', // Belonging relationship (new)
+    // Social/Organizational Types
+    MemberOf: 'memberOf', // Membership or affiliation
+    WorksWith: 'worksWith', // Professional relationship
+    FriendOf: 'friendOf', // Friendship relationship
+    Follows: 'follows', // Following relationship
+    Likes: 'likes', // Liking relationship
+    ReportsTo: 'reportsTo', // Reporting relationship
+    Supervises: 'supervises', // Supervisory relationship
+    Mentors: 'mentors', // Mentorship relationship
+    Communicates: 'communicates', // Communication relationship (merges Communicates and Collaborates)
+    // Descriptive/Functional Types
+    Describes: 'describes', // Descriptive relationship
+    Defines: 'defines', // Definition relationship
+    Categorizes: 'categorizes', // Categorization relationship
+    Measures: 'measures', // Measurement relationship
+    Evaluates: 'evaluates', // Evaluation or assessment relationship
+    Uses: 'uses', // Utilization relationship (new)
+    Implements: 'implements', // Implementation relationship
+    Extends: 'extends' // Extension relationship (merges Extends and Inherits)
 };
 
 /** Common types for the augmentation system */
@@ -12202,6 +12419,12 @@ class BrainyData {
             config.storage?.requestPersistentStorage || false;
         // Set read-only flag
         this.readOnly = config.readOnly || false;
+        // Set write-only flag
+        this.writeOnly = config.writeOnly || false;
+        // Validate that readOnly and writeOnly are not both true
+        if (this.readOnly && this.writeOnly) {
+            throw new Error('Database cannot be both read-only and write-only');
+        }
         // Store storage configuration for later use in init()
         this.storageConfig = config.storage || {};
         // Store timeout and retry configuration
@@ -12228,6 +12451,15 @@ class BrainyData {
             throw new Error('Cannot perform write operation: database is in read-only mode');
         }
     }
+    /**
+     * Check if the database is in write-only mode and throw an error if it is
+     * @throws Error if the database is in write-only mode
+     */
+    checkWriteOnly() {
+        if (this.writeOnly) {
+            throw new Error('Cannot perform search operation: database is in write-only mode');
+        }
+    }
     /**
      * Start real-time updates if enabled in the configuration
      * This will periodically check for new data in storage and update the in-memory index and statistics
@@ -12242,14 +12474,16 @@ class BrainyData {
             return;
         }
         // Set the initial last known noun count
-        this.getNounCount().then(count => {
+        this.getNounCount()
+            .then((count) => {
             this.lastKnownNounCount = count;
-        }).catch(error => {
+        })
+            .catch((error) => {
             console.warn('Failed to get initial noun count for real-time updates:', error);
         });
         // Start the update timer
         this.updateTimerId = setInterval(() => {
-            this.checkForUpdates().catch(error => {
+            this.checkForUpdates().catch((error) => {
                 console.warn('Error during real-time update check:', error);
             });
         }, this.realtimeUpdateConfig.interval);
@@ -12415,7 +12649,8 @@ class BrainyData {
                     // Continue with other changes
                 }
             }
-            if (this.loggingConfig?.verbose && (addedCount > 0 || updatedCount > 0 || deletedCount > 0)) {
+            if (this.loggingConfig?.verbose &&
+                (addedCount > 0 || updatedCount > 0 || deletedCount > 0)) {
                 console.log(`Real-time update: Added ${addedCount}, updated ${updatedCount}, deleted ${deletedCount} nouns using change log`);
             }
             // Update the last known noun count
@@ -12442,7 +12677,7 @@ class BrainyData {
                 const indexNouns = this.index.getNouns();
                 const indexNounIds = new Set(indexNouns.keys());
                 // Find nouns that are in storage but not in the index
-                const newNouns = nouns.filter(noun => !indexNounIds.has(noun.id));
+                const newNouns = nouns.filter((noun) => !indexNounIds.has(noun.id));
                 // Add new nouns to the index
                 for (const noun of newNouns) {
                     // Check if the vector dimensions match the expected dimensions
@@ -12574,23 +12809,31 @@ class BrainyData {
             if (this.useOptimizedIndex && this.index instanceof HNSWIndexOptimized) {
                 this.index.setStorage(this.storage);
             }
-            // Load all nouns from storage
-            const nouns = await this.storage.getAllNouns();
-            // Clear the index and add all nouns
-            this.index.clear();
-            for (const noun of nouns) {
-                // Check if the vector dimensions match the expected dimensions
-                if (noun.vector.length !== this._dimensions) {
-                    console.warn(`Deleting noun ${noun.id} due to dimension mismatch: expected ${this._dimensions}, got ${noun.vector.length}`);
-                    // Delete the mismatched noun from storage to prevent future issues
-                    await this.storage.deleteNoun(noun.id);
-                    continue;
+            // In write-only mode, skip loading the index into memory
+            if (this.writeOnly) {
+                if (this.loggingConfig?.verbose) {
+                    console.log('Database is in write-only mode, skipping index loading');
+                }
+            }
+            else {
+                // Load all nouns from storage
+                const nouns = await this.storage.getAllNouns();
+                // Clear the index and add all nouns
+                this.index.clear();
+                for (const noun of nouns) {
+                    // Check if the vector dimensions match the expected dimensions
+                    if (noun.vector.length !== this._dimensions) {
+                        console.warn(`Deleting noun ${noun.id} due to dimension mismatch: expected ${this._dimensions}, got ${noun.vector.length}`);
+                        // Delete the mismatched noun from storage to prevent future issues
+                        await this.storage.deleteNoun(noun.id);
+                        continue;
+                    }
+                    // Add to index
+                    await this.index.addItem({
+                        id: noun.id,
+                        vector: noun.vector
+                    });
                 }
-                // Add to index
-                await this.index.addItem({
-                    id: noun.id,
-                    vector: noun.vector
-                });
             }
             // Connect to remote server if configured with autoConnect
             if (this.remoteServerConfig && this.remoteServerConfig.autoConnect) {
@@ -12664,8 +12907,7 @@ class BrainyData {
                 }
             }
             // Check if input is already a vector
-            if (Array.isArray(vectorOrData) &&
-                !options.forceEmbed) {
+            if (Array.isArray(vectorOrData) && !options.forceEmbed) {
                 // Input is already a vector (and we've validated it contains only numbers)
                 vector = vectorOrData;
             }
@@ -12706,7 +12948,9 @@ class BrainyData {
             // Save metadata if provided and not empty
             if (metadata !== undefined) {
                 // Skip saving if metadata is an empty object
-                if (metadata && typeof metadata === 'object' && Object.keys(metadata).length === 0) {
+                if (metadata &&
+                    typeof metadata === 'object' &&
+                    Object.keys(metadata).length === 0) {
                     // Don't save empty metadata
                     // Explicitly save null to ensure no metadata is stored
                     await this.storage.saveMetadata(id, null);
@@ -12938,7 +13182,7 @@ class BrainyData {
     filterResultsByService(results, service) {
         if (!service)
             return results;
-        return results.filter(result => {
+        return results.filter((result) => {
             if (!result.metadata || typeof result.metadata !== 'object')
                 return false;
             if (!('createdBy' in result.metadata))
@@ -12961,6 +13205,8 @@ class BrainyData {
         if (!this.isInitialized) {
             throw new Error('BrainyData must be initialized before searching. Call init() first.');
         }
+        // Check if database is in write-only mode
+        this.checkWriteOnly();
         try {
             let queryVector;
             // Check if input is already a vector
@@ -13087,6 +13333,8 @@ class BrainyData {
         if (!this.isInitialized) {
             throw new Error('BrainyData must be initialized before searching. Call init() first.');
         }
+        // Check if database is in write-only mode
+        this.checkWriteOnly();
         // If searching for verbs directly
         if (options.searchVerbs) {
             const verbResults = await this.searchVerbs(queryVectorOrData, k, {
@@ -13138,6 +13386,8 @@ class BrainyData {
         if (!this.isInitialized) {
             throw new Error('BrainyData must be initialized before searching. Call init() first.');
         }
+        // Check if database is in write-only mode
+        this.checkWriteOnly();
         // If input is a string and not a vector, automatically vectorize it
         let queryToUse = queryVectorOrData;
         if (typeof queryVectorOrData === 'string' && !options.forceEmbed) {
@@ -13202,9 +13452,9 @@ class BrainyData {
             // Get all verbs (relationships) from the source entity
             const outgoingVerbs = await this.storage.getVerbsBySource(id);
             // Filter to only include verbs of the specified type
-            const verbsOfType = outgoingVerbs.filter(verb => verb.type === options.relationType);
+            const verbsOfType = outgoingVerbs.filter((verb) => verb.type === options.relationType);
             // Get the target IDs
-            const targetIds = verbsOfType.map(verb => verb.target);
+            const targetIds = verbsOfType.map((verb) => verb.target);
             // Get the actual entities for these IDs
             const results = [];
             for (const targetId of targetIds) {
@@ -13382,7 +13632,7 @@ class BrainyData {
                 const service = options.service || this.getCurrentAugmentation();
                 const graphNoun = metadata;
                 // Preserve existing createdBy and createdAt if they exist
-                const existingMetadata = await this.storage.getMetadata(id);
+                const existingMetadata = (await this.storage.getMetadata(id));
                 if (existingMetadata &&
                     typeof existingMetadata === 'object' &&
                     'createdBy' in existingMetadata) {
@@ -13791,7 +14041,7 @@ class BrainyData {
         // Get all verbs from storage
         const allVerbs = await this.storage.getAllVerbs();
         // Create a set of verb IDs for faster lookup
-        const verbIds = new Set(allVerbs.map(verb => verb.id));
+        const verbIds = new Set(allVerbs.map((verb) => verb.id));
         // Get all nouns from the index
         const nouns = this.index.getNouns();
         // Count nouns that are not verbs
@@ -13853,8 +14103,14 @@ class BrainyData {
                 };
                 // Filter by service if specified
                 const services = options.service
-                    ? (Array.isArray(options.service) ? options.service : [options.service])
-                    : Object.keys({ ...stats.nounCount, ...stats.verbCount, ...stats.metadataCount });
+                    ? Array.isArray(options.service)
+                        ? options.service
+                        : [options.service]
+                    : Object.keys({
+                        ...stats.nounCount,
+                        ...stats.verbCount,
+                        ...stats.metadataCount
+                    });
                 // Calculate totals and service breakdown
                 for (const service of services) {
                     const nounCount = stats.nounCount[service] || 0;
@@ -13959,6 +14215,28 @@ class BrainyData {
      */
     setReadOnly(readOnly) {
         this.readOnly = readOnly;
+        // Ensure readOnly and writeOnly are not both true
+        if (readOnly && this.writeOnly) {
+            this.writeOnly = false;
+        }
+    }
+    /**
+     * Check if the database is in write-only mode
+     * @returns True if the database is in write-only mode, false otherwise
+     */
+    isWriteOnly() {
+        return this.writeOnly;
+    }
+    /**
+     * Set the database to write-only mode
+     * @param writeOnly True to set the database to write-only mode, false to allow searches
+     */
+    setWriteOnly(writeOnly) {
+        this.writeOnly = writeOnly;
+        // Ensure readOnly and writeOnly are not both true
+        if (writeOnly && this.readOnly) {
+            this.readOnly = false;
+        }
     }
     /**
      * Embed text or data into a vector using the same embedding function used by this instance
@@ -13986,6 +14264,8 @@ class BrainyData {
      */
     async searchVerbs(queryVectorOrData, k = 10, options = {}) {
         await this.ensureInitialized();
+        // Check if database is in write-only mode
+        this.checkWriteOnly();
         try {
             let queryVector;
             // Check if input is already a vector
@@ -14052,9 +14332,11 @@ class BrainyData {
                     verbs = allVerbs;
                 }
                 // Calculate similarity for each verb not already in results
-                const existingIds = new Set(verbResults.map(v => v.id));
+                const existingIds = new Set(verbResults.map((v) => v.id));
                 for (const verb of verbs) {
-                    if (!existingIds.has(verb.id) && verb.vector && verb.vector.length > 0) {
+                    if (!existingIds.has(verb.id) &&
+                        verb.vector &&
+                        verb.vector.length > 0) {
                         const distance = this.index.getDistanceFunction()(queryVector, verb.vector);
                         verbResults.push({
                             ...verb,
@@ -14082,6 +14364,8 @@ class BrainyData {
      */
     async searchNounsByVerbs(queryVectorOrData, k = 10, options = {}) {
         await this.ensureInitialized();
+        // Check if database is in write-only mode
+        this.checkWriteOnly();
         try {
             // First, search for nouns
             const nounResults = await this.searchByNounTypes(queryVectorOrData, k * 2, // Get more results initially to account for filtering
@@ -14171,6 +14455,8 @@ class BrainyData {
      */
     async searchText(query, k = 10, options = {}) {
         await this.ensureInitialized();
+        // Check if database is in write-only mode
+        this.checkWriteOnly();
         try {
             // Embed the query text
             const queryVector = await this.embed(query);
@@ -14195,6 +14481,8 @@ class BrainyData {
      */
     async searchRemote(queryVectorOrData, k = 10, options = {}) {
         await this.ensureInitialized();
+        // Check if database is in write-only mode
+        this.checkWriteOnly();
         // Check if connected to a remote server
         if (!this.isConnectedToRemoteServer()) {
             throw new Error('Not connected to a remote server. Call connectToRemoteServer() first.');
@@ -14234,6 +14522,8 @@ class BrainyData {
      */
     async searchCombined(queryVectorOrData, k = 10, options = {}) {
         await this.ensureInitialized();
+        // Check if database is in write-only mode
+        this.checkWriteOnly();
         // Check if connected to a remote server
         if (!this.isConnectedToRemoteServer()) {
             // If not connected to a remote server, just search locally
@@ -14669,14 +14959,14 @@ class BrainyData {
             const nounIds = [];
             const nounDescriptions = {
                 [NounType.Person]: 'A person with unique characteristics',
-                [NounType.Place]: 'A location with specific attributes',
+                [NounType.Location]: 'A location with specific attributes',
                 [NounType.Thing]: 'An object with distinct properties',
                 [NounType.Event]: 'An occurrence with temporal aspects',
                 [NounType.Concept]: 'An abstract idea or notion',
                 [NounType.Content]: 'A piece of content or information',
-                [NounType.Group]: 'A collection of related entities',
-                [NounType.List]: 'An ordered sequence of items',
-                [NounType.Category]: 'A classification or grouping'
+                [NounType.Collection]: 'A collection of related entities',
+                [NounType.Organization]: 'An organization or institution',
+                [NounType.Document]: 'A document or text-based file'
             };
             for (let i = 0; i < nounCount; i++) {
                 // Select a random noun type
@@ -14702,10 +14992,10 @@ class BrainyData {
             const verbIds = [];
             const verbDescriptions = {
                 [VerbType.AttributedTo]: 'Attribution relationship',
-                [VerbType.Controls]: 'Control relationship',
-                [VerbType.Created]: 'Creation relationship',
-                [VerbType.Earned]: 'Achievement relationship',
                 [VerbType.Owns]: 'Ownership relationship',
+                [VerbType.Creates]: 'Creation relationship',
+                [VerbType.Uses]: 'Utilization relationship',
+                [VerbType.BelongsTo]: 'Belonging relationship',
                 [VerbType.MemberOf]: 'Membership relationship',
                 [VerbType.RelatedTo]: 'General relationship',
                 [VerbType.WorksWith]: 'Collaboration relationship',