@soulcraft/brainy 5.7.12 → 5.8.0

package/dist/graph/graphAdjacencyIndex.js

@@ -87,11 +87,39 @@ export class GraphAdjacencyIndex {
     }
     /**
      * Core API - Neighbor lookup with LSM-tree storage
-     * Now O(log n) with bloom filter optimization (90% of queries skip disk I/O)
+     *
+     * O(log n) with bloom filter optimization (90% of queries skip disk I/O)
+     * v5.8.0: Added pagination support for high-degree nodes
+     *
+     * @param id Entity ID to get neighbors for
+     * @param optionsOrDirection Optional: direction string OR options object
+     * @returns Array of neighbor IDs (paginated if limit/offset specified)
+     *
+     * @example
+     * // Get all neighbors (backward compatible)
+     * const all = await graphIndex.getNeighbors(id)
+     *
+     * @example
+     * // Get outgoing neighbors (backward compatible)
+     * const out = await graphIndex.getNeighbors(id, 'out')
+     *
+     * @example
+     * // Get first 50 outgoing neighbors (new API)
+     * const page1 = await graphIndex.getNeighbors(id, { direction: 'out', limit: 50 })
+     *
+     * @example
+     * // Paginate through neighbors
+     * const page1 = await graphIndex.getNeighbors(id, { limit: 100, offset: 0 })
+     * const page2 = await graphIndex.getNeighbors(id, { limit: 100, offset: 100 })
      */
