agentic-qe 2.7.4 → 2.8.0

package/dist/edge/p2p/sharing/PatternSyncManager.js

@@ -0,0 +1,859 @@
+"use strict";
+/**
+ * Pattern Sync Manager for P2P Synchronization
+ *
+ * Manages pattern synchronization between peers including pull/push operations,
+ * incremental sync using vector clocks, conflict resolution, and bandwidth management.
+ *
+ * @module edge/p2p/sharing/PatternSyncManager
+ * @version 1.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternSyncManager = void 0;
+exports.createPatternSyncManager = createPatternSyncManager;
+const types_1 = require("./types");
+const PatternSerializer_1 = require("./PatternSerializer");
+// ============================================
+// Pattern Sync Manager Class
+// ============================================
+/**
+ * Manages pattern synchronization between P2P peers
+ *
+ * @example
+ * ```typescript
+ * const syncManager = new PatternSyncManager({
+ *   localAgentId: 'my-agent',
+ *   index: patternIndex,
+ *   channel: agentChannel,
+ * });
+ *
+ * // Pull patterns from peer
+ * const patterns = await syncManager.pull('peer-agent', {
+ *   categories: ['test'],
+ *   limit: 50,
+ * });
+ *
+ * // Push local patterns to peer
+ * await syncManager.push('peer-agent', localPatterns);
+ *
+ * // Incremental sync
+ * await syncManager.syncWithPeer('peer-agent');
+ * ```
+ */
+class PatternSyncManager {
+    constructor(config) {
+        // Sync state tracking
+        this.syncStates = new Map();
+        this.activeSessions = new Map();
+        this.pendingSyncs = new Map();
+        this.vectorClocks = new Map();
+        // Rate limiting
+        this.bytesThisSecond = 0;
+        this.lastRateReset = Date.now();
+        // Event handlers
+        this.eventHandlers = [];
+        this.localAgentId = config.localAgentId;
+        this.index = config.index;
+        this.channel = config.channel;
+        this.bandwidth = { ...types_1.DEFAULT_BANDWIDTH_CONFIG, ...config.bandwidth };
+        this.conflictStrategy = config.conflictStrategy ?? 'latest_wins';
+        this.maxBatchSize = config.maxBatchSize ?? types_1.MAX_BATCH_SIZE;
+        this.verifySignatures = config.verifySignatures ?? true;
+        this.serializer = new PatternSerializer_1.PatternSerializer();
+        // Setup channel handlers if provided
+        if (this.channel) {
+            this.setupChannelHandlers();
+        }
+        // Start auto-sync if configured
+        if (config.autoSyncInterval && config.autoSyncInterval > 0) {
+            this.startAutoSync(config.autoSyncInterval);
+        }
+    }
+    // ============================================
+    // Pull Operations
+    // ============================================
+    /**
+     * Pull patterns from a peer
+     */
+    async pull(peerId, query) {
+        if (!this.channel) {
+            throw new types_1.SharingError('No channel configured for sync', types_1.SharingErrorCode.NETWORK_ERROR);
+        }
+        const requestId = this.generateRequestId();
+        const session = this.createSession(requestId, peerId, 'pull');
+        try {
+            // Build sync request
+            const request = {
+                requestId,
+                requesterId: this.localAgentId,
+                query,
+                vectorClocks: this.getVectorClocksForPeer(peerId),
+                timestamp: new Date().toISOString(),
+                includeContent: true,
+            };
+            // Send request
+            const response = await this.sendSyncRequest(peerId, request);
+            // Process patterns
+            const patterns = [];
+            for (const pattern of response.patterns) {
+                await this.processReceivedPattern(pattern, peerId);
+                patterns.push(pattern);
+                session.patternsTransferred++;
+            }
+            // Handle conflicts
+            if (response.conflicts && response.conflicts.length > 0) {
+                for (const conflict of response.conflicts) {
+                    await this.resolveConflict(conflict, peerId);
+                }
+            }
+            // Update sync state
+            this.updateSyncState(peerId, types_1.SyncStatus.SYNCED, patterns.map((p) => p.id));
+            session.status = types_1.SyncStatus.SYNCED;
+            this.emit({
+                type: types_1.SharingEventType.SYNC_COMPLETED,
+                timestamp: Date.now(),
+                details: {
+                    peerId,
+                    direction: 'pull',
+                    patternsReceived: patterns.length,
+                    conflicts: response.conflicts?.length ?? 0,
+                },
+            });
+            return patterns;
+        }
+        catch (error) {
+            session.status = types_1.SyncStatus.FAILED;
+            session.error = error instanceof Error ? error.message : 'Unknown error';
+            this.updateSyncState(peerId, types_1.SyncStatus.FAILED);
+            this.emit({
+                type: types_1.SharingEventType.SYNC_FAILED,
+                timestamp: Date.now(),
+                details: { peerId, direction: 'pull', error: session.error },
+            });
+            throw error;
+        }
+        finally {
+            this.activeSessions.delete(session.sessionId);
+        }
+    }
+    /**
+     * Pull specific patterns by ID
+     */
+    async pullPatterns(peerId, patternIds) {
+        if (!this.channel) {
+            throw new types_1.SharingError('No channel configured for sync', types_1.SharingErrorCode.NETWORK_ERROR);
+        }
+        const requestId = this.generateRequestId();
+        const session = this.createSession(requestId, peerId, 'pull');
+        try {
+            const request = {
+                requestId,
+                requesterId: this.localAgentId,
+                patternIds,
+                timestamp: new Date().toISOString(),
+                includeContent: true,
+            };
+            const response = await this.sendSyncRequest(peerId, request);
+            const patterns = [];
+            for (const pattern of response.patterns) {
+                await this.processReceivedPattern(pattern, peerId);
+                patterns.push(pattern);
+            }
+            session.status = types_1.SyncStatus.SYNCED;
+            return patterns;
+        }
+        catch (error) {
+            session.status = types_1.SyncStatus.FAILED;
+            throw error;
+        }
+        finally {
+            this.activeSessions.delete(session.sessionId);
+        }
+    }
+    // ============================================
+    // Push Operations
+    // ============================================
+    /**
+     * Push patterns to a peer
+     */
+    async push(peerId, patterns) {
+        if (!this.channel) {
+            throw new types_1.SharingError('No channel configured for sync', types_1.SharingErrorCode.NETWORK_ERROR);
+        }
+        const session = this.createSession(this.generateRequestId(), peerId, 'push');
+        this.emit({
+            type: types_1.SharingEventType.SYNC_STARTED,
+            timestamp: Date.now(),
+            details: { peerId, direction: 'push', patternCount: patterns.length },
+        });
+        try {
+            // Send in batches respecting bandwidth limits
+            const batches = this.createBatches(patterns);
+            for (const batch of batches) {
+                await this.waitForBandwidth(batch.length * 1024); // Estimate
+                // Send batch via channel
+                await this.channel.publish('pattern:sync:push', {
+                    senderId: this.localAgentId,
+                    patterns: batch,
+                    timestamp: new Date().toISOString(),
+                });
+                session.patternsTransferred += batch.length;
+                // Delay between batches
+                if (this.bandwidth.batchDelay > 0) {
+                    await this.delay(this.bandwidth.batchDelay);
+                }
+            }
+            // Update sync state
+            const patternIds = patterns.map((p) => p.id);
+            this.updateSyncState(peerId, types_1.SyncStatus.SYNCED, patternIds);
+            session.status = types_1.SyncStatus.SYNCED;
+            this.emit({
+                type: types_1.SharingEventType.SYNC_COMPLETED,
+                timestamp: Date.now(),
+                details: { peerId, direction: 'push', patternsSent: patterns.length },
+            });
+        }
+        catch (error) {
+            session.status = types_1.SyncStatus.FAILED;
+            session.error = error instanceof Error ? error.message : 'Unknown error';
+            this.updateSyncState(peerId, types_1.SyncStatus.FAILED);
+            this.emit({
+                type: types_1.SharingEventType.SYNC_FAILED,
+                timestamp: Date.now(),
+                details: { peerId, direction: 'push', error: session.error },
+            });
+            throw error;
+        }
+        finally {
+            this.activeSessions.delete(session.sessionId);
+        }
+    }
+    /**
+     * Push all local patterns to peer (full sync)
+     */
+    async pushAll(peerId) {
+        const patterns = this.index.getAll();
+        await this.push(peerId, patterns);
+    }
+    // ============================================
+    // Incremental Sync
+    // ============================================
+    /**
+     * Perform incremental sync with a peer
+     * Uses vector clocks to sync only changed patterns
+     */
+    async syncWithPeer(peerId) {
+        if (!this.channel) {
+            throw new types_1.SharingError('No channel configured for sync', types_1.SharingErrorCode.NETWORK_ERROR);
+        }
+        this.emit({
+            type: types_1.SharingEventType.SYNC_STARTED,
+            timestamp: Date.now(),
+            details: { peerId, direction: 'bidirectional' },
+        });
+        try {
+            // Get peer's vector clocks
+            const peerClocks = await this.getPeerVectorClocks(peerId);
+            // Determine what to pull (patterns peer has that are newer)
+            const toPull = this.findPatternsToPull(peerClocks);
+            // Determine what to push (patterns we have that are newer)
+            const toPush = this.findPatternsToPush(peerClocks);
+            // Execute sync
+            let pulled = 0;
+            let pushed = 0;
+            let conflicts = 0;
+            // Pull first
+            if (toPull.length > 0) {
+                const pulledPatterns = await this.pullPatterns(peerId, toPull);
+                pulled = pulledPatterns.length;
+            }
+            // Then push
+            if (toPush.length > 0) {
+                const patterns = toPush
+                    .map((id) => this.index.get(id))
+                    .filter((p) => p !== undefined);
+                await this.push(peerId, patterns);
+                pushed = patterns.length;
+            }
+            // Update local vector clock
+            this.updateLocalClock(peerId);
+            this.emit({
+                type: types_1.SharingEventType.SYNC_COMPLETED,
+                timestamp: Date.now(),
+                details: { peerId, pulled, pushed, conflicts },
+            });
+            return { pulled, pushed, conflicts };
+        }
+        catch (error) {
+            this.emit({
+                type: types_1.SharingEventType.SYNC_FAILED,
+                timestamp: Date.now(),
+                details: {
+                    peerId,
+                    error: error instanceof Error ? error.message : 'Unknown',
+                },
+            });
+            throw error;
+        }
+    }
+    // ============================================
+    // Conflict Resolution
+    // ============================================
+    /**
+     * Resolve a pattern conflict
+     */
+    async resolveConflict(conflict, peerId) {
+        this.emit({
+            type: types_1.SharingEventType.CONFLICT_DETECTED,
+            timestamp: Date.now(),
+            details: { conflict, peerId },
+        });
+        let resolution;
+        switch (this.conflictStrategy) {
+            case 'latest_wins':
+                resolution = this.resolveLatestWins(conflict);
+                break;
+            case 'prefer_local':
+                resolution = this.resolvePreferLocal(conflict);
+                break;
+            case 'prefer_remote':
+                resolution = await this.resolvePreferRemote(conflict, peerId);
+                break;
+            case 'manual':
+            default:
+                resolution = {
+                    strategy: 'manual',
+                    resolvedAt: new Date().toISOString(),
+                };
+                break;
+        }
+        // Apply resolution if we have a resolved pattern
+        if (resolution.resolvedPattern) {
+            this.index.update(conflict.patternId, resolution.resolvedPattern);
+        }
+        this.emit({
+            type: types_1.SharingEventType.CONFLICT_RESOLVED,
+            timestamp: Date.now(),
+            details: { conflict, resolution },
+        });
+        return resolution;
+    }
+    /**
+     * Latest-wins conflict resolution
+     */
+    resolveLatestWins(conflict) {
+        const localPattern = this.index.get(conflict.patternId);
+        if (!localPattern) {
+            return {
+                strategy: 'latest_wins',
+                resolvedAt: new Date().toISOString(),
+            };
+        }
+        // Compare timestamps
+        const localTime = new Date(localPattern.updatedAt).getTime();
+        const remoteVersion = conflict.remoteVersion;
+        // Use vector clock comparison
+        const comparison = this.index.compareVectorClocks(conflict.localVersion.vectorClock, conflict.remoteVersion.vectorClock);
+        if (comparison === 'after') {
+            // Local is newer, keep local
+            return {
+                strategy: 'latest_wins',
+                resolvedPattern: localPattern,
+                resolvedAt: new Date().toISOString(),
+                resolvedBy: this.localAgentId,
+            };
+        }
+        // Remote is newer or concurrent, need to fetch and use remote
+        return {
+            strategy: 'latest_wins',
+            resolvedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * Prefer local pattern resolution
+     */
+    resolvePreferLocal(conflict) {
+        const localPattern = this.index.get(conflict.patternId);
+        return {
+            strategy: 'prefer_local',
+            resolvedPattern: localPattern,
+            resolvedAt: new Date().toISOString(),
+            resolvedBy: this.localAgentId,
+        };
+    }
+    /**
+     * Prefer remote pattern resolution
+     */
+    async resolvePreferRemote(conflict, peerId) {
+        // Fetch the remote pattern
+        const patterns = await this.pullPatterns(peerId, [conflict.patternId]);
+        const remotePattern = patterns[0];
+        return {
+            strategy: 'prefer_remote',
+            resolvedPattern: remotePattern,
+            resolvedAt: new Date().toISOString(),
+            resolvedBy: peerId,
+        };
+    }
+    // ============================================
+    // Request Handling
+    // ============================================
+    /**
+     * Handle incoming sync request from a peer
+     */
+    async handleSyncRequest(request) {
+        const patterns = [];
+        const conflicts = [];
+        if (request.patternIds) {
+            // Specific patterns requested
+            for (const id of request.patternIds) {
+                const pattern = this.index.get(id);
+                if (pattern && this.canShareWith(pattern, request.requesterId)) {
+                    patterns.push(pattern);
+                }
+            }
+        }
+        else if (request.query) {
+            // Query-based request
+            const results = this.index.search(request.query);
+            for (const match of results.matches) {
+                if (this.canShareWith(match.pattern, request.requesterId)) {
+                    patterns.push(match.pattern);
+                }
+            }
+        }
+        // Check for conflicts using vector clocks
+        if (request.vectorClocks) {
+            for (const pattern of patterns) {
+                const peerClock = request.vectorClocks[pattern.id];
+                if (peerClock) {
+                    const conflict = this.checkVectorClockConflict(pattern, peerClock);
+                    if (conflict) {
+                        conflicts.push(conflict);
+                    }
+                }
+            }
+        }
+        // Apply pagination
+        const limit = request.query?.limit ?? this.maxBatchSize;
+        const paginatedPatterns = patterns.slice(0, limit);
+        return {
+            requestId: request.requestId,
+            responderId: this.localAgentId,
+            patterns: paginatedPatterns,
+            conflicts,
+            hasMore: patterns.length > limit,
+            continuationToken: patterns.length > limit ? this.generateContinuationToken() : undefined,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    /**
+     * Handle incoming pushed patterns from a peer
+     */
+    async handlePushedPatterns(peerId, patterns) {
+        for (const pattern of patterns) {
+            await this.processReceivedPattern(pattern, peerId);
+        }
+    }
+    // ============================================
+    // Channel Setup
+    // ============================================
+    /**
+     * Setup channel handlers for sync protocol
+     */
+    setupChannelHandlers() {
+        if (!this.channel)
+            return;
+        // Handle sync requests
+        this.channel.onRequest('pattern:sync:request', async (request) => {
+            return this.handleSyncRequest(request);
+        });
+        // Handle pushed patterns
+        this.channel.subscribe('pattern:sync:push', async (data) => {
+            await this.handlePushedPatterns(data.senderId, data.patterns);
+        });
+        // Handle vector clock requests
+        this.channel.onRequest('pattern:sync:clocks', () => {
+            return this.getAllVectorClocks();
+        });
+    }
+    /**
+     * Set communication channel
+     */
+    setChannel(channel) {
+        this.channel = channel;
+        this.setupChannelHandlers();
+    }
+    // ============================================
+    // Vector Clock Management
+    // ============================================
+    /**
+     * Get vector clocks for patterns to sync with peer
+     */
+    getVectorClocksForPeer(peerId) {
+        const clocks = {};
+        for (const pattern of this.index.getAll()) {
+            clocks[pattern.id] = pattern.version.vectorClock;
+        }
+        return clocks;
+    }
+    /**
+     * Get all local vector clocks
+     */
+    getAllVectorClocks() {
+        const clocks = {};
+        for (const pattern of this.index.getAll()) {
+            clocks[pattern.id] = pattern.version.vectorClock;
+        }
+        return clocks;
+    }
+    /**
+     * Get peer's vector clocks
+     */
+    async getPeerVectorClocks(peerId) {
+        if (!this.channel) {
+            return {};
+        }
+        try {
+            return await this.channel.request('pattern:sync:clocks', { peerId: this.localAgentId });
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * Find patterns to pull based on peer's clocks
+     */
+    findPatternsToPull(peerClocks) {
+        const toPull = [];
+        for (const [patternId, peerClock] of Object.entries(peerClocks)) {
+            const localPattern = this.index.get(patternId);
+            if (!localPattern) {
+                // Don't have it, need to pull
+                toPull.push(patternId);
+            }
+            else {
+                // Compare clocks
+                const comparison = this.index.compareVectorClocks(localPattern.version.vectorClock, peerClock);
+                if (comparison === 'before') {
+                    // Peer has newer version
+                    toPull.push(patternId);
+                }
+            }
+        }
+        return toPull;
+    }
+    /**
+     * Find patterns to push based on peer's clocks
+     */
+    findPatternsToPush(peerClocks) {
+        const toPush = [];
+        for (const pattern of this.index.getAll()) {
+            const peerClock = peerClocks[pattern.id];
+            if (!peerClock) {
+                // Peer doesn't have it
+                toPush.push(pattern.id);
+            }
+            else {
+                // Compare clocks
+                const comparison = this.index.compareVectorClocks(pattern.version.vectorClock, peerClock);
+                if (comparison === 'after') {
+                    // We have newer version
+                    toPush.push(pattern.id);
+                }
+            }
+        }
+        return toPush;
+    }
+    /**
+     * Update local vector clock after sync
+     */
+    updateLocalClock(peerId) {
+        for (const pattern of this.index.getAll()) {
+            const newClock = this.index.incrementClock(pattern.version.vectorClock, this.localAgentId);
+            this.index.update(pattern.id, {
+                version: {
+                    ...pattern.version,
+                    vectorClock: newClock,
+                },
+            });
+        }
+    }
+    /**
+     * Check for conflict using vector clocks
+     */
+    checkVectorClockConflict(pattern, peerClock) {
+        const comparison = this.index.compareVectorClocks(pattern.version.vectorClock, peerClock);
+        if (comparison === 'concurrent') {
+            return {
+                patternId: pattern.id,
+                localVersion: pattern.version,
+                remoteVersion: { ...pattern.version, vectorClock: peerClock },
+                conflictType: 'concurrent_update',
+            };
+        }
+        return null;
+    }
+    // ============================================
+    // Sync State Management
+    // ============================================
+    /**
+     * Get sync state for a peer
+     */
+    getSyncState(peerId) {
+        return this.syncStates.get(peerId);
+    }
+    /**
+     * Get all sync states
+     */
+    getAllSyncStates() {
+        return new Map(this.syncStates);
+    }
+    /**
+     * Update sync state
+     */
+    updateSyncState(peerId, status, patternIds) {
+        const existing = this.syncStates.get(peerId);
+        const now = new Date().toISOString();
+        const state = {
+            patternId: peerId, // Using peerId as the pattern sync identifier
+            status,
+            lastSyncAt: now,
+            lastSuccessAt: status === types_1.SyncStatus.SYNCED ? now : existing?.lastSuccessAt,
+            syncedPeers: patternIds ?? existing?.syncedPeers ?? [],
+            pendingPeers: [],
+        };
+        this.syncStates.set(peerId, state);
+    }
+    // ============================================
+    // Bandwidth Management
+    // ============================================
+    /**
+     * Wait for available bandwidth
+     */
+    async waitForBandwidth(bytes) {
+        const now = Date.now();
+        // Reset counter every second
+        if (now - this.lastRateReset > 1000) {
+            this.bytesThisSecond = 0;
+            this.lastRateReset = now;
+        }
+        // Check if we need to wait
+        if (this.bytesThisSecond + bytes > this.bandwidth.maxUploadBps) {
+            const waitTime = 1000 - (now - this.lastRateReset);
+            await this.delay(waitTime);
+            this.bytesThisSecond = 0;
+            this.lastRateReset = Date.now();
+        }
+        this.bytesThisSecond += bytes;
+    }
+    /**
+     * Create batches for sending
+     */
+    createBatches(patterns) {
+        const batches = [];
+        const batchSize = Math.min(this.maxBatchSize, this.bandwidth.batchSize);
+        for (let i = 0; i < patterns.length; i += batchSize) {
+            batches.push(patterns.slice(i, i + batchSize));
+        }
+        return batches;
+    }
+    // ============================================
+    // Auto Sync
+    // ============================================
+    /**
+     * Start automatic sync interval
+     */
+    startAutoSync(intervalMs) {
+        if (this.autoSyncInterval) {
+            this.stopAutoSync();
+        }
+        this.autoSyncInterval = setInterval(() => {
+            this.runAutoSync();
+        }, intervalMs);
+    }
+    /**
+     * Stop automatic sync
+     */
+    stopAutoSync() {
+        if (this.autoSyncInterval) {
+            clearInterval(this.autoSyncInterval);
+            this.autoSyncInterval = undefined;
+        }
+    }
+    /**
+     * Run automatic sync with all known peers
+     */
+    async runAutoSync() {
+        // Get peers from sync states
+        for (const peerId of this.syncStates.keys()) {
+            try {
+                await this.syncWithPeer(peerId);
+            }
+            catch {
+                // Log error but continue with other peers
+            }
+        }
+    }
+    // ============================================
+    // Helper Methods
+    // ============================================
+    /**
+     * Send sync request and wait for response
+     */
+    async sendSyncRequest(peerId, request) {
+        if (!this.channel) {
+            throw new types_1.SharingError('No channel for sync', types_1.SharingErrorCode.NETWORK_ERROR);
+        }
+        return this.channel.request('pattern:sync:request', request, 30000 // 30s timeout
+        );
+    }
+    /**
+     * Process a received pattern
+     */
+    async processReceivedPattern(pattern, fromPeer) {
+        // Validate pattern
+        if (!this.serializer.validatePattern(pattern)) {
+            throw new types_1.SharingError(`Invalid pattern: ${pattern.id}`, types_1.SharingErrorCode.INVALID_PATTERN);
+        }
+        // Check for conflicts
+        const conflict = this.index.checkConflict(pattern);
+        if (conflict) {
+            await this.resolveConflict(conflict, fromPeer);
+            return;
+        }
+        // Add or update pattern
+        if (this.index.has(pattern.id)) {
+            this.index.update(pattern.id, pattern);
+        }
+        else {
+            try {
+                this.index.add(pattern);
+            }
+            catch (error) {
+                if (error instanceof types_1.SharingError &&
+                    error.code === types_1.SharingErrorCode.DUPLICATE_PATTERN) {
+                    // Already exists (by content hash), skip
+                    return;
+                }
+                throw error;
+            }
+        }
+    }
+    /**
+     * Check if pattern can be shared with peer
+     */
+    canShareWith(pattern, peerId) {
+        const { policy, allowedPeers, blockedPeers } = pattern.sharing;
+        // Check blocked list
+        if (blockedPeers?.includes(peerId)) {
+            return false;
+        }
+        switch (policy) {
+            case 'public':
+                return true;
+            case 'trusted':
+                // For now, all connected peers are considered trusted
+                return true;
+            case 'selective':
+                return allowedPeers?.includes(peerId) ?? false;
+            case 'private':
+                return false;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Create a sync session
+     */
+    createSession(sessionId, peerId, direction) {
+        const session = {
+            sessionId,
+            peerId,
+            direction,
+            startTime: Date.now(),
+            patternsTransferred: 0,
+            bytesTransferred: 0,
+            status: types_1.SyncStatus.SYNCING,
+        };
+        this.activeSessions.set(sessionId, session);
+        return session;
+    }
+    /**
+     * Generate unique request ID using cryptographically secure random
+     */
+    generateRequestId() {
+        const timestamp = Date.now().toString(36);
+        const randomBytes = new Uint8Array(4);
+        crypto.getRandomValues(randomBytes);
+        const random = Array.from(randomBytes).map(b => b.toString(36)).join('').substring(0, 6);
+        return `sync-${timestamp}-${random}`;
+    }
+    /**
+     * Generate continuation token
+     */
+    generateContinuationToken() {
+        return Buffer.from(Date.now().toString()).toString('base64');
+    }
+    /**
+     * Delay helper
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    // ============================================
+    // Events
+    // ============================================
+    /**
+     * Subscribe to events
+     */
+    on(handler) {
+        this.eventHandlers.push(handler);
+    }
+    /**
+     * Unsubscribe from events
+     */
+    off(handler) {
+        const index = this.eventHandlers.indexOf(handler);
+        if (index !== -1) {
+            this.eventHandlers.splice(index, 1);
+        }
+    }
+    /**
+     * Emit an event
+     */
+    emit(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch {
+                // Ignore handler errors
+            }
+        }
+    }
+    // ============================================
+    // Cleanup
+    // ============================================
+    /**
+     * Destroy the sync manager
+     */
+    destroy() {
+        this.stopAutoSync();
+        this.activeSessions.clear();
+        this.pendingSyncs.clear();
+        this.syncStates.clear();
+        this.eventHandlers = [];
+    }
+}
+exports.PatternSyncManager = PatternSyncManager;
+// ============================================
+// Factory Functions
+// ============================================
+/**
+ * Create a new pattern sync manager
+ */
+function createPatternSyncManager(config) {
+    return new PatternSyncManager(config);
+}
+//# sourceMappingURL=PatternSyncManager.js.map