@soulcraft/brainy 5.10.4 → 5.11.0

package/dist/storage/adapters/opfsStorage.js

@@ -42,6 +42,16 @@ export class OPFSStorage extends BaseStorage {
         this.statistics = null;
         this.activeLocks = new Set();
         this.lockPrefix = 'opfs-lock-';
+        /**
+         * Check if COW has been explicitly disabled via clear()
+         * v5.10.4: Fixes bug where clear() doesn't persist across instance restarts
+         * @returns true if marker file exists, false otherwise
+         * @protected
+         */
+        /**
+         * v5.11.0: Removed checkClearMarker() and createClearMarker() methods
+         * COW is now always enabled - marker files are no longer used
+         */
         // Quota monitoring configuration (v4.0.0)
         this.quotaWarningThreshold = 0.8; // Warn at 80% usage
         this.quotaCriticalThreshold = 0.95; // Critical at 95% usage
@@ -393,18 +403,11 @@ export class OPFSStorage extends BaseStorage {
             try {
                 // Delete the entire _cow/ directory (not just contents)
                 await this.rootDir.removeEntry('_cow', { recursive: true });
-                // CRITICAL: Reset COW state to prevent automatic reinitialization
-                // When COW data is cleared, we must also clear the COW managers
-                // Otherwise initializeCOW() will auto-recreate initial commit on next operation
+                // v5.11.0: Reset COW managers (but don't disable COW - it's always enabled)
+                // COW will re-initialize automatically on next use
                 this.refManager = undefined;
                 this.blobStorage = undefined;
                 this.commitLog = undefined;
-                this.cowEnabled = false;
-                // v5.10.4: Create persistent marker file (CRITICAL FIX)
-                // Bug: cowEnabled = false only affects current instance, not future instances
-                // Fix: Create marker file that persists across instance restarts
-                // When new instance calls initializeCOW(), it checks for this marker
-                await this.createClearMarker();
             }
             catch (error) {
                 // Ignore if _cow directory doesn't exist (not all instances use COW)
@@ -423,51 +426,6 @@ export class OPFSStorage extends BaseStorage {
             throw error;
         }
     }
-    /**
-     * Check if COW has been explicitly disabled via clear()
-     * v5.10.4: Fixes bug where clear() doesn't persist across instance restarts
-     * @returns true if marker file exists, false otherwise
-     * @protected
-     */
-    async checkClearMarker() {
-        await this.ensureInitialized();
-        try {
-            // Get system directory (may not exist yet)
-            const systemDir = await this.rootDir.getDirectoryHandle('system', { create: false });
-            // Try to get the marker file
-            await systemDir.getFileHandle('cow-disabled', { create: false });
-            return true; // Marker exists
-        }
-        catch (error) {
-            if (error.name === 'NotFoundError') {
-                return false; // Marker doesn't exist (or system dir doesn't exist)
-            }
-            // Other errors (permissions, etc.) - treat as marker not existing
-            console.warn('OPFSStorage.checkClearMarker: Error checking marker', error);
-            return false;
-        }
-    }
-    /**
-     * Create marker indicating COW has been explicitly disabled
-     * v5.10.4: Called by clear() to prevent COW reinitialization on new instances
-     * @protected
-     */
-    async createClearMarker() {
-        await this.ensureInitialized();
-        try {
-            // Get or create system directory
-            const systemDir = await this.rootDir.getDirectoryHandle('system', { create: true });
-            // Create empty marker file
-            const fileHandle = await systemDir.getFileHandle('cow-disabled', { create: true });
-            const writable = await fileHandle.createWritable();
-            await writable.write(new Uint8Array(0)); // Empty file
-            await writable.close();
-        }
-        catch (error) {
-            console.error('OPFSStorage.createClearMarker: Failed to create marker file', error);
-            // Don't throw - marker creation failure shouldn't break clear()
-        }
-    }
     /**
      * Get information about storage usage and capacity
      */

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

@@ -200,18 +200,5 @@ export declare class R2Storage extends BaseStorage {
         quota: number | null;
         details?: Record<string, any>;
     }>;
-    /**
-     * Check if COW has been explicitly disabled via clear()
-     * v5.10.4: Fixes bug where clear() doesn't persist across instance restarts
-     * @returns true if marker object exists, false otherwise
-     * @protected
-     */
-    protected checkClearMarker(): Promise<boolean>;
-    /**
-     * Create marker indicating COW has been explicitly disabled
-     * v5.10.4: Called by clear() to prevent COW reinitialization on new instances
-     * @protected
-     */
-    protected createClearMarker(): Promise<void>;
 }
 export {};

package/dist/storage/adapters/r2Storage.js

@@ -771,27 +771,27 @@ export class R2Storage extends BaseStorage {
     async clear() {
         await this.ensureInitialized();
         prodLog.info('🧹 R2: Clearing all data from bucket...');
-        // Clear all prefixes (v5.6.1: includes _cow/ for version control data)
-        // _cow/ stores all git-like versioning data (commits, trees, blobs, refs)
-        // Must be deleted to fully clear all data including version history
-        for (const prefix of [this.nounPrefix, this.verbPrefix, this.metadataPrefix, this.verbMetadataPrefix, this.systemPrefix, '_cow/']) {
-            const objects = await this.listObjectsUnderPath(prefix);
-            for (const key of objects) {
-                await this.deleteObjectFromPath(key);
-            }
-        }
-        // CRITICAL: Reset COW state to prevent automatic reinitialization
-        // When COW data is cleared, we must also clear the COW managers
-        // Otherwise initializeCOW() will auto-recreate initial commit on next operation
+        // v5.11.0: Clear ALL data using correct paths
+        // Delete entire branches/ directory (includes ALL entities, ALL types, ALL VFS data, ALL forks)
+        const branchObjects = await this.listObjectsUnderPath('branches/');
+        for (const key of branchObjects) {
+            await this.deleteObjectFromPath(key);
+        }
+        // Delete COW version control data
+        const cowObjects = await this.listObjectsUnderPath('_cow/');
+        for (const key of cowObjects) {
+            await this.deleteObjectFromPath(key);
+        }
+        // Delete system metadata
+        const systemObjects = await this.listObjectsUnderPath('_system/');
+        for (const key of systemObjects) {
+            await this.deleteObjectFromPath(key);
+        }
+        // v5.11.0: Reset COW managers (but don't disable COW - it's always enabled)
+        // COW will re-initialize automatically on next use
         this.refManager = undefined;
         this.blobStorage = undefined;
         this.commitLog = undefined;
-        this.cowEnabled = false;
-        // v5.10.4: Create persistent marker object (CRITICAL FIX)
-        // Bug: cowEnabled = false only affects current instance, not future instances
-        // Fix: Create marker object that persists across instance restarts
-        // When new instance calls initializeCOW(), it checks for this marker
-        await this.createClearMarker();
         this.nounCacheManager.clear();
         this.verbCacheManager.clear();
         this.totalNounCount = 0;
@@ -818,40 +818,5 @@ export class R2Storage extends BaseStorage {
             }
         };
     }
-    /**
-     * Check if COW has been explicitly disabled via clear()
-     * v5.10.4: Fixes bug where clear() doesn't persist across instance restarts
-     * @returns true if marker object exists, false otherwise
-     * @protected
-     */
-    async checkClearMarker() {
-        await this.ensureInitialized();
-        try {
-            const markerPath = `${this.systemPrefix}cow-disabled`;
-            const data = await this.readObjectFromPath(markerPath);
-            return data !== null; // Marker exists if we got any data
-        }
-        catch (error) {
-            prodLog.warn('R2Storage.checkClearMarker: Error checking marker', error);
-            return false;
-        }
-    }
-    /**
-     * Create marker indicating COW has been explicitly disabled
-     * v5.10.4: Called by clear() to prevent COW reinitialization on new instances
-     * @protected
-     */
-    async createClearMarker() {
-        await this.ensureInitialized();
-        try {
-            const markerPath = `${this.systemPrefix}cow-disabled`;
-            // Create empty marker object
-            await this.writeObjectToPath(markerPath, '');
-        }
-        catch (error) {
-            prodLog.error('R2Storage.createClearMarker: Failed to create marker object', error);
-            // Don't throw - marker creation failure shouldn't break clear()
-        }
-    }
 }
 //# sourceMappingURL=r2Storage.js.map

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

