@soulcraft/brainy 5.10.4 → 5.11.0

package/dist/brainy.d.ts

@@ -1009,6 +1009,51 @@ export declare class Brainy<T = any> implements BrainyInterface<T> {
         timestamp: number;
         metadata?: Record<string, any>;
     }>>;
+    /**
+     * Stream commit history (memory-efficient)
+     *
+     * Use this for large commit histories (1000s of snapshots) where memory
+     * efficiency is critical. Yields commits one at a time without accumulating
+     * them in memory.
+     *
+     * For small histories (< 100 commits), use getHistory() for simpler API.
+     *
+     * @param options - History options
+     * @param options.limit - Maximum number of commits to stream
+     * @param options.since - Only include commits after this timestamp
+     * @param options.until - Only include commits before this timestamp
+     * @param options.author - Filter by author name
+     *
+     * @yields Commit metadata in reverse chronological order (newest first)
+     *
+     * @example
+     * ```typescript
+     * // Stream all commits without memory accumulation
+     * for await (const commit of brain.streamHistory({ limit: 10000 })) {
+     *   console.log(`${commit.timestamp}: ${commit.message}`)
+     * }
+     *
+     * // Stream with filtering
+     * for await (const commit of brain.streamHistory({
+     *   author: 'alice',
+     *   since: Date.now() - 86400000  // Last 24 hours
+     * })) {
+     *   // Process commit
+     * }
+     * ```
+     */
+    streamHistory(options?: {
+        limit?: number;
+        since?: number;
+        until?: number;
+        author?: string;
+    }): AsyncIterableIterator<{
+        hash: string;
+        message: string;
+        author: string;
+        timestamp: number;
+        metadata?: Record<string, any>;
+    }>;
     /**
      * Get total count of nouns - O(1) operation
      * @returns Promise that resolves to the total number of nouns
@@ -1019,6 +1064,50 @@ export declare class Brainy<T = any> implements BrainyInterface<T> {
      * @returns Promise that resolves to the total number of verbs
      */
     getVerbCount(): Promise<number>;
+    /**
+     * Get memory statistics and limits (v5.11.0)
+     *
+     * Returns detailed memory information including:
+     * - Current heap usage
+     * - Container memory limits (if detected)
+     * - Query limits and how they were calculated
+     * - Memory allocation recommendations
+     *
+     * Use this to debug why query limits are low or to understand
+     * memory allocation in production environments.
+     *
+     * @returns Memory statistics and configuration
+     *
+     * @example
+     * ```typescript
+     * const stats = brain.getMemoryStats()
+     * console.log(`Query limit: ${stats.limits.maxQueryLimit}`)
+     * console.log(`Basis: ${stats.limits.basis}`)
+     * console.log(`Free memory: ${Math.round(stats.memory.free / 1024 / 1024)}MB`)
+     * ```
+     */
+    getMemoryStats(): {
+        memory: {
+            heapUsed: number;
+            heapTotal: number;
+            external: number;
+            rss: number;
+            free: number;
+            total: number;
+            containerLimit: number | null;
+        };
+        limits: {
+            maxQueryLimit: number;
+            maxQueryLength: number;
+            maxVectorDimensions: number;
+            basis: 'override' | 'reservedMemory' | 'containerMemory' | 'freeMemory';
+        };
+        config: {
+            maxQueryLimit?: number;
+            reservedQueryMemory?: number;
+        };
+        recommendations?: string[];
+    };
     /**
      * Neural API - Advanced AI operations
      */

package/dist/brainy.js

@@ -25,6 +25,7 @@ import { NULL_HASH } from './storage/cow/constants.js';
 import { createPipeline } from './streaming/pipeline.js';
 import { configureLogger, LogLevel } from './utils/logger.js';
 import { TransactionManager } from './transaction/TransactionManager.js';
