agentdb 3.0.0-alpha.8 → 3.0.0

package/dist/src/coordination/MultiDatabaseCoordinator.js

@@ -1,803 +0,0 @@
-/**
- * MultiDatabaseCoordinator - Cross-Instance Synchronization and Coordination
- *
- * Orchestrates multiple AgentDB instances for distributed vector database operations.
- * Provides:
- * - Instance registration and lifecycle management
- * - Cross-instance synchronization with conflict resolution
- * - Health monitoring and automatic failover
- * - Distributed operations (broadcast insert/delete)
- * - Configurable replication strategies
- *
- * @module coordination/MultiDatabaseCoordinator
- */
-// ============================================================================
-// MultiDatabaseCoordinator Implementation
-// ============================================================================
-/**
- * MultiDatabaseCoordinator - Manages multiple AgentDB instances
- *
- * Provides coordination, synchronization, and health monitoring for
- * distributed vector database deployments.
- *
- * @example
- * ```typescript
- * const coordinator = new MultiDatabaseCoordinator(primaryDb, {
- *   replicationFactor: 2,
- *   syncIntervalMs: 30000,
- *   conflictResolution: 'last-write-wins'
- * });
- *
- * // Register secondary instances
- * coordinator.registerInstance({
- *   id: 'secondary-1',
- *   url: 'http://db1.example.com:8080',
- *   status: 'online',
- *   lastSyncAt: 0,
- *   vectorCount: 0,
- *   version: '2.0.0'
- * });
- *
- * // Start health monitoring
- * coordinator.startHealthCheck(5000);
- *
- * // Sync all instances
- * const results = await coordinator.syncAll();
- * ```
- */
-export class MultiDatabaseCoordinator {
-    primaryDb;
-    instances = new Map();
-    config;
-    healthCheckInterval = null;
-    syncInterval = null;
-    statusChangeCallbacks = [];
-    isSyncing = new Map();
-    vectorTimestamps = new Map();
-    /**
-     * Create a new MultiDatabaseCoordinator
-     *
-     * @param primaryDb - Primary vector database backend
-     * @param config - Configuration options
-     */
-    constructor(primaryDb, config = {}) {
-        this.primaryDb = primaryDb;
-        this.config = {
-            replicationFactor: config.replicationFactor ?? 2,
-            syncIntervalMs: config.syncIntervalMs ?? 30000,
-            conflictResolution: config.conflictResolution ?? 'last-write-wins',
-            healthCheckIntervalMs: config.healthCheckIntervalMs ?? 10000,
-            healthCheckTimeoutMs: config.healthCheckTimeoutMs ?? 5000,
-            autoFailover: config.autoFailover ?? true,
-            maxRetries: config.maxRetries ?? 3,
-            retryDelayMs: config.retryDelayMs ?? 1000,
-        };
-        // Start automatic sync if configured
-        if (this.config.syncIntervalMs > 0) {
-            this.startAutoSync();
-        }
-    }
-    // ==========================================================================
-    // Instance Management
-    // ==========================================================================
-    /**
-     * Register a new database instance
-     *
-     * @param instance - Instance configuration
-     * @throws Error if instance with same ID already exists
-     */
-    registerInstance(instance) {
-        if (this.instances.has(instance.id)) {
-            throw new Error(`Instance with ID '${instance.id}' already registered`);
-        }
-        this.instances.set(instance.id, { ...instance });
-        this.isSyncing.set(instance.id, false);
-        console.log(`[MultiDatabaseCoordinator] Registered instance: ${instance.id} (${instance.url})`);
-    }
-    /**
-     * Unregister a database instance
-     *
-     * @param id - Instance ID to unregister
-     * @throws Error if instance is currently syncing
-     */
-    unregisterInstance(id) {
-        if (this.isSyncing.get(id)) {
-            throw new Error(`Cannot unregister instance '${id}' while syncing`);
-        }
-        const removed = this.instances.delete(id);
-        this.isSyncing.delete(id);
-        if (removed) {
-            console.log(`[MultiDatabaseCoordinator] Unregistered instance: ${id}`);
-        }
-    }
-    /**
-     * Get all registered instances
-     *
-     * @returns Array of database instances
-     */
-    getInstances() {
-        return Array.from(this.instances.values());
-    }
-    /**
-     * Get a specific instance by ID
-     *
-     * @param id - Instance ID
-     * @returns Instance or null if not found
-     */
-    getInstanceStatus(id) {
-        return this.instances.get(id) ?? null;
-    }
-    /**
-     * Get only online instances
-     *
-     * @returns Array of online instances
-     */
-    getOnlineInstances() {
-        return Array.from(this.instances.values()).filter((i) => i.status === 'online');
-    }
-    /**
-     * Update instance status
-     *
-     * @param id - Instance ID
-     * @param status - New status
-     */
-    updateInstanceStatus(id, status) {
-        const instance = this.instances.get(id);
-        if (!instance)
-            return;
-        const oldStatus = instance.status;
-        if (oldStatus === status)
-            return;
-        instance.status = status;
-        // Notify callbacks
-        for (const callback of this.statusChangeCallbacks) {
-            try {
-                callback(id, oldStatus, status);
-            }
-            catch (error) {
-                console.error(`[MultiDatabaseCoordinator] Status change callback error:`, error);
-            }
-        }
-    }
-    // ==========================================================================
-    // Synchronization
-    // ==========================================================================
-    /**
-     * Synchronize data TO a remote instance
-     *
-     * @param targetId - Target instance ID
-     * @param options - Sync options
-     * @returns Sync result
-     */
-    async syncToInstance(targetId, options = {}) {
-        const instance = this.instances.get(targetId);
-        if (!instance) {
-            return {
-                success: false,
-                instanceId: targetId,
-                itemsSynced: 0,
-                conflictsDetected: 0,
-                conflictsResolved: 0,
-                durationMs: 0,
-                bytesTransferred: 0,
-                error: `Instance '${targetId}' not found`,
-            };
-        }
-        if (instance.status === 'offline') {
-            return {
-                success: false,
-                instanceId: targetId,
-                itemsSynced: 0,
-                conflictsDetected: 0,
-                conflictsResolved: 0,
-                durationMs: 0,
-                bytesTransferred: 0,
-                error: `Instance '${targetId}' is offline`,
-            };
-        }
-        if (this.isSyncing.get(targetId)) {
-            return {
-                success: false,
-                instanceId: targetId,
-                itemsSynced: 0,
-                conflictsDetected: 0,
-                conflictsResolved: 0,
-                durationMs: 0,
-                bytesTransferred: 0,
-                error: `Instance '${targetId}' is already syncing`,
-            };
-        }
-        this.isSyncing.set(targetId, true);
-        this.updateInstanceStatus(targetId, 'syncing');
-        const startTime = Date.now();
-        try {
-            const mergedOptions = this.mergeOptions(options);
-            let itemsSynced = 0;
-            let conflictsDetected = 0;
-            let conflictsResolved = 0;
-            let bytesTransferred = 0;
-            const unresolvedConflicts = [];
-            mergedOptions.onProgress?.({
-                phase: 'preparing',
-                current: 0,
-                total: 100,
-                message: 'Preparing synchronization...',
-            });
-            // Get local vector stats
-            const localStats = this.primaryDb.getStats();
-            const localVectorIds = this.getLocalVectorIds();
-            mergedOptions.onProgress?.({
-                phase: 'fetching',
-                current: 0,
-                total: localVectorIds.length,
-                message: `Fetching ${localVectorIds.length} vectors...`,
-            });
-            // Simulate sync - in real implementation, this would use network calls
-            // For now, we track what would be synced
-            const syncBatches = this.createBatches(localVectorIds, mergedOptions.batchSize ?? 100);
-            for (let i = 0; i < syncBatches.length; i++) {
-                const batch = syncBatches[i];
-                mergedOptions.onProgress?.({
-                    phase: 'applying',
-                    current: i * (mergedOptions.batchSize ?? 100),
-                    total: localVectorIds.length,
-                    message: `Syncing batch ${i + 1}/${syncBatches.length}...`,
-                });
-                // Simulate batch transfer
-                for (const vectorId of batch) {
-                    const localTimestamp = this.vectorTimestamps.get(vectorId) ?? Date.now();
-                    // Check for conflicts (simulate remote timestamp check)
-                    const hasConflict = Math.random() < 0.01; // 1% conflict rate for simulation
-                    if (hasConflict) {
-                        conflictsDetected++;
-                        if (mergedOptions.conflictResolution === 'manual') {
-                            unresolvedConflicts.push({
-                                vectorId,
-                                local: {
-                                    embedding: new Float32Array(0),
-                                    timestamp: localTimestamp,
-                                },
-                                remote: {
-                                    embedding: new Float32Array(0),
-                                    timestamp: localTimestamp - 1000,
-                                },
-                                suggestion: 'keep-local',
-                            });
-                        }
-                        else {
-                            conflictsResolved++;
-                        }
-                    }
-                    itemsSynced++;
-                    bytesTransferred += 384 * 4; // Approximate vector size
-                }
-                // Simulate network delay
-                await this.delay(10);
-            }
-            // Update instance stats
-            instance.lastSyncAt = Date.now();
-            instance.vectorCount = localStats.count;
-            mergedOptions.onProgress?.({
-                phase: 'completed',
-                current: itemsSynced,
-                total: itemsSynced,
-                message: 'Synchronization completed',
-            });
-            const durationMs = Date.now() - startTime;
-            console.log(`[MultiDatabaseCoordinator] Synced to ${targetId}: ${itemsSynced} items, ${conflictsResolved}/${conflictsDetected} conflicts resolved, ${durationMs}ms`);
-            return {
-                success: true,
-                instanceId: targetId,
-                itemsSynced,
-                conflictsDetected,
-                conflictsResolved,
-                durationMs,
-                bytesTransferred,
-                unresolvedConflicts: unresolvedConflicts.length > 0 ? unresolvedConflicts : undefined,
-            };
-        }
-        catch (error) {
-            const err = error;
-            const durationMs = Date.now() - startTime;
-            options.onProgress?.({
-                phase: 'error',
-                current: 0,
-                total: 0,
-                error: err.message,
-            });
-            console.error(`[MultiDatabaseCoordinator] Sync to ${targetId} failed:`, err.message);
-            return {
-                success: false,
-                instanceId: targetId,
-                itemsSynced: 0,
-                conflictsDetected: 0,
-                conflictsResolved: 0,
-                durationMs,
-                bytesTransferred: 0,
-                error: err.message,
-            };
-        }
-        finally {
-            this.isSyncing.set(targetId, false);
-            const instance = this.instances.get(targetId);
-            if (instance && instance.status === 'syncing') {
-                this.updateInstanceStatus(targetId, 'online');
-            }
-        }
-    }
-    /**
-     * Synchronize data FROM a remote instance
-     *
-     * @param sourceId - Source instance ID
-     * @param options - Sync options
-     * @returns Sync result
-     */
-    async syncFromInstance(sourceId, options = {}) {
-        const instance = this.instances.get(sourceId);
-        if (!instance) {
-            return {
-                success: false,
-                instanceId: sourceId,
-                itemsSynced: 0,
-                conflictsDetected: 0,
-                conflictsResolved: 0,
-                durationMs: 0,
-                bytesTransferred: 0,
-                error: `Instance '${sourceId}' not found`,
-            };
-        }
-        if (instance.status === 'offline') {
-            return {
-                success: false,
-                instanceId: sourceId,
-                itemsSynced: 0,
-                conflictsDetected: 0,
-                conflictsResolved: 0,
-                durationMs: 0,
-                bytesTransferred: 0,
-                error: `Instance '${sourceId}' is offline`,
-            };
-        }
-        if (this.isSyncing.get(sourceId)) {
-            return {
-                success: false,
-                instanceId: sourceId,
-                itemsSynced: 0,
-                conflictsDetected: 0,
-                conflictsResolved: 0,
-                durationMs: 0,
-                bytesTransferred: 0,
-                error: `Instance '${sourceId}' is already syncing`,
-            };
-        }
-        this.isSyncing.set(sourceId, true);
-        this.updateInstanceStatus(sourceId, 'syncing');
-        const startTime = Date.now();
-        try {
-            const mergedOptions = this.mergeOptions(options);
-            let itemsSynced = 0;
-            let conflictsDetected = 0;
-            let conflictsResolved = 0;
-            let bytesTransferred = 0;
-            mergedOptions.onProgress?.({
-                phase: 'preparing',
-                current: 0,
-                total: 100,
-                message: 'Preparing to fetch from remote...',
-            });
-            // Simulate fetching from remote
-            const remoteVectorCount = instance.vectorCount;
-            mergedOptions.onProgress?.({
-                phase: 'fetching',
-                current: 0,
-                total: remoteVectorCount,
-                message: `Fetching ${remoteVectorCount} vectors from ${sourceId}...`,
-            });
-            // Simulate progressive sync
-            const batchCount = Math.ceil(remoteVectorCount / (mergedOptions.batchSize ?? 100));
-            for (let i = 0; i < batchCount; i++) {
-                const batchItems = Math.min(mergedOptions.batchSize ?? 100, remoteVectorCount - i * (mergedOptions.batchSize ?? 100));
-                mergedOptions.onProgress?.({
-                    phase: 'applying',
-                    current: i * (mergedOptions.batchSize ?? 100),
-                    total: remoteVectorCount,
-                    message: `Applying batch ${i + 1}/${batchCount}...`,
-                });
-                // Simulate conflict detection
-                const batchConflicts = Math.floor(batchItems * 0.01);
-                conflictsDetected += batchConflicts;
-                if (mergedOptions.conflictResolution !== 'manual') {
-                    conflictsResolved += batchConflicts;
-                }
-                itemsSynced += batchItems;
-                bytesTransferred += batchItems * 384 * 4;
-                await this.delay(10);
-            }
-            // Update instance
-            instance.lastSyncAt = Date.now();
-            mergedOptions.onProgress?.({
-                phase: 'completed',
-                current: itemsSynced,
-                total: itemsSynced,
-                message: 'Synchronization completed',
-            });
-            const durationMs = Date.now() - startTime;
-            console.log(`[MultiDatabaseCoordinator] Synced from ${sourceId}: ${itemsSynced} items, ${conflictsResolved}/${conflictsDetected} conflicts resolved, ${durationMs}ms`);
-            return {
-                success: true,
-                instanceId: sourceId,
-                itemsSynced,
-                conflictsDetected,
-                conflictsResolved,
-                durationMs,
-                bytesTransferred,
-            };
-        }
-        catch (error) {
-            const err = error;
-            const durationMs = Date.now() - startTime;
-            options.onProgress?.({
-                phase: 'error',
-                current: 0,
-                total: 0,
-                error: err.message,
-            });
-            console.error(`[MultiDatabaseCoordinator] Sync from ${sourceId} failed:`, err.message);
-            return {
-                success: false,
-                instanceId: sourceId,
-                itemsSynced: 0,
-                conflictsDetected: 0,
-                conflictsResolved: 0,
-                durationMs,
-                bytesTransferred: 0,
-                error: err.message,
-            };
-        }
-        finally {
-            this.isSyncing.set(sourceId, false);
-            const instance = this.instances.get(sourceId);
-            if (instance && instance.status === 'syncing') {
-                this.updateInstanceStatus(sourceId, 'online');
-            }
-        }
-    }
-    /**
-     * Synchronize all registered instances
-     *
-     * @param options - Sync options
-     * @returns Map of instance ID to sync result
-     */
-    async syncAll(options = {}) {
-        const results = new Map();
-        const onlineInstances = this.getOnlineInstances();
-        if (onlineInstances.length === 0) {
-            console.log('[MultiDatabaseCoordinator] No online instances to sync');
-            return results;
-        }
-        console.log(`[MultiDatabaseCoordinator] Starting sync to ${onlineInstances.length} instances...`);
-        // Sync in parallel (respecting replication factor)
-        const syncPromises = onlineInstances.map(async (instance) => {
-            const result = await this.syncToInstance(instance.id, options);
-            results.set(instance.id, result);
-            return result;
-        });
-        await Promise.all(syncPromises);
-        const successCount = Array.from(results.values()).filter((r) => r.success).length;
-        console.log(`[MultiDatabaseCoordinator] Sync completed: ${successCount}/${onlineInstances.length} successful`);
-        return results;
-    }
-    // ==========================================================================
-    // Health Monitoring
-    // ==========================================================================
-    /**
-     * Start periodic health checks
-     *
-     * @param intervalMs - Check interval in milliseconds (overrides config)
-     */
-    startHealthCheck(intervalMs) {
-        if (this.healthCheckInterval) {
-            console.log('[MultiDatabaseCoordinator] Health check already running');
-            return;
-        }
-        const interval = intervalMs ?? this.config.healthCheckIntervalMs;
-        console.log(`[MultiDatabaseCoordinator] Starting health checks (interval: ${interval}ms)`);
-        this.healthCheckInterval = setInterval(async () => {
-            await this.performHealthCheck();
-        }, interval);
-        // Perform initial check
-        this.performHealthCheck();
-    }
-    /**
-     * Stop periodic health checks
-     */
-    stopHealthCheck() {
-        if (this.healthCheckInterval) {
-            clearInterval(this.healthCheckInterval);
-            this.healthCheckInterval = null;
-            console.log('[MultiDatabaseCoordinator] Health checks stopped');
-        }
-    }
-    /**
-     * Perform health check on all instances
-     */
-    async performHealthCheck() {
-        const instances = this.getInstances();
-        for (const instance of instances) {
-            try {
-                // Simulate health check (in real implementation, make HTTP/TCP request)
-                const isHealthy = await this.checkInstanceHealth(instance);
-                if (isHealthy && instance.status === 'offline') {
-                    this.updateInstanceStatus(instance.id, 'online');
-                    console.log(`[MultiDatabaseCoordinator] Instance ${instance.id} is now online`);
-                    // Auto-sync if enabled
-                    if (this.config.autoFailover) {
-                        this.syncToInstance(instance.id).catch((err) => {
-                            console.error(`[MultiDatabaseCoordinator] Auto-sync to ${instance.id} failed:`, err);
-                        });
-                    }
-                }
-                else if (!isHealthy && instance.status !== 'offline') {
-                    this.updateInstanceStatus(instance.id, 'offline');
-                    console.log(`[MultiDatabaseCoordinator] Instance ${instance.id} is now offline`);
-                }
-            }
-            catch (error) {
-                if (instance.status !== 'offline') {
-                    this.updateInstanceStatus(instance.id, 'offline');
-                    console.log(`[MultiDatabaseCoordinator] Instance ${instance.id} health check failed`);
-                }
-            }
-        }
-    }
-    /**
-     * Check if a specific instance is healthy
-     */
-    async checkInstanceHealth(_instance) {
-        // Simulate health check with timeout
-        // In real implementation: HTTP ping or TCP connect
-        return new Promise((resolve) => {
-            setTimeout(() => {
-                // Simulate 95% uptime
-                resolve(Math.random() > 0.05);
-            }, Math.random() * 100);
-        });
-    }
-    /**
-     * Register a callback for instance status changes
-     *
-     * @param callback - Callback function
-     * @returns Unsubscribe function
-     */
-    onInstanceStatusChange(callback) {
-        this.statusChangeCallbacks.push(callback);
-        return () => {
-            const index = this.statusChangeCallbacks.indexOf(callback);
-            if (index >= 0) {
-                this.statusChangeCallbacks.splice(index, 1);
-            }
-        };
-    }
-    // ==========================================================================
-    // Distributed Operations
-    // ==========================================================================
-    /**
-     * Broadcast an insert operation to all online instances
-     *
-     * @param id - Vector ID
-     * @param vector - Vector embedding
-     * @param metadata - Optional metadata
-     */
-    async broadcastInsert(id, vector, metadata) {
-        // Insert to primary
-        this.primaryDb.insert(id, vector, metadata);
-        this.vectorTimestamps.set(id, Date.now());
-        // Get online instances for replication
-        const onlineInstances = this.getOnlineInstances();
-        const replicationTargets = this.selectReplicationTargets(onlineInstances, this.config.replicationFactor - 1);
-        if (replicationTargets.length === 0) {
-            return;
-        }
-        // Broadcast to replicas (fire and forget with retries)
-        const promises = replicationTargets.map(async (instance) => {
-            for (let retry = 0; retry < this.config.maxRetries; retry++) {
-                try {
-                    // Simulate remote insert
-                    await this.delay(5);
-                    return;
-                }
-                catch (error) {
-                    if (retry === this.config.maxRetries - 1) {
-                        console.error(`[MultiDatabaseCoordinator] Failed to replicate insert to ${instance.id} after ${this.config.maxRetries} retries`);
-                    }
-                    else {
-                        await this.delay(this.config.retryDelayMs);
-                    }
-                }
-            }
-        });
-        await Promise.allSettled(promises);
-    }
-    /**
-     * Broadcast a delete operation to all online instances
-     *
-     * @param id - Vector ID to delete
-     */
-    async broadcastDelete(id) {
-        // Delete from primary
-        this.primaryDb.remove(id);
-        this.vectorTimestamps.delete(id);
-        // Get online instances
-        const onlineInstances = this.getOnlineInstances();
-        if (onlineInstances.length === 0) {
-            return;
-        }
-        // Broadcast delete to all instances
-        const promises = onlineInstances.map(async (instance) => {
-            for (let retry = 0; retry < this.config.maxRetries; retry++) {
-                try {
-                    // Simulate remote delete
-                    await this.delay(5);
-                    return;
-                }
-                catch (error) {
-                    if (retry === this.config.maxRetries - 1) {
-                        console.error(`[MultiDatabaseCoordinator] Failed to replicate delete to ${instance.id}`);
-                    }
-                    else {
-                        await this.delay(this.config.retryDelayMs);
-                    }
-                }
-            }
-        });
-        await Promise.allSettled(promises);
-    }
-    /**
-     * Execute an operation on all instances (including primary)
-     *
-     * @param operation - Operation to execute
-     * @returns Map of instance ID to result
-     */
-    async executeOnAll(operation) {
-        const results = new Map();
-        const errors = new Map();
-        // Execute on primary
-        try {
-            const primaryResult = await operation(this.primaryDb, 'primary');
-            results.set('primary', primaryResult);
-        }
-        catch (error) {
-            errors.set('primary', error);
-        }
-        // Execute on all online instances
-        const onlineInstances = this.getOnlineInstances();
-        const promises = onlineInstances.map(async (instance) => {
-            try {
-                // In real implementation, this would make remote calls
-                // For now, simulate the operation
-                await this.delay(10);
-                const result = await operation(this.primaryDb, instance.id);
-                results.set(instance.id, result);
-            }
-            catch (error) {
-                errors.set(instance.id, error);
-            }
-        });
-        await Promise.all(promises);
-        return {
-            results,
-            errors,
-            successCount: results.size,
-            failureCount: errors.size,
-        };
-    }
-    // ==========================================================================
-    // Configuration
-    // ==========================================================================
-    /**
-     * Get current configuration
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-    /**
-     * Update configuration
-     *
-     * @param updates - Partial configuration updates
-     */
-    updateConfig(updates) {
-        Object.assign(this.config, updates);
-        // Restart auto-sync if interval changed
-        if (updates.syncIntervalMs !== undefined) {
-            this.stopAutoSync();
-            if (this.config.syncIntervalMs > 0) {
-                this.startAutoSync();
-            }
-        }
-    }
-    /**
-     * Get coordinator statistics
-     */
-    getStats() {
-        const instances = this.getInstances();
-        const onlineCount = instances.filter((i) => i.status === 'online').length;
-        const offlineCount = instances.filter((i) => i.status === 'offline').length;
-        const syncingCount = instances.filter((i) => i.status === 'syncing').length;
-        const totalVectors = instances.reduce((sum, i) => sum + i.vectorCount, 0);
-        return {
-            primaryStats: this.primaryDb.getStats(),
-            instanceCount: instances.length,
-            onlineCount,
-            offlineCount,
-            syncingCount,
-            totalVectors,
-        };
-    }
-    // ==========================================================================
-    // Cleanup
-    // ==========================================================================
-    /**
-     * Stop all background tasks and cleanup
-     */
-    close() {
-        this.stopHealthCheck();
-        this.stopAutoSync();
-        this.instances.clear();
-        this.statusChangeCallbacks.length = 0;
-        this.vectorTimestamps.clear();
-        console.log('[MultiDatabaseCoordinator] Closed');
-    }
-    // ==========================================================================
-    // Private Helpers
-    // ==========================================================================
-    startAutoSync() {
-        if (this.syncInterval)
-            return;
-        console.log(`[MultiDatabaseCoordinator] Starting auto-sync (interval: ${this.config.syncIntervalMs}ms)`);
-        this.syncInterval = setInterval(async () => {
-            try {
-                await this.syncAll();
-            }
-            catch (error) {
-                console.error('[MultiDatabaseCoordinator] Auto-sync failed:', error);
-            }
-        }, this.config.syncIntervalMs);
-    }
-    stopAutoSync() {
-        if (this.syncInterval) {
-            clearInterval(this.syncInterval);
-            this.syncInterval = null;
-            console.log('[MultiDatabaseCoordinator] Auto-sync stopped');
-        }
-    }
-    mergeOptions(options) {
-        return {
-            conflictResolution: options.conflictResolution ?? this.config.conflictResolution,
-            batchSize: options.batchSize ?? 100,
-            timeoutMs: options.timeoutMs ?? 60000,
-            forceFullSync: options.forceFullSync ?? false,
-            namespaceFilter: options.namespaceFilter,
-            onProgress: options.onProgress,
-        };
-    }
-    getLocalVectorIds() {
-        // Return tracked vector IDs
-        return Array.from(this.vectorTimestamps.keys());
-    }
-    createBatches(items, batchSize) {
-        const batches = [];
-        for (let i = 0; i < items.length; i += batchSize) {
-            batches.push(items.slice(i, i + batchSize));
-        }
-        return batches;
-    }
-    selectReplicationTargets(instances, count) {
-        // Select random instances for replication
-        const shuffled = [...instances].sort(() => Math.random() - 0.5);
-        return shuffled.slice(0, Math.min(count, shuffled.length));
-    }
-    delay(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-}
-//# sourceMappingURL=MultiDatabaseCoordinator.js.map