@@ -379,13 +379,10 @@ export declare class S3CompatibleStorage extends BaseStorage {
      * @returns true if marker object exists, false otherwise
      * @protected
      */
-    protected checkClearMarker(): Promise<boolean>;
     /**
-     * Create marker indicating COW has been explicitly disabled
-     * v5.10.4: Called by clear() to prevent COW reinitialization on new instances
-     * @protected
+     * v5.11.0: Removed checkClearMarker() and createClearMarker() methods
+     * COW is now always enabled - marker files are no longer used
      */
-    protected createClearMarker(): Promise<void>;
     protected statisticsBatchUpdateTimerId: NodeJS.Timeout | null;
     protected statisticsModified: boolean;
     protected lastStatisticsFlushTime: number;

package/dist/storage/adapters/s3CompatibleStorage.js

@@ -89,6 +89,16 @@ export class S3CompatibleStorage extends BaseStorage {
         this.hnswLocks = new Map();
         // Node cache to avoid redundant API calls
         this.nodeCache = new Map();
+        /**
+         * Check if COW has been explicitly disabled via clear()
+         * v5.10.4: Fixes bug where clear() doesn't persist across instance restarts
+         * @returns true if marker object exists, false otherwise
+         * @protected
+         */
+        /**
+         * v5.11.0: Removed checkClearMarker() and createClearMarker() methods
+         * COW is now always enabled - marker files are no longer used
+         */
         // Batch update timer ID
         this.statisticsBatchUpdateTimerId = null;
         // Flag to indicate if statistics have been modified since last save
@@ -1611,32 +1621,18 @@ export class S3CompatibleStorage extends BaseStorage {
                     }
                 }
             };