+import { ValidationConfig } from './utils/paramValidation.js';
 import { SaveNounMetadataOperation, SaveNounOperation, AddToTypeAwareHNSWOperation, AddToHNSWOperation, AddToMetadataIndexOperation, SaveVerbMetadataOperation, SaveVerbOperation, AddToGraphIndexOperation, RemoveFromHNSWOperation, RemoveFromTypeAwareHNSWOperation, RemoveFromMetadataIndexOperation, RemoveFromGraphIndexOperation, UpdateNounMetadataOperation, DeleteNounMetadataOperation, DeleteVerbMetadataOperation } from './transaction/operations/index.js';
 import { DistributedCoordinator, ShardManager, CacheSync, ReadWriteSeparation } from './distributed/index.js';
 import { NounType } from './types/graphTypes.js';
@@ -45,6 +46,14 @@ export class Brainy {
         this.lazyRebuildPromise = null;
         // Normalize configuration with defaults
         this.config = this.normalizeConfig(config);
+        // Configure memory limits (v5.11.0)
+        // This must happen early, before any validation occurs
+        if (this.config.maxQueryLimit !== undefined || this.config.reservedQueryMemory !== undefined) {
+            ValidationConfig.reconfigure({
+                maxQueryLimit: this.config.maxQueryLimit,
+                reservedQueryMemory: this.config.reservedQueryMemory
+            });
+        }
         // Setup core components
         this.distance = cosineDistance;
         this.embedder = this.setupEmbedder();
@@ -2688,6 +2697,67 @@ export class Brainy {
             }));
         });
     }