-    async getNeighbors(id, direction) {
+    async getNeighbors(id, optionsOrDirection) {
         await this.ensureInitialized();
+        // Normalize old API (direction string) to new API (options object)
+        const options = typeof optionsOrDirection === 'string'
+            ? { direction: optionsOrDirection }
+            : (optionsOrDirection || {});
         const startTime = performance.now();
+        const direction = options.direction || 'both';
         const neighbors = new Set();
         // Query LSM-trees with bloom filter optimization
         if (direction !== 'in') {
@@ -106,7 +134,14 @@ export class GraphAdjacencyIndex {
                 incoming.forEach(neighborId => neighbors.add(neighborId));
             }
         }
-        const result = Array.from(neighbors);
+        // Convert to array for pagination
+        let result = Array.from(neighbors);
+        // Apply pagination if requested (v5.8.0)
+        if (options?.limit !== undefined || options?.offset !== undefined) {
+            const offset = options.offset || 0;
+            const limit = options.limit !== undefined ? options.limit : result.length;
+            result = result.slice(offset, offset + limit);
+        }
         const elapsed = performance.now() - startTime;
         // Performance assertion - should be sub-5ms with LSM-tree
         if (elapsed > 5.0) {
@@ -116,13 +151,31 @@ export class GraphAdjacencyIndex {
     }
     /**
      * Get verb IDs by source - Billion-scale optimization for getVerbsBySource
+     *
      * O(log n) LSM-tree lookup with bloom filter optimization
      * v5.7.1: Filters out deleted verb IDs (tombstone deletion workaround)
+     * v5.8.0: Added pagination support for entities with many relationships
      *
      * @param sourceId Source entity ID
-     * @returns Array of verb IDs originating from this source (excluding deleted)
+     * @param options Optional configuration
+     * @param options.limit Maximum number of verb IDs to return (default: all)
+     * @param options.offset Number of verb IDs to skip (default: 0)
+     * @returns Array of verb IDs originating from this source (excluding deleted, paginated if requested)
+     *
+     * @example
+     * // Get all verb IDs (backward compatible)
+     * const all = await graphIndex.getVerbIdsBySource(sourceId)
+     *
+     * @example
+     * // Get first 50 verb IDs
+     * const page1 = await graphIndex.getVerbIdsBySource(sourceId, { limit: 50 })
+     *
+     * @example
+     * // Paginate through verb IDs
+     * const page1 = await graphIndex.getVerbIdsBySource(sourceId, { limit: 100, offset: 0 })
+     * const page2 = await graphIndex.getVerbIdsBySource(sourceId, { limit: 100, offset: 100 })
      */
-    async getVerbIdsBySource(sourceId) {
+    async getVerbIdsBySource(sourceId, options) {
         await this.ensureInitialized();
         const startTime = performance.now();
         const verbIds = await this.lsmTreeVerbsBySource.get(sourceId);
@@ -134,17 +187,42 @@ export class GraphAdjacencyIndex {
         // Filter out deleted verb IDs (tombstone deletion workaround)
         // LSM-tree retains all IDs, but verbIdSet tracks deletions
         const allIds = verbIds || [];
-        return allIds.filter(id => this.verbIdSet.has(id));
+        let result = allIds.filter(id => this.verbIdSet.has(id));
+        // Apply pagination if requested (v5.8.0)
+        if (options?.limit !== undefined || options?.offset !== undefined) {
+            const offset = options.offset || 0;
+            const limit = options.limit !== undefined ? options.limit : result.length;
+            result = result.slice(offset, offset + limit);
+        }
+        return result;
     }
     /**
      * Get verb IDs by target - Billion-scale optimization for getVerbsByTarget
+     *
      * O(log n) LSM-tree lookup with bloom filter optimization
      * v5.7.1: Filters out deleted verb IDs (tombstone deletion workaround)
+     * v5.8.0: Added pagination support for popular target entities
      *
      * @param targetId Target entity ID
-     * @returns Array of verb IDs pointing to this target (excluding deleted)
+     * @param options Optional configuration
+     * @param options.limit Maximum number of verb IDs to return (default: all)
+     * @param options.offset Number of verb IDs to skip (default: 0)
+     * @returns Array of verb IDs pointing to this target (excluding deleted, paginated if requested)
+     *
+     * @example
+     * // Get all verb IDs (backward compatible)
+     * const all = await graphIndex.getVerbIdsByTarget(targetId)
+     *
+     * @example
+     * // Get first 50 verb IDs
+     * const page1 = await graphIndex.getVerbIdsByTarget(targetId, { limit: 50 })
+     *
+     * @example
+     * // Paginate through verb IDs
+     * const page1 = await graphIndex.getVerbIdsByTarget(targetId, { limit: 100, offset: 0 })
+     * const page2 = await graphIndex.getVerbIdsByTarget(targetId, { limit: 100, offset: 100 })
      */
-    async getVerbIdsByTarget(targetId) {
+    async getVerbIdsByTarget(targetId, options) {
         await this.ensureInitialized();
         const startTime = performance.now();
         const verbIds = await this.lsmTreeVerbsByTarget.get(targetId);
@@ -156,7 +234,14 @@ export class GraphAdjacencyIndex {
         // Filter out deleted verb IDs (tombstone deletion workaround)
         // LSM-tree retains all IDs, but verbIdSet tracks deletions
         const allIds = verbIds || [];
-        return allIds.filter(id => this.verbIdSet.has(id));
+        let result = allIds.filter(id => this.verbIdSet.has(id));
+        // Apply pagination if requested (v5.8.0)
+        if (options?.limit !== undefined || options?.offset !== undefined) {
+            const offset = options.offset || 0;
+            const limit = options.limit !== undefined ? options.limit : result.length;
+            result = result.slice(offset, offset + limit);
+        }
+        return result;
     }
     /**
      * Get verb from cache or storage - Billion-scale memory optimization

package/dist/hnsw/typeAwareHNSWIndex.d.ts

@@ -2,8 +2,8 @@
  * Type-Aware HNSW Index - Phase 2 Billion-Scale Optimization
  *
  * Maintains separate HNSW graphs per entity type for massive memory savings:
- * - Memory @ 1B scale: 384GB → 50GB (-87%)
- * - Query speed: 10x faster for single-type queries
+ * - Memory @ 1B scale: PROJECTED 384GB → 50GB (-87% from architectural analysis, not yet benchmarked)
+ * - Query speed: PROJECTED 10x faster for single-type queries (not yet benchmarked)
  * - Storage: Already type-first from Phase 1a
  *
  * Architecture:
@@ -35,7 +35,7 @@ export interface TypeAwareHNSWStats {
  * TypeAwareHNSWIndex - Separate HNSW graphs per entity type
  *
  * Phase 2 of billion-scale optimization roadmap.
- * Reduces HNSW memory by 87% @ billion scale.
+ * PROJECTED: Reduces HNSW memory by 87% @ billion scale (calculated from architecture, not yet benchmarked).
  */
 export declare class TypeAwareHNSWIndex {
     private indexes;

package/dist/hnsw/typeAwareHNSWIndex.js

@@ -2,8 +2,8 @@
  * Type-Aware HNSW Index - Phase 2 Billion-Scale Optimization
  *
  * Maintains separate HNSW graphs per entity type for massive memory savings:
- * - Memory @ 1B scale: 384GB → 50GB (-87%)
- * - Query speed: 10x faster for single-type queries
+ * - Memory @ 1B scale: PROJECTED 384GB → 50GB (-87% from architectural analysis, not yet benchmarked)
+ * - Query speed: PROJECTED 10x faster for single-type queries (not yet benchmarked)
  * - Storage: Already type-first from Phase 1a
  *
  * Architecture:
@@ -27,7 +27,7 @@ const DEFAULT_CONFIG = {
  * TypeAwareHNSWIndex - Separate HNSW graphs per entity type
  *
  * Phase 2 of billion-scale optimization roadmap.
- * Reduces HNSW memory by 87% @ billion scale.
+ * PROJECTED: Reduces HNSW memory by 87% @ billion scale (calculated from architecture, not yet benchmarked).
  */
 export class TypeAwareHNSWIndex {
     /**

package/dist/query/typeAwareQueryPlanner.d.ts

@@ -5,14 +5,14 @@
  * natural language queries using semantic similarity and routing to specific
  * TypeAwareHNSWIndex graphs.
  *
- * Performance Impact:
+ * Performance Impact (PROJECTED - not yet benchmarked):
  * - Single-type queries: 42x speedup (search 1/42 graphs)
  * - Multi-type queries: 8-21x speedup (search 2-5/42 graphs)
- * - Overall: 40% latency reduction @ 1B scale
+ * - Overall: PROJECTED 40% latency reduction @ 1B scale (calculated from graph reduction, not measured)
  *
  * Examples:
- * - "Find engineers" → single-type → [Person] → 42x speedup
- * - "People at Tesla" → multi-type → [Person, Organization] → 21x speedup
+ * - "Find engineers" → single-type → [Person] → PROJECTED 42x speedup
+ * - "People at Tesla" → multi-type → [Person, Organization] → PROJECTED 21x speedup
  * - "Everything about AI" → all-types → [all 42 types] → no speedup
  */
 import { NounType } from '../types/graphTypes.js';

package/dist/query/typeAwareQueryPlanner.js

@@ -5,14 +5,14 @@
  * natural language queries using semantic similarity and routing to specific
  * TypeAwareHNSWIndex graphs.
  *
- * Performance Impact:
+ * Performance Impact (PROJECTED - not yet benchmarked):
  * - Single-type queries: 42x speedup (search 1/42 graphs)
  * - Multi-type queries: 8-21x speedup (search 2-5/42 graphs)
- * - Overall: 40% latency reduction @ 1B scale
+ * - Overall: PROJECTED 40% latency reduction @ 1B scale (calculated from graph reduction, not measured)
  *
  * Examples:
- * - "Find engineers" → single-type → [Person] → 42x speedup
- * - "People at Tesla" → multi-type → [Person, Organization] → 21x speedup
+ * - "Find engineers" → single-type → [Person] → PROJECTED 42x speedup
+ * - "People at Tesla" → multi-type → [Person, Organization] → PROJECTED 21x speedup
  * - "Everything about AI" → all-types → [all 42 types] → no speedup
  */
 import { NounType, NOUN_TYPE_COUNT } from '../types/graphTypes.js';

package/dist/transaction/Transaction.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Transaction - Atomic Unit of Work
+ *
+ * Executes operations atomically: all succeed or all rollback.
+ * Prevents partial failures that leave system in inconsistent state.
+ *
+ * Usage:
+ * ```typescript
+ * const tx = new Transaction()
+ * tx.addOperation(operation1)
+ * tx.addOperation(operation2)
+ * await tx.execute() // Both succeed or both rollback
+ * ```
+ */
+import { Operation, TransactionState, TransactionContext, TransactionOptions } from './types.js';
+/**
+ * Transaction class
+ */
+export declare class Transaction implements TransactionContext {
+    private operations;
+    private rollbackActions;
+    private state;
+    private readonly options;
+    private startTime?;
+    private endTime?;
+    constructor(options?: TransactionOptions);
+    /**
+     * Add an operation to the transaction
+     */
+    addOperation(operation: Operation): void;
+    /**
+     * Get current transaction state
+     */
+    getState(): TransactionState;
+    /**
+     * Get number of operations in transaction
+     */
+    getOperationCount(): number;
+    /**
+     * Execute all operations atomically
+     */
+    execute(): Promise<void>;
+    /**
+     * Commit the transaction
+     */
+    private commit;
+    /**
+     * Rollback all executed operations in reverse order
+     */
+    private rollback;
+    /**
+     * Get transaction execution time in milliseconds
+     */
+    getExecutionTimeMs(): number | undefined;
+}

package/dist/transaction/Transaction.js

@@ -0,0 +1,175 @@
+/**
+ * Transaction - Atomic Unit of Work
+ *
+ * Executes operations atomically: all succeed or all rollback.
+ * Prevents partial failures that leave system in inconsistent state.
+ *
+ * Usage:
+ * ```typescript
+ * const tx = new Transaction()
+ * tx.addOperation(operation1)
+ * tx.addOperation(operation2)
+ * await tx.execute() // Both succeed or both rollback
+ * ```
+ */
+import { InvalidTransactionStateError, TransactionExecutionError, TransactionRollbackError, TransactionTimeoutError } from './errors.js';
+import { prodLog } from '../utils/logger.js';
+/**
+ * Default transaction options
+ */
+const DEFAULT_OPTIONS = {
+    timeout: 30000, // 30 seconds
+    logging: false,
+    maxRollbackRetries: 3
+};
+/**
+ * Transaction class
+ */
+export class Transaction {
+    constructor(options = {}) {
+        this.operations = [];
+        this.rollbackActions = [];
+        this.state = 'pending';
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+    }
+    /**
+     * Add an operation to the transaction
+     */
+    addOperation(operation) {
+        if (this.state !== 'pending') {
+            throw new InvalidTransactionStateError(this.state, 'add operation');
+        }
+        this.operations.push(operation);
+    }
+    /**
+     * Get current transaction state
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Get number of operations in transaction
+     */
+    getOperationCount() {
+        return this.operations.length;
+    }
+    /**
+     * Execute all operations atomically
+     */
+    async execute() {
+        if (this.state !== 'pending') {
+            throw new InvalidTransactionStateError(this.state, 'execute');
+        }
+        this.state = 'executing';
+        this.startTime = Date.now();
+        if (this.options.logging) {
+            prodLog.info(`[Transaction] Executing ${this.operations.length} operations`);
+        }
+        try {
+            // Execute each operation in order
+            for (let i = 0; i < this.operations.length; i++) {
+                // Check timeout
+                if (Date.now() - this.startTime > this.options.timeout) {
+                    throw new TransactionTimeoutError(this.options.timeout, i);
+                }
+                const operation = this.operations[i];
+                try {
+                    if (this.options.logging) {
+                        prodLog.info(`[Transaction] Executing operation ${i}: ${operation.name || 'unnamed'}`);
+                    }
+                    // Execute operation
+                    const rollbackAction = await operation.execute();
+                    // Record rollback action (if provided)
+                    if (rollbackAction) {
+                        this.rollbackActions.push(rollbackAction);
+                    }
+                }
+                catch (error) {
+                    // Operation failed - rollback and re-throw
+                    const executionError = new TransactionExecutionError(`Operation ${i} failed: ${error.message}`, i, operation.name, error);
+                    await this.rollback(executionError);
+                    throw executionError;
+                }
+            }
+            // All operations succeeded - commit
+            this.commit();
+        }
+        catch (error) {
+            // Error already handled in rollback
+            throw error;
+        }
+    }
+    /**
+     * Commit the transaction
+     */
+    commit() {
+        this.state = 'committed';
+        this.endTime = Date.now();
+        if (this.options.logging) {
+            const duration = this.endTime - (this.startTime || this.endTime);
+            prodLog.info(`[Transaction] Committed successfully in ${duration}ms`);
+        }
+        // Clear rollback actions - no longer needed
+        this.rollbackActions = [];
+    }
+    /**
+     * Rollback all executed operations in reverse order
+     */
+    async rollback(originalError) {
+        this.state = 'rolling_back';
+        if (this.options.logging) {
+            prodLog.info(`[Transaction] Rolling back ${this.rollbackActions.length} operations`);
+        }
+        const rollbackErrors = [];
+        // Execute rollback actions in REVERSE order
+        for (let i = this.rollbackActions.length - 1; i >= 0; i--) {
+            const action = this.rollbackActions[i];
+            // Retry rollback with exponential backoff
+            let attempts = 0;
+            let success = false;
+            while (attempts < this.options.maxRollbackRetries && !success) {
+                try {
+                    await action();
+                    success = true;
+                    if (this.options.logging) {
+                        prodLog.info(`[Transaction] Rolled back operation ${i}`);
+                    }
+                }
+                catch (error) {
+                    attempts++;
+                    if (attempts >= this.options.maxRollbackRetries) {
+                        // Max retries exceeded - log error and continue
+                        const rollbackError = error;
+                        rollbackErrors.push(rollbackError);
+                        prodLog.error(`[Transaction] Rollback failed for operation ${i} after ${attempts} attempts: ${rollbackError.message}`);
+                    }
+                    else {
+                        // Retry with exponential backoff
+                        const delayMs = Math.pow(2, attempts) * 100;
+                        await new Promise(resolve => setTimeout(resolve, delayMs));
+                    }
+                }
+            }
+        }
+        this.state = 'rolled_back';
+        this.endTime = Date.now();
+        if (this.options.logging) {
+            const duration = this.endTime - (this.startTime || this.endTime);
+            prodLog.info(`[Transaction] Rolled back in ${duration}ms`);
+        }
+        // If rollback encountered errors, wrap them with original error
+        if (rollbackErrors.length > 0) {
+            throw new TransactionRollbackError(`Transaction rollback encountered ${rollbackErrors.length} errors during cleanup`, originalError, rollbackErrors);
+        }
+    }
+    /**
+     * Get transaction execution time in milliseconds
+     */
+    getExecutionTimeMs() {
+        if (this.startTime && this.endTime) {
+            return this.endTime - this.startTime;
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=Transaction.js.map

package/dist/transaction/TransactionManager.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Transaction Manager
+ *
+ * Manages transaction execution across the system.
+ * Provides high-level API for executing atomic operations.
+ *
+ * Usage:
+ * ```typescript
+ * const txManager = new TransactionManager()
+ *
+ * const result = await txManager.executeTransaction(async (tx) => {
+ *   tx.addOperation(operation1)
+ *   tx.addOperation(operation2)
+ *   return someValue
+ * })
+ * ```
+ */
+import { TransactionFunction, TransactionResult, TransactionOptions } from './types.js';
+/**
+ * Transaction Manager Statistics
+ */
+export interface TransactionStats {
+    totalTransactions: number;
+    successfulTransactions: number;
+    failedTransactions: number;
+    rolledBackTransactions: number;
+    averageExecutionTimeMs: number;
+    averageOperationsPerTransaction: number;
+}
+/**
+ * Transaction Manager
+ */
+export declare class TransactionManager {
+    private stats;
+    private totalExecutionTime;
+    private totalOperations;
+    /**
+     * Execute a function within a transaction
+     * All operations succeed atomically or all rollback
+     *
+     * @param fn Function that builds and executes transaction
+     * @param options Transaction execution options
+     * @returns Result from user function
+     * @throws TransactionError if transaction fails
+     */
+    executeTransaction<T>(fn: TransactionFunction<T>, options?: TransactionOptions): Promise<T>;
+    /**
+     * Execute a transaction and return detailed result
+     */
+    executeTransactionWithResult<T>(fn: TransactionFunction<T>, options?: TransactionOptions): Promise<TransactionResult<T>>;
+    /**
+     * Get transaction statistics
+     */
+    getStats(): Readonly<TransactionStats>;
+    /**
+     * Reset transaction statistics
+     */
+    resetStats(): void;
+    /**
+     * Update running statistics
+     */
+    private updateStats;
+    /**
+     * Log current statistics
+     */
+    logStats(): void;
+}

package/dist/transaction/TransactionManager.js

@@ -0,0 +1,145 @@
+/**
+ * Transaction Manager
+ *
+ * Manages transaction execution across the system.
+ * Provides high-level API for executing atomic operations.
+ *
+ * Usage:
+ * ```typescript
+ * const txManager = new TransactionManager()
+ *
+ * const result = await txManager.executeTransaction(async (tx) => {
+ *   tx.addOperation(operation1)
+ *   tx.addOperation(operation2)
+ *   return someValue
+ * })
+ * ```
+ */
+import { Transaction } from './Transaction.js';
+import { TransactionError } from './errors.js';
+import { prodLog } from '../utils/logger.js';
+/**
+ * Transaction Manager
+ */
+export class TransactionManager {
+    constructor() {
+        this.stats = {
+            totalTransactions: 0,
+            successfulTransactions: 0,
+            failedTransactions: 0,
+            rolledBackTransactions: 0,
+            averageExecutionTimeMs: 0,
+            averageOperationsPerTransaction: 0
+        };
+        this.totalExecutionTime = 0;
+        this.totalOperations = 0;
+    }
+    /**
+     * Execute a function within a transaction
+     * All operations succeed atomically or all rollback
+     *
+     * @param fn Function that builds and executes transaction
+     * @param options Transaction execution options
+     * @returns Result from user function
+     * @throws TransactionError if transaction fails
+     */
+    async executeTransaction(fn, options) {
+        const transaction = new Transaction(options);
+        this.stats.totalTransactions++;
+        try {
+            // Execute user function (builds operations list)
+            const result = await fn(transaction);
+            // Execute all operations atomically
+            await transaction.execute();
+            // Update statistics
+            this.stats.successfulTransactions++;
+            this.updateStats(transaction);
+            return result;
+        }
+        catch (error) {
+            // Transaction failed and rolled back
+            this.stats.failedTransactions++;
+            if (transaction.getState() === 'rolled_back') {
+                this.stats.rolledBackTransactions++;
+            }
+            this.updateStats(transaction);
+            // Re-throw with context
+            if (error instanceof TransactionError) {
+                throw error;
+            }
+            else {
+                throw new TransactionError(`Transaction failed: ${error.message}`, { cause: error });
+            }
+        }
+    }
+    /**
+     * Execute a transaction and return detailed result
+     */
+    async executeTransactionWithResult(fn, options) {
+        const startTime = Date.now();
+        const transaction = new Transaction(options);
+        try {
+            const value = await fn(transaction);
+            await transaction.execute();
+            const executionTimeMs = Date.now() - startTime;
+            return {
+                value,
+                operationCount: transaction.getOperationCount(),
+                executionTimeMs
+            };
+        }
+        catch (error) {
+            // Transaction failed
+            throw error;
+        }
+    }
+    /**
+     * Get transaction statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Reset transaction statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalTransactions: 0,
+            successfulTransactions: 0,
+            failedTransactions: 0,
+            rolledBackTransactions: 0,
+            averageExecutionTimeMs: 0,
+            averageOperationsPerTransaction: 0
+        };
+        this.totalExecutionTime = 0;
+        this.totalOperations = 0;
+    }
+    /**
+     * Update running statistics
+     */
+    updateStats(transaction) {
+        const executionTime = transaction.getExecutionTimeMs();
+        const operationCount = transaction.getOperationCount();
+        if (executionTime !== undefined) {
+            this.totalExecutionTime += executionTime;
+            this.stats.averageExecutionTimeMs =
+                this.totalExecutionTime / this.stats.totalTransactions;
+        }
+        this.totalOperations += operationCount;
+        this.stats.averageOperationsPerTransaction =
+            this.totalOperations / this.stats.totalTransactions;
+    }
+    /**
+     * Log current statistics
+     */
+    logStats() {
+        prodLog.info('[TransactionManager] Statistics:');
+        prodLog.info(`  Total: ${this.stats.totalTransactions}`);
+        prodLog.info(`  Successful: ${this.stats.successfulTransactions}`);
+        prodLog.info(`  Failed: ${this.stats.failedTransactions}`);
+        prodLog.info(`  Rolled back: ${this.stats.rolledBackTransactions}`);
+        prodLog.info(`  Avg execution time: ${this.stats.averageExecutionTimeMs.toFixed(2)}ms`);
+        prodLog.info(`  Avg operations/tx: ${this.stats.averageOperationsPerTransaction.toFixed(2)}`);
+    }
+}
+//# sourceMappingURL=TransactionManager.js.map