-            // Delete all objects in the nouns directory
-            await deleteObjectsWithPrefix(this.nounPrefix);
-            // Delete all objects in the verbs directory
-            await deleteObjectsWithPrefix(this.verbPrefix);
-            // Delete all objects in the noun metadata directory
-            await deleteObjectsWithPrefix(this.metadataPrefix);
-            // Delete all objects in the verb metadata directory
-            await deleteObjectsWithPrefix(this.verbMetadataPrefix);
-            // Delete all objects in the index directory
-            await deleteObjectsWithPrefix(this.indexPrefix);
-            // v5.6.1: Delete COW (copy-on-write) version control data
-            // This includes all git-like versioning data (commits, trees, blobs, refs)
-            // Must be deleted to fully clear all data including version history
+            // v5.11.0: Clear ALL data using correct paths
+            // Delete entire branches/ directory (includes ALL entities, ALL types, ALL VFS data, ALL forks)
+            await deleteObjectsWithPrefix('branches/');
+            // Delete COW version control data
             await deleteObjectsWithPrefix('_cow/');
-            // CRITICAL: Reset COW state to prevent automatic reinitialization
-            // When COW data is cleared, we must also clear the COW managers
-            // Otherwise initializeCOW() will auto-recreate initial commit on next operation
+            // Delete system metadata
+            await deleteObjectsWithPrefix('_system/');
+            // v5.11.0: Reset COW managers (but don't disable COW - it's always enabled)
+            // COW will re-initialize automatically on next use
             this.refManager = undefined;
             this.blobStorage = undefined;
             this.commitLog = undefined;
-            this.cowEnabled = false;
-            // v5.10.4: Create persistent marker object (CRITICAL FIX)
-            // Bug: cowEnabled = false only affects current instance, not future instances
-            // Fix: Create marker object that persists across instance restarts
-            // When new instance calls initializeCOW(), it checks for this marker
-            await this.createClearMarker();
             // Clear the statistics cache
             this.statisticsCache = null;
             this.statisticsModified = false;
@@ -1736,54 +1732,6 @@ export class S3CompatibleStorage extends BaseStorage {
             };
         }
     }