+    /**
+     * Stream commit history (memory-efficient)
+     *
+     * Use this for large commit histories (1000s of snapshots) where memory
+     * efficiency is critical. Yields commits one at a time without accumulating
+     * them in memory.
+     *
+     * For small histories (< 100 commits), use getHistory() for simpler API.
+     *
+     * @param options - History options
+     * @param options.limit - Maximum number of commits to stream
+     * @param options.since - Only include commits after this timestamp
+     * @param options.until - Only include commits before this timestamp
+     * @param options.author - Filter by author name
+     *
+     * @yields Commit metadata in reverse chronological order (newest first)
+     *
+     * @example
+     * ```typescript
+     * // Stream all commits without memory accumulation
+     * for await (const commit of brain.streamHistory({ limit: 10000 })) {
+     *   console.log(`${commit.timestamp}: ${commit.message}`)
+     * }
+     *
+     * // Stream with filtering
+     * for await (const commit of brain.streamHistory({
+     *   author: 'alice',
+     *   since: Date.now() - 86400000  // Last 24 hours
+     * })) {
+     *   // Process commit
+     * }
+     * ```
+     */
+    async *streamHistory(options) {
+        await this.ensureInitialized();
+        if (!('commitLog' in this.storage) || !('refManager' in this.storage)) {
+            throw new Error('History streaming requires COW-enabled storage (v5.0.0+)');
+        }
+        const commitLog = this.storage.commitLog;
+        const currentBranch = await this.getCurrentBranch();
+        const blobStorage = this.storage.blobStorage;
+        // Stream commits from CommitLog
+        for await (const commit of commitLog.streamHistory(currentBranch, {
+            maxCount: options?.limit,
+            since: options?.since,
+            until: options?.until
+        })) {
+            // Filter by author if specified
+            if (options?.author && commit.author !== options.author) {
+                continue;
+            }
+            // Map to expected format (compute hash for commit)
+            yield {
+                hash: blobStorage.constructor.hash(Buffer.from(JSON.stringify(commit))),
+                message: commit.message,
+                author: commit.author,
+                timestamp: commit.timestamp,
+                metadata: commit.metadata
+            };
+        }
+    }
     /**
      * Get total count of nouns - O(1) operation
      * @returns Promise that resolves to the total number of nouns
@@ -2704,6 +2774,86 @@ export class Brainy {
         await this.ensureInitialized();
         return this.storage.getVerbCount();
     }
+    /**
+     * Get memory statistics and limits (v5.11.0)
+     *
+     * Returns detailed memory information including:
+     * - Current heap usage
+     * - Container memory limits (if detected)
+     * - Query limits and how they were calculated
+     * - Memory allocation recommendations
+     *
+     * Use this to debug why query limits are low or to understand
+     * memory allocation in production environments.
+     *
+     * @returns Memory statistics and configuration
+     *
+     * @example
+     * ```typescript
+     * const stats = brain.getMemoryStats()
+     * console.log(`Query limit: ${stats.limits.maxQueryLimit}`)
+     * console.log(`Basis: ${stats.limits.basis}`)
+     * console.log(`Free memory: ${Math.round(stats.memory.free / 1024 / 1024)}MB`)
+     * ```
+     */
+    getMemoryStats() {
+        const config = ValidationConfig.getInstance();
+        const heapStats = process.memoryUsage ? process.memoryUsage() : {
+            heapUsed: 0,
+            heapTotal: 0,
+            external: 0,
+            rss: 0
+        };
+        // Get system memory info
+        let freeMemory = 0;
+        let totalMemory = 0;
+        if (typeof window === 'undefined') {
+            try {
+                const os = require('node:os');
+                freeMemory = os.freemem();
+                totalMemory = os.totalmem();
+            }
+            catch (e) {
+                // OS module not available
+            }
+        }
+        const stats = {
+            memory: {
+                heapUsed: heapStats.heapUsed,
+                heapTotal: heapStats.heapTotal,
+                external: heapStats.external,
+                rss: heapStats.rss,
+                free: freeMemory,
+                total: totalMemory,
+                containerLimit: config.detectedContainerLimit
+            },
+            limits: {
+                maxQueryLimit: config.maxLimit,
+                maxQueryLength: config.maxQueryLength,
+                maxVectorDimensions: config.maxVectorDimensions,
+                basis: config.limitBasis
+            },
+            config: {
+                maxQueryLimit: this.config.maxQueryLimit,
+                reservedQueryMemory: this.config.reservedQueryMemory
+            },
+            recommendations: []
+        };
+        // Generate recommendations based on stats
+        if (stats.limits.basis === 'freeMemory' && stats.memory.containerLimit) {
+            stats.recommendations.push(`Container detected (${Math.round(stats.memory.containerLimit / 1024 / 1024)}MB) but limits based on free memory. ` +
+                `Consider setting reservedQueryMemory config option for better limits.`);
+        }
+        if (stats.limits.maxQueryLimit < 5000 && stats.memory.containerLimit && stats.memory.containerLimit > 2 * 1024 * 1024 * 1024) {
+            stats.recommendations.push(`Query limit is low (${stats.limits.maxQueryLimit}) despite ${Math.round(stats.memory.containerLimit / 1024 / 1024 / 1024)}GB container. ` +
+                `Consider: new Brainy({ reservedQueryMemory: 1073741824 }) to reserve 1GB for queries.`);
+        }
+        if (stats.limits.basis === 'override') {
+            stats.recommendations.push(`Using explicit maxQueryLimit override (${stats.limits.maxQueryLimit}). ` +
+                `Auto-detection bypassed.`);
+        }
+        return stats;
+    }
     // ============= SUB-APIS =============
     /**
      * Neural API - Advanced AI operations
@@ -3993,7 +4143,10 @@ export class Brainy {
             disableMetrics: config?.disableMetrics ?? false,
             disableAutoOptimize: config?.disableAutoOptimize ?? false,
             batchWrites: config?.batchWrites ?? true,
-            maxConcurrentOperations: config?.maxConcurrentOperations ?? 10
+            maxConcurrentOperations: config?.maxConcurrentOperations ?? 10,
+            // Memory management options (v5.11.0)
+            maxQueryLimit: config?.maxQueryLimit ?? undefined,
+            reservedQueryMemory: config?.reservedQueryMemory ?? undefined
         };
     }
     /**

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

@@ -246,13 +246,10 @@ export declare class AzureBlobStorage extends BaseStorage {
      * @returns true if marker blob 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>;
     /**
      * Save statistics data to storage
      */

package/dist/storage/adapters/azureBlobStorage.js

@@ -859,18 +859,11 @@ export class AzureBlobStorage extends BaseStorage {
                     await blockBlobClient.delete();
                 }
             }
-            // 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 blob (CRITICAL FIX)
-            // Bug: cowEnabled = false only affects current instance, not future instances
-            // Fix: Create marker blob that persists across instance restarts
-            // When new instance calls initializeCOW(), it checks for this marker
-            await this.createClearMarker();
             // Clear caches
             this.nounCacheManager.clear();
             this.verbCacheManager.clear();