-    /**
-     * Check if COW has been explicitly disabled via clear()
-     * v5.10.4: Fixes bug where clear() doesn't persist across instance restarts
-     * @returns true if marker object exists, false otherwise
-     * @protected
-     */
-    async checkClearMarker() {
-        await this.ensureInitialized();
-        try {
-            const { HeadObjectCommand } = await import('@aws-sdk/client-s3');
-            const markerKey = `${this.systemPrefix}cow-disabled`;
-            await this.s3Client.send(new HeadObjectCommand({
-                Bucket: this.bucketName,
-                Key: markerKey
-            }));
-            return true; // Marker exists
-        }
-        catch (error) {
-            if (error.name === 'NotFound' || error.$metadata?.httpStatusCode === 404) {
-                return false; // Marker doesn't exist
-            }
-            prodLog.warn('S3CompatibleStorage.checkClearMarker: Error checking marker', error);
-            return false;
-        }
-    }
-    /**
-     * Create marker indicating COW has been explicitly disabled
-     * v5.10.4: Called by clear() to prevent COW reinitialization on new instances
-     * @protected
-     */
-    async createClearMarker() {
-        await this.ensureInitialized();
-        try {
-            const { PutObjectCommand } = await import('@aws-sdk/client-s3');
-            const markerKey = `${this.systemPrefix}cow-disabled`;
-            // Create empty marker object
-            await this.s3Client.send(new PutObjectCommand({
-                Bucket: this.bucketName,
-                Key: markerKey,
-                Body: Buffer.from(''),
-                ContentType: 'text/plain'
-            }));
-        }
-        catch (error) {
-            prodLog.error('S3CompatibleStorage.createClearMarker: Failed to create marker object', error);
-            // Don't throw - marker creation failure shouldn't break clear()
-        }
-    }
     /**
      * Get the statistics key for a specific date
      * @param date The date to get the key for

package/dist/storage/baseStorage.d.ts

@@ -58,7 +58,6 @@ export declare abstract class BaseStorage extends BaseStorageAdapter {
     blobStorage?: BlobStorage;
     commitLog?: CommitLog;
     currentBranch: string;
-    protected cowEnabled: boolean;
     protected nounCountsByType: Uint32Array<ArrayBuffer>;
     protected verbCountsByType: Uint32Array<ArrayBuffer>;
     protected nounTypeCache: Map<string, NounType>;
@@ -88,6 +87,8 @@ export declare abstract class BaseStorage extends BaseStorageAdapter {
      * Called during init() to ensure all data is stored with branch prefixes from the start
      * RefManager/BlobStorage/CommitLog are lazy-initialized on first fork()
      * @param branch - Branch name to use (default: 'main')
+     *
+     * v5.11.0: COW is always enabled - this method now just sets the branch name (idempotent)
      */
     enableCOWLightweight(branch?: string): void;
     /**
@@ -119,6 +120,8 @@ export declare abstract class BaseStorage extends BaseStorageAdapter {
      * Read object with inheritance from parent branches (COW layer)
      * Tries current branch first, then walks commit history
      * @protected - Available to subclasses for COW implementation
+     *
+     * v5.11.0: COW is always enabled - always use branch-scoped paths with inheritance
      */
     protected readWithInheritance(path: string, branch?: string): Promise<any | null>;
     /**
@@ -137,6 +140,8 @@ export declare abstract class BaseStorage extends BaseStorageAdapter {
      * This enables fork to see parent's data in pagination operations
      *
      * Simplified approach: All branches inherit from main
+     *
+     * v5.11.0: COW is always enabled - always use inheritance
      */
     protected listObjectsWithInheritance(prefix: string, branch?: string): Promise<string[]>;
     /**
@@ -328,20 +333,9 @@ export declare abstract class BaseStorage extends BaseStorageAdapter {
      */
     abstract clear(): Promise<void>;
     /**
-     * Check if COW has been explicitly disabled via clear()
-     * v5.10.4: Fixes bug where clear() doesn't persist across instance restarts
-     * Each adapter checks for a marker file/object (e.g., "_system/cow-disabled")
-     * @returns true if COW was disabled by clear(), false otherwise
-     * @protected
-     */
-    protected abstract checkClearMarker(): Promise<boolean>;
-    /**
-     * Create marker indicating COW has been explicitly disabled
-     * v5.10.4: Called by clear() to prevent COW reinitialization on new instances
-     * Each adapter creates a marker file/object (e.g., "_system/cow-disabled")
-     * @protected
+     * v5.11.0: Removed checkClearMarker() and createClearMarker() abstract methods
+     * COW is now always enabled - marker files are no longer used
      */
-    protected abstract createClearMarker(): Promise<void>;
     /**
      * Get information about storage usage and capacity
      * This method should be implemented by each specific adapter

package/dist/storage/baseStorage.js

@@ -83,7 +83,7 @@ export class BaseStorage extends BaseStorageAdapter {
         // Memory footprint: Bounded by batch size (typically <1000 items during imports)
         this.writeCache = new Map();
         this.currentBranch = 'main';
-        this.cowEnabled = false;
+        // v5.11.0: Removed cowEnabled flag - COW is ALWAYS enabled (mandatory, cannot be disabled)
         // Type-first indexing support (v5.4.0)
         // Built into all storage adapters for billion-scale efficiency
         this.nounCountsByType = new Uint32Array(NOUN_TYPE_COUNT); // 168 bytes (Stage 3: 42 types)
@@ -191,13 +191,11 @@ export class BaseStorage extends BaseStorageAdapter {
      * Called during init() to ensure all data is stored with branch prefixes from the start
      * RefManager/BlobStorage/CommitLog are lazy-initialized on first fork()
      * @param branch - Branch name to use (default: 'main')
+     *
+     * v5.11.0: COW is always enabled - this method now just sets the branch name (idempotent)
      */
     enableCOWLightweight(branch = 'main') {
-        if (this.cowEnabled) {
-            return;
-        }
         this.currentBranch = branch;
-        this.cowEnabled = true;
         // RefManager/BlobStorage/CommitLog remain undefined until first fork()
     }
     /**
@@ -212,27 +210,15 @@ export class BaseStorage extends BaseStorageAdapter {
      * @returns Promise that resolves when COW is initialized
      */
     async initializeCOW(options) {
-        // v5.10.4: Check for persistent marker file (CRITICAL FIX)
-        // Bug: Setting cowEnabled = false on OLD instance doesn't affect NEW instances
-        // Fix: Check storage for persistent marker created by clear()
-        // If marker exists, COW was explicitly disabled and should NOT reinitialize
-        const markerExists = await this.checkClearMarker();
-        if (markerExists) {
-            return; // COW was disabled by clear() - don't recreate _cow/ directory
-        }
-        // v5.6.1: If COW was explicitly disabled (e.g., via clear()), don't reinitialize
-        // This prevents automatic recreation of COW data after clear() operations
-        if (this.cowEnabled === false) {
+        // v5.11.0: COW is ALWAYS enabled - idempotent initialization only
+        // Removed marker file check (cowEnabled flag removed, COW is mandatory)
+        // Check if RefManager already initialized (idempotent)
+        if (this.refManager && this.blobStorage && this.commitLog) {
             return;
         }
-        // Check if RefManager already initialized (full COW setup complete)
-        if (this.refManager) {
-            return;
-        }
-        // Enable lightweight COW if not already enabled
-        if (!this.cowEnabled) {
-            this.currentBranch = options?.branch || 'main';
-            this.cowEnabled = true;
+        // Set current branch if provided
+        if (options?.branch) {
+            this.currentBranch = options.branch;
         }
         // Create COWStorageAdapter bridge
         // This adapts BaseStorage's methods to the simple key-value interface
@@ -334,7 +320,7 @@ export class BaseStorage extends BaseStorageAdapter {
                 await this.refManager.setHead(this.currentBranch);
             }
         }
-        this.cowEnabled = true;
+        // v5.11.0: COW is always enabled - no flag to set
     }
     /**
      * Resolve branch-scoped path for COW isolation
@@ -348,9 +334,7 @@ export class BaseStorage extends BaseStorageAdapter {
         if (basePath.startsWith('_cow/')) {
             return basePath; // COW metadata is global across all branches
         }
-        if (!this.cowEnabled) {
-            return basePath; // COW disabled, use direct path
-        }
+        // v5.11.0: COW is always enabled - always use branch-scoped paths
         const targetBranch = branch || this.currentBranch || 'main';
         // Branch-scoped path: branches/<branch>/<basePath>
         return `branches/${targetBranch}/${basePath}`;
@@ -374,17 +358,10 @@ export class BaseStorage extends BaseStorageAdapter {
      * Read object with inheritance from parent branches (COW layer)
      * Tries current branch first, then walks commit history
      * @protected - Available to subclasses for COW implementation
+     *
+     * v5.11.0: COW is always enabled - always use branch-scoped paths with inheritance
      */
     async readWithInheritance(path, branch) {
-        if (!this.cowEnabled) {
-            // COW disabled: check write cache, then direct read
-            // v5.7.2: Check cache first for read-after-write consistency
-            const cachedData = this.writeCache.get(path);
-            if (cachedData !== undefined) {
-                return cachedData;
-            }
-            return this.readObjectFromPath(path);
-        }
         const targetBranch = branch || this.currentBranch || 'main';
         const branchPath = this.resolveBranchPath(path, targetBranch);
         // v5.7.2: Check write cache FIRST (synchronous, instant)
@@ -461,11 +438,10 @@ export class BaseStorage extends BaseStorageAdapter {
      * This enables fork to see parent's data in pagination operations
      *
      * Simplified approach: All branches inherit from main
+     *
+     * v5.11.0: COW is always enabled - always use inheritance
      */
     async listObjectsWithInheritance(prefix, branch) {
-        if (!this.cowEnabled) {
-            return this.listObjectsInBranch(prefix, branch);
-        }
         const targetBranch = branch || this.currentBranch || 'main';
         // Collect paths from current branch
         const pathsSet = new Set();

package/dist/storage/cow/CommitLog.d.ts

@@ -115,6 +115,30 @@ export declare class CommitLog {
         since?: number;
         until?: number;
     }): Promise<CommitObject[]>;
+    /**
+     * Stream commit history (memory-efficient for large histories)
+     *
+     * Yields commits one at a time without accumulating in memory.
+     * Use this for large commit histories (1000s of commits) where
+     * memory efficiency is important.
+     *
+     * @param ref - Starting ref
+     * @param options - Walk options
+     * @yields Commits in reverse chronological order (newest first)
+     *
+     * @example
+     * ```typescript
+     * // Stream all commits without memory accumulation
+     * for await (const commit of commitLog.streamHistory('main', { maxCount: 10000 })) {
+     *   console.log(commit.message)
+     * }
+     * ```
+     */
+    streamHistory(ref: string, options?: {
+        maxCount?: number;
+        since?: number;
+        until?: number;
+    }): AsyncIterableIterator<CommitObject>;
     /**
      * Count commits between two commits
      *

package/dist/storage/cow/CommitLog.js

@@ -183,6 +183,43 @@ export class CommitLog {
         }
         return commits;
     }
+    /**
+     * Stream commit history (memory-efficient for large histories)
+     *
+     * Yields commits one at a time without accumulating in memory.
+     * Use this for large commit histories (1000s of commits) where
+     * memory efficiency is important.
+     *
+     * @param ref - Starting ref
+     * @param options - Walk options
+     * @yields Commits in reverse chronological order (newest first)
+     *
+     * @example
+     * ```typescript
+     * // Stream all commits without memory accumulation
+     * for await (const commit of commitLog.streamHistory('main', { maxCount: 10000 })) {
+     *   console.log(commit.message)
+     * }
+     * ```
+     */
+    async *streamHistory(ref, options) {
+        let count = 0;
+        for await (const commit of this.walk(ref, {
+            maxDepth: options?.maxCount,
+            until: options?.until
+        })) {
+            // Filter by since timestamp if provided
+            if (options?.since && commit.timestamp < options.since) {
+                continue;
+            }
+            yield commit;
+            count++;
+            // Stop after maxCount commits
+            if (options?.maxCount && count >= options.maxCount) {
+                break;
+            }
+        }
+    }
     /**
      * Count commits between two commits
      *

package/dist/types/brainy.types.d.ts

@@ -494,6 +494,8 @@ export interface BrainyConfig {
     disableAutoOptimize?: boolean;
     batchWrites?: boolean;
     maxConcurrentOperations?: number;
+    maxQueryLimit?: number;
+    reservedQueryMemory?: number;
     verbose?: boolean;
     silent?: boolean;
 }

package/dist/utils/paramValidation.d.ts

@@ -5,6 +5,49 @@
  * Only enforces universal truths, learns everything else
  */
 import { FindParams, AddParams, UpdateParams, RelateParams } from '../types/brainy.types.js';
+/**
+ * Configuration options for ValidationConfig
+ */
+export interface ValidationConfigOptions {
+    /**
+     * Explicit maximum query limit override
+     * Bypasses all auto-detection
+     */
+    maxQueryLimit?: number;
+    /**
+     * Memory reserved for query operations (in bytes)
+     * Bypasses auto-detection but still applies safety limits
+     */
+    reservedQueryMemory?: number;
+}
+/**
+ * Auto-configured limits based on system resources
+ * These adapt to available memory and observed performance
+ */
+export declare class ValidationConfig {
+    private static instance;
+    maxLimit: number;
+    maxQueryLength: number;
+    maxVectorDimensions: number;
+    limitBasis: 'override' | 'reservedMemory' | 'containerMemory' | 'freeMemory';
+    detectedContainerLimit: number | null;
+    private avgQueryTime;
+    private queryCount;
+    private constructor();
+    static getInstance(options?: ValidationConfigOptions): ValidationConfig;
+    /**
+     * Reset singleton (for testing or reconfiguration)
+     */
+    static reset(): void;
+    /**
+     * Reconfigure with new options
+     */
+    static reconfigure(options: ValidationConfigOptions): ValidationConfig;
+    /**
+     * Learn from actual usage to adjust limits
+     */
+    recordQuery(duration: number, resultCount: number): void;
+}
 /**
  * Universal validations - things that are always invalid
  * These are mathematical/logical truths, not configuration