@@ -919,39 +912,10 @@ export class AzureBlobStorage extends BaseStorage {
      * @returns true if marker blob exists, false otherwise
      * @protected
      */
-    async checkClearMarker() {
-        await this.ensureInitialized();
-        try {
-            const markerPath = `${this.systemPrefix}cow-disabled`;
-            const blockBlobClient = this.containerClient.getBlockBlobClient(markerPath);
-            const exists = await blockBlobClient.exists();
-            return exists;
-        }
-        catch (error) {
-            this.logger.warn('AzureBlobStorage.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
+     * v5.11.0: Removed checkClearMarker() and createClearMarker() methods
+     * COW is now always enabled - marker files are no longer used
      */
-    async createClearMarker() {
-        await this.ensureInitialized();
-        try {
-            const markerPath = `${this.systemPrefix}cow-disabled`;
-            const blockBlobClient = this.containerClient.getBlockBlobClient(markerPath);
-            // Create empty marker blob
-            await blockBlobClient.upload(Buffer.from(''), 0, {
-                blobHTTPHeaders: { blobContentType: 'text/plain' }
-            });
-        }
-        catch (error) {
-            this.logger.error('AzureBlobStorage.createClearMarker: Failed to create marker blob', error);
-            // Don't throw - marker creation failure shouldn't break clear()
-        }
-    }
     /**
      * Save statistics data to storage
      */

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

@@ -177,13 +177,10 @@ export declare class FileSystemStorage extends BaseStorage {
      * @returns true if marker file 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>;
     /**
      * Get information about storage usage and capacity
      */

package/dist/storage/adapters/fileSystemStorage.js

@@ -878,18 +878,11 @@ export class FileSystemStorage extends BaseStorage {
         if (await this.directoryExists(cowDir)) {
             // Delete the entire _cow/ directory (not just contents)
             await fs.promises.rm(cowDir, { recursive: true, force: 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();
         }
         // Clear the statistics cache
         this.statisticsCache = null;
@@ -923,41 +916,10 @@ export class FileSystemStorage extends BaseStorage {
      * @returns true if marker file exists, false otherwise
      * @protected
      */
-    async checkClearMarker() {
-        // Check if fs module is available
-        if (!fs || !fs.promises) {
-            return false;
-        }
-        try {
-            const markerPath = path.join(this.systemDir, 'cow-disabled');
-            await fs.promises.access(markerPath, fs.constants.F_OK);
-            return true; // Marker exists
-        }
-        catch (error) {
-            return false; // Marker doesn't exist (ENOENT) or can't be accessed
-        }
-    }
     /**
-     * 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
      */
-    async createClearMarker() {
-        // Check if fs module is available
-        if (!fs || !fs.promises) {
-            console.warn('FileSystemStorage.createClearMarker: fs module not available, skipping marker creation');
-            return;
-        }
-        try {
-            const markerPath = path.join(this.systemDir, 'cow-disabled');
-            // Create empty marker file
-            await fs.promises.writeFile(markerPath, '', 'utf8');
-        }
-        catch (error) {
-            console.error('FileSystemStorage.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/gcsStorage.d.ts

@@ -234,13 +234,10 @@ export declare class GcsStorage 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>;
     /**
      * Save statistics data to storage
      */

package/dist/storage/adapters/gcsStorage.js

@@ -772,28 +772,18 @@ export class GcsStorage extends BaseStorage {
                     await file.delete();
                 }
             };
-            // Clear all data directories
-            await deleteObjectsWithPrefix(this.nounPrefix);
-            await deleteObjectsWithPrefix(this.verbPrefix);
-            await deleteObjectsWithPrefix(this.metadataPrefix);
-            await deleteObjectsWithPrefix(this.verbMetadataPrefix);
-            await deleteObjectsWithPrefix(this.systemPrefix);
-            // v5.6.1: Clear 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 caches
             this.nounCacheManager.clear();
             this.verbCacheManager.clear();
@@ -845,37 +835,10 @@ export class GcsStorage extends BaseStorage {
      * @returns true if marker object exists, false otherwise
      * @protected
      */
-    async checkClearMarker() {
-        await this.ensureInitialized();
-        try {
-            const markerPath = `${this.systemPrefix}cow-disabled`;
-            const file = this.bucket.file(markerPath);
-            const [exists] = await file.exists();
-            return exists;
-        }
-        catch (error) {
-            this.logger.warn('GCSStorage.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
+     * v5.11.0: Removed checkClearMarker() and createClearMarker() methods
+     * COW is now always enabled - marker files are no longer used
      */
-    async createClearMarker() {
-        await this.ensureInitialized();
-        try {
-            const markerPath = `${this.systemPrefix}cow-disabled`;
-            const file = this.bucket.file(markerPath);
-            // Create empty marker object
-            await file.save('', { contentType: 'text/plain' });
-        }
-        catch (error) {
-            this.logger.error('GCSStorage.createClearMarker: Failed to create marker object', error);
-            // Don't throw - marker creation failure shouldn't break clear()
-        }
-    }
     /**
      * Save statistics data to storage
      */

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

@@ -107,13 +107,10 @@ export declare class HistoricalStorageAdapter extends BaseStorage {
      * @returns Always false (read-only adapter doesn't manage COW state)
      * @protected
      */
-    protected checkClearMarker(): Promise<boolean>;
     /**
-     * Create marker indicating COW has been explicitly disabled
-     * v5.10.4: No-op for HistoricalStorageAdapter (read-only)
-     * @protected
+     * v5.11.0: Removed checkClearMarker() and createClearMarker() methods
+     * COW is now always enabled - marker files are no longer used
      */
-    protected createClearMarker(): Promise<void>;
     /**
      * WRITE BLOCKED: Historical storage is read-only
      */

package/dist/storage/adapters/historicalStorageAdapter.js

@@ -232,17 +232,10 @@ export class HistoricalStorageAdapter extends BaseStorage {
      * @returns Always false (read-only adapter doesn't manage COW state)
      * @protected
      */
-    async checkClearMarker() {
-        return false; // Read-only adapter - COW state managed by underlying storage
-    }
     /**
-     * Create marker indicating COW has been explicitly disabled
-     * v5.10.4: No-op for HistoricalStorageAdapter (read-only)
-     * @protected
+     * v5.11.0: Removed checkClearMarker() and createClearMarker() methods
+     * COW is now always enabled - marker files are no longer used
      */
-    async createClearMarker() {
-        // No-op: HistoricalStorageAdapter is read-only, doesn't create markers
-    }
     // ============= Override Write Methods (Read-Only) =============
     /**
      * WRITE BLOCKED: Historical storage is read-only

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

@@ -85,13 +85,10 @@ export declare class MemoryStorage extends BaseStorage {
      * @returns Always false (marker doesn't persist in memory)
      * @protected
      */
-    protected checkClearMarker(): Promise<boolean>;
     /**
-     * Create marker indicating COW has been explicitly disabled
-     * v5.10.4: No-op for MemoryStorage (doesn't persist)
-     * @protected
+     * v5.11.0: Removed checkClearMarker() and createClearMarker() methods
+     * COW is now always enabled - marker files are no longer used
      */
-    protected createClearMarker(): Promise<void>;
     /**
      * Save statistics data to storage
      * @param statistics The statistics data to save

package/dist/storage/adapters/memoryStorage.js

@@ -164,18 +164,10 @@ export class MemoryStorage extends BaseStorage {
      * @returns Always false (marker doesn't persist in memory)
      * @protected
      */
-    async checkClearMarker() {
-        return false; // MemoryStorage doesn't persist - marker doesn't survive restart
-    }
     /**
-     * Create marker indicating COW has been explicitly disabled
-     * v5.10.4: No-op for MemoryStorage (doesn't persist)
-     * @protected
+     * v5.11.0: Removed checkClearMarker() and createClearMarker() methods
+     * COW is now always enabled - marker files are no longer used
      */
-    async createClearMarker() {
-        // No-op: MemoryStorage doesn't persist, so marker is not needed
-        // clear() in memory already resets all state, no marker survives restart
-    }
     /**
      * Save statistics data to storage
      * @param statistics The statistics data to save

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

@@ -100,13 +100,10 @@ export declare class OPFSStorage extends BaseStorage {
      * @returns true if marker file 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>;
     private quotaWarningThreshold;
     private quotaCriticalThreshold;
     private lastQuotaCheck;