agentic-qe 2.7.4 → 2.8.0

package/dist/edge/p2p/federated/FederatedRound.js

@@ -0,0 +1,819 @@
+"use strict";
+/**
+ * Federated Round Coordinator
+ *
+ * Coordinates training rounds across peers in a federated learning session.
+ * Handles participant selection, round lifecycle management, update collection,
+ * timeout handling, and minimum participation thresholds.
+ *
+ * @module edge/p2p/federated/FederatedRound
+ * @version 1.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FederatedRound = exports.RoundEventType = void 0;
+exports.createFederatedRound = createFederatedRound;
+const types_1 = require("./types");
+/**
+ * Round event types
+ */
+var RoundEventType;
+(function (RoundEventType) {
+    RoundEventType["STATUS_CHANGED"] = "status_changed";
+    RoundEventType["PARTICIPANT_JOINED"] = "participant_joined";
+    RoundEventType["PARTICIPANT_DROPPED"] = "participant_dropped";
+    RoundEventType["UPDATE_RECEIVED"] = "update_received";
+    RoundEventType["AGGREGATION_STARTED"] = "aggregation_started";
+    RoundEventType["AGGREGATION_COMPLETED"] = "aggregation_completed";
+    RoundEventType["ROUND_COMPLETED"] = "round_completed";
+    RoundEventType["ROUND_FAILED"] = "round_failed";
+    RoundEventType["ROUND_TIMED_OUT"] = "round_timed_out";
+})(RoundEventType || (exports.RoundEventType = RoundEventType = {}));
+// ============================================
+// FederatedRound Class
+// ============================================
+/**
+ * Manages a single federated learning round
+ *
+ * @example
+ * ```typescript
+ * const round = new FederatedRound({
+ *   sessionId: 'session-1',
+ *   roundNumber: 5,
+ *   federatedConfig: config,
+ *   globalModel: currentModel,
+ *   availableParticipants: participants,
+ *   aggregator: aggregator,
+ *   sendMessage: async (id, msg) => channel.send(id, msg),
+ *   broadcastMessage: async (msg) => channel.broadcast(msg),
+ * });
+ *
+ * await round.start();
+ *
+ * // Handle join requests
+ * round.handleJoinRequest(request);
+ *
+ * // Handle update submissions
+ * round.handleUpdateSubmission(submission);
+ *
+ * // Wait for round completion
+ * const result = await round.waitForCompletion();
+ * ```
+ */
+class FederatedRound {
+    constructor(config) {
+        this.eventHandlers = [];
+        this.timeoutTimer = null;
+        this.collectionTimer = null;
+        this.completionPromise = null;
+        this.completionResolve = null;
+        this.completionReject = null;
+        this.config = config;
+        // Initialize round state
+        this.state = {
+            roundId: `${config.sessionId}-round-${config.roundNumber}`,
+            roundNumber: config.roundNumber,
+            status: types_1.RoundStatus.PREPARING,
+            participants: new Map(),
+            updates: new Map(),
+            startingModel: config.globalModel,
+            startedAt: 0,
+            targetParticipants: Math.min(config.federatedConfig.maxParticipants, config.availableParticipants.size),
+            minParticipants: Math.max(1, Math.ceil(config.availableParticipants.size * config.federatedConfig.minParticipation)),
+            timeoutAt: 0,
+            metrics: this.createInitialMetrics(),
+            errors: [],
+        };
+    }
+    // ============================================
+    // Lifecycle Methods
+    // ============================================
+    /**
+     * Start the round
+     */
+    async start() {
+        if (this.state.status !== types_1.RoundStatus.PREPARING) {
+            throw new types_1.FederatedError('Round already started', types_1.FederatedErrorCode.ROUND_NOT_FOUND);
+        }
+        this.state.startedAt = Date.now();
+        this.state.timeoutAt = this.state.startedAt + this.config.federatedConfig.roundTimeout;
+        // Set up completion promise
+        this.completionPromise = new Promise((resolve, reject) => {
+            this.completionResolve = resolve;
+            this.completionReject = reject;
+        });
+        // Select participants
+        const selectedParticipants = this.selectParticipants();
+        if (selectedParticipants.length < this.state.minParticipants) {
+            this.fail(new types_1.FederatedError(`Insufficient participants: ${selectedParticipants.length} < ${this.state.minParticipants}`, types_1.FederatedErrorCode.INSUFFICIENT_PARTICIPANTS));
+            return;
+        }
+        // Transition to awaiting participants
+        this.updateStatus(types_1.RoundStatus.AWAITING_PARTICIPANTS);
+        // Create round announcement
+        const announcement = this.createRoundAnnouncement();
+        // Send announcements to selected participants
+        await this.announceRound(selectedParticipants, announcement);
+        // Start timeout timer
+        this.startTimeoutTimer();
+        // Start collection phase after brief delay
+        setTimeout(() => {
+            if (this.state.status === types_1.RoundStatus.AWAITING_PARTICIPANTS) {
+                this.updateStatus(types_1.RoundStatus.ANNOUNCED);
+                // Start collecting after announcement phase
+                setTimeout(() => {
+                    if (this.state.status === types_1.RoundStatus.ANNOUNCED ||
+                        this.state.status === types_1.RoundStatus.AWAITING_PARTICIPANTS) {
+                        this.updateStatus(types_1.RoundStatus.COLLECTING);
+                    }
+                }, 1000); // 1 second for announcements to propagate
+            }
+        }, 100);
+    }
+    /**
+     * Cancel the round
+     */
+    cancel(reason = 'Round cancelled') {
+        if (this.isFinished())
+            return;
+        this.cleanup();
+        this.updateStatus(types_1.RoundStatus.CANCELLED);
+        this.addError('CANCELLED', reason, true);
+        if (this.completionReject) {
+            this.completionReject(new types_1.FederatedError(reason, types_1.FederatedErrorCode.ROUND_NOT_FOUND));
+        }
+    }
+    /**
+     * Wait for round completion
+     */
+    async waitForCompletion() {
+        if (!this.completionPromise) {
+            throw new types_1.FederatedError('Round not started', types_1.FederatedErrorCode.ROUND_NOT_FOUND);
+        }
+        return this.completionPromise;
+    }
+    /**
+     * Check if round is finished
+     */
+    isFinished() {
+        return [
+            types_1.RoundStatus.COMPLETED,
+            types_1.RoundStatus.FAILED,
+            types_1.RoundStatus.CANCELLED,
+            types_1.RoundStatus.TIMED_OUT,
+        ].includes(this.state.status);
+    }
+    // ============================================
+    // Participant Management
+    // ============================================
+    /**
+     * Handle join request from participant
+     */
+    async handleJoinRequest(request) {
+        // Validate request
+        if (request.roundId !== this.state.roundId) {
+            return {
+                type: 'join_response',
+                accepted: false,
+                rejectionReason: 'Wrong round ID',
+            };
+        }
+        // Check if still accepting participants
+        if (this.state.status !== types_1.RoundStatus.AWAITING_PARTICIPANTS &&
+            this.state.status !== types_1.RoundStatus.ANNOUNCED &&
+            this.state.status !== types_1.RoundStatus.COLLECTING) {
+            return {
+                type: 'join_response',
+                accepted: false,
+                rejectionReason: 'Round not accepting participants',
+            };
+        }
+        // Check if already joined
+        if (this.state.participants.has(request.participantId)) {
+            return {
+                type: 'join_response',
+                accepted: false,
+                rejectionReason: 'Already joined',
+            };
+        }
+        // Check participant limit
+        if (this.state.participants.size >= this.config.federatedConfig.maxParticipants) {
+            return {
+                type: 'join_response',
+                accepted: false,
+                rejectionReason: 'Round at capacity',
+            };
+        }
+        // Calculate participant weight
+        const totalSamples = this.getTotalSamples() + request.sampleCount;
+        const weight = request.sampleCount / totalSamples;
+        // Create participant record
+        const participant = {
+            participantId: request.participantId,
+            sampleCount: request.sampleCount,
+            weight,
+            hasSubmitted: false,
+            joinedAt: Date.now(),
+            capabilities: request.capabilities,
+        };
+        this.state.participants.set(request.participantId, participant);
+        this.state.metrics.participantsJoined++;
+        this.state.metrics.totalSamples += request.sampleCount;
+        // Recalculate weights for all participants
+        this.recalculateWeights();
+        this.emitEvent({
+            type: RoundEventType.PARTICIPANT_JOINED,
+            timestamp: Date.now(),
+            details: { participantId: request.participantId },
+        });
+        return {
+            type: 'join_response',
+            accepted: true,
+            weight: participant.weight,
+            model: this.state.startingModel,
+        };
+    }
+    /**
+     * Handle participant dropout
+     */
+    handleParticipantDropout(participantId) {
+        const participant = this.state.participants.get(participantId);
+        if (!participant)
+            return;
+        // Remove participant
+        this.state.participants.delete(participantId);
+        this.state.updates.delete(participantId);
+        // Recalculate weights
+        this.recalculateWeights();
+        // Update metrics
+        this.state.metrics.totalSamples -= participant.sampleCount;
+        this.emitEvent({
+            type: RoundEventType.PARTICIPANT_DROPPED,
+            timestamp: Date.now(),
+            details: { participantId },
+        });
+        // Check if we still have minimum participants
+        if (this.state.participants.size < this.state.minParticipants &&
+            !this.isFinished()) {
+            this.fail(new types_1.FederatedError('Dropped below minimum participants', types_1.FederatedErrorCode.INSUFFICIENT_PARTICIPANTS));
+        }
+    }
+    // ============================================
+    // Update Collection
+    // ============================================
+    /**
+     * Handle update submission from participant
+     */
+    async handleUpdateSubmission(submission) {
+        // Validate submission
+        if (submission.roundId !== this.state.roundId) {
+            return false;
+        }
+        // Check if collecting
+        if (this.state.status !== types_1.RoundStatus.COLLECTING &&
+            this.state.status !== types_1.RoundStatus.ANNOUNCED) {
+            return false;
+        }
+        // Check if participant joined
+        const participant = this.state.participants.get(submission.update.participantId);
+        if (!participant) {
+            return false;
+        }
+        // Check if already submitted
+        if (participant.hasSubmitted) {
+            return false;
+        }
+        // Store update
+        this.state.updates.set(submission.update.participantId, submission.update);
+        participant.hasSubmitted = true;
+        participant.submittedAt = Date.now();
+        // Update metrics
+        this.state.metrics.participantsSubmitted++;
+        this.state.metrics.participationRate =
+            this.state.metrics.participantsSubmitted / this.state.participants.size;
+        this.emitEvent({
+            type: RoundEventType.UPDATE_RECEIVED,
+            timestamp: Date.now(),
+            details: {
+                participantId: submission.update.participantId,
+                sampleCount: submission.update.sampleCount,
+            },
+        });
+        // Check if we have enough updates to aggregate
+        await this.checkAggregationTrigger();
+        return true;
+    }
+    /**
+     * Check if we should trigger aggregation
+     */
+    async checkAggregationTrigger() {
+        // All participants submitted
+        if (this.state.updates.size >= this.state.participants.size) {
+            await this.startAggregation();
+            return;
+        }
+        // Enough participants and timeout approaching
+        const timeRemaining = this.state.timeoutAt - Date.now();
+        const enoughParticipants = this.state.updates.size >= this.state.minParticipants;
+        const timeoutApproaching = timeRemaining < this.config.federatedConfig.roundTimeout * 0.2;
+        if (enoughParticipants && timeoutApproaching) {
+            await this.startAggregation();
+        }
+    }
+    // ============================================
+    // Aggregation
+    // ============================================
+    /**
+     * Start aggregation phase
+     */
+    async startAggregation() {
+        if (this.state.status === types_1.RoundStatus.AGGREGATING ||
+            this.state.status === types_1.RoundStatus.DISTRIBUTING ||
+            this.isFinished()) {
+            return;
+        }
+        this.updateStatus(types_1.RoundStatus.AGGREGATING);
+        this.emitEvent({
+            type: RoundEventType.AGGREGATION_STARTED,
+            timestamp: Date.now(),
+            details: { updateCount: this.state.updates.size },
+        });
+        try {
+            const aggregationStart = Date.now();
+            // Get updates array
+            const updates = Array.from(this.state.updates.values());
+            // Perform aggregation
+            const result = await this.config.aggregator.aggregate(updates, this.state.startingModel);
+            // Update metrics
+            this.state.metrics.aggregationTime = Date.now() - aggregationStart;
+            this.state.metrics.aggregatedLoss = this.computeAggregatedLoss(updates);
+            this.state.aggregatedModel = result.aggregatedWeights;
+            this.emitEvent({
+                type: RoundEventType.AGGREGATION_COMPLETED,
+                timestamp: Date.now(),
+                details: {
+                    aggregationTime: this.state.metrics.aggregationTime,
+                    updateCount: result.updateCount,
+                },
+            });
+            // Distribute result
+            await this.distributeResult(result);
+            // Complete round
+            this.complete(result);
+        }
+        catch (error) {
+            this.fail(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Distribute aggregation result to participants
+     */
+    async distributeResult(result) {
+        this.updateStatus(types_1.RoundStatus.DISTRIBUTING);
+        const broadcast = {
+            type: 'aggregation_result',
+            sessionId: this.config.sessionId,
+            roundId: this.state.roundId,
+            model: result.aggregatedWeights,
+            metrics: this.state.metrics,
+        };
+        try {
+            await this.config.broadcastMessage(broadcast);
+        }
+        catch (error) {
+            this.addError('DISTRIBUTION_ERROR', `Failed to distribute result: ${error}`, true);
+        }
+    }
+    /**
+     * Complete the round successfully
+     */
+    complete(result) {
+        this.cleanup();
+        this.state.endedAt = Date.now();
+        this.state.metrics.duration = this.state.endedAt - this.state.startedAt;
+        this.updateStatus(types_1.RoundStatus.COMPLETED);
+        this.emitEvent({
+            type: RoundEventType.ROUND_COMPLETED,
+            timestamp: Date.now(),
+            details: {
+                roundNumber: this.state.roundNumber,
+                metrics: this.state.metrics,
+            },
+        });
+        if (this.completionResolve) {
+            this.completionResolve(result);
+        }
+    }
+    /**
+     * Fail the round
+     */
+    fail(error) {
+        this.cleanup();
+        this.state.endedAt = Date.now();
+        this.state.metrics.duration = this.state.endedAt - this.state.startedAt;
+        this.addError('ROUND_FAILED', error.message, false);
+        this.updateStatus(types_1.RoundStatus.FAILED);
+        this.emitEvent({
+            type: RoundEventType.ROUND_FAILED,
+            timestamp: Date.now(),
+            details: { error: error.message },
+        });
+        if (this.completionReject) {
+            this.completionReject(error);
+        }
+    }
+    // ============================================
+    // Participant Selection
+    // ============================================
+    /**
+     * Select participants for this round
+     */
+    selectParticipants() {
+        const available = Array.from(this.config.availableParticipants.values());
+        const strategy = this.config.federatedConfig.selectionStrategy;
+        const targetCount = Math.min(this.config.federatedConfig.maxParticipants, available.length);
+        switch (strategy) {
+            case types_1.SelectionStrategy.RANDOM:
+                return this.randomSelection(available, targetCount);
+            case types_1.SelectionStrategy.IMPORTANCE:
+                return this.importanceSelection(available, targetCount);
+            case types_1.SelectionStrategy.DIVERSITY:
+                return this.diversitySelection(available, targetCount);
+            case types_1.SelectionStrategy.ROUND_ROBIN:
+                return this.roundRobinSelection(available, targetCount);
+            case types_1.SelectionStrategy.ACTIVE:
+                return this.activeSelection(available, targetCount);
+            case types_1.SelectionStrategy.POWER_OF_CHOICE:
+                return this.powerOfChoiceSelection(available, targetCount);
+            default:
+                return this.randomSelection(available, targetCount);
+        }
+    }
+    /**
+     * Random selection strategy
+     */
+    randomSelection(available, targetCount) {
+        const shuffled = [...available].sort(() => Math.random() - 0.5);
+        return shuffled.slice(0, targetCount);
+    }
+    /**
+     * Importance sampling based on data size
+     */
+    importanceSelection(available, targetCount) {
+        const totalSamples = available.reduce((sum, p) => sum + p.sampleCount, 0);
+        // Calculate selection probabilities
+        const probabilities = available.map((p) => ({
+            participant: p,
+            probability: p.sampleCount / totalSamples,
+        }));
+        // Weighted sampling without replacement
+        const selected = [];
+        const remaining = [...probabilities];
+        while (selected.length < targetCount && remaining.length > 0) {
+            const totalProb = remaining.reduce((sum, p) => sum + p.probability, 0);
+            let random = Math.random() * totalProb;
+            for (let i = 0; i < remaining.length; i++) {
+                random -= remaining[i].probability;
+                if (random <= 0) {
+                    selected.push(remaining[i].participant);
+                    remaining.splice(i, 1);
+                    break;
+                }
+            }
+        }
+        return selected;
+    }
+    /**
+     * Diversity-based selection
+     */
+    diversitySelection(available, targetCount) {
+        // Sort by diversity score (descending)
+        const sorted = [...available].sort((a, b) => (b.diversityScore ?? 0) - (a.diversityScore ?? 0));
+        return sorted.slice(0, targetCount);
+    }
+    /**
+     * Round-robin selection
+     */
+    roundRobinSelection(available, targetCount) {
+        // Sort by last participation (oldest first)
+        const sorted = [...available].sort((a, b) => (a.lastParticipation ?? 0) - (b.lastParticipation ?? 0));
+        return sorted.slice(0, targetCount);
+    }
+    /**
+     * Active learning-based selection
+     */
+    activeSelection(available, targetCount) {
+        // Combine factors: trust score, diversity, recency
+        const scored = available.map((p) => ({
+            participant: p,
+            score: p.trustScore * 0.4 +
+                (p.diversityScore ?? 0.5) * 0.3 +
+                (1 - Math.min(1, ((Date.now() - (p.lastParticipation ?? 0)) / (24 * 60 * 60 * 1000)))) * 0.3,
+        }));
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, targetCount).map((s) => s.participant);
+    }
+    /**
+     * Power-of-choice selection
+     */
+    powerOfChoiceSelection(available, targetCount) {
+        // For each slot, pick best of d random candidates
+        const d = 2; // Power of 2 choices
+        const selected = [];
+        const remaining = [...available];
+        while (selected.length < targetCount && remaining.length > 0) {
+            // Pick d random candidates
+            const candidates = [];
+            for (let i = 0; i < Math.min(d, remaining.length); i++) {
+                const idx = Math.floor(Math.random() * remaining.length);
+                candidates.push(remaining[idx]);
+            }
+            // Select best candidate (by sample count)
+            const best = candidates.reduce((a, b) => a.sampleCount > b.sampleCount ? a : b);
+            selected.push(best);
+            remaining.splice(remaining.indexOf(best), 1);
+        }
+        return selected;
+    }
+    // ============================================
+    // Round Communication
+    // ============================================
+    /**
+     * Create round announcement message
+     */
+    createRoundAnnouncement() {
+        const config = this.config.federatedConfig;
+        const trainingConfig = {
+            epochs: config.localEpochs,
+            batchSize: config.batchSize,
+            learningRate: config.learningRate,
+            updateType: types_1.UpdateType.GRADIENTS,
+            applyDifferentialPrivacy: config.differentialPrivacy?.enabled ?? false,
+            dpConfig: config.differentialPrivacy,
+            compressionConfig: config.compression,
+        };
+        return {
+            type: 'round_announcement',
+            sessionId: this.config.sessionId,
+            roundId: this.state.roundId,
+            roundNumber: this.state.roundNumber,
+            modelVersion: this.state.startingModel.version,
+            modelChecksum: this.state.startingModel.checksum,
+            trainingConfig,
+            deadline: this.state.timeoutAt,
+            minParticipants: this.state.minParticipants,
+        };
+    }
+    /**
+     * Send round announcements to selected participants
+     */
+    async announceRound(participants, announcement) {
+        const sendPromises = participants.map(async (p) => {
+            try {
+                await this.config.sendMessage(p.participantId, announcement);
+            }
+            catch (error) {
+                this.addError('ANNOUNCEMENT_ERROR', `Failed to announce to ${p.participantId}: ${error}`, true);
+            }
+        });
+        await Promise.all(sendPromises);
+    }
+    // ============================================
+    // Timeout Handling
+    // ============================================
+    /**
+     * Start the round timeout timer
+     */
+    startTimeoutTimer() {
+        const timeout = this.config.federatedConfig.roundTimeout;
+        this.timeoutTimer = setTimeout(() => {
+            this.handleTimeout();
+        }, timeout);
+    }
+    /**
+     * Handle round timeout
+     */
+    handleTimeout() {
+        if (this.isFinished())
+            return;
+        // Check if we have minimum participants
+        if (this.state.updates.size >= this.state.minParticipants) {
+            // Proceed with aggregation
+            this.startAggregation();
+        }
+        else {
+            // Fail the round
+            this.cleanup();
+            this.state.endedAt = Date.now();
+            this.state.metrics.duration = this.state.endedAt - this.state.startedAt;
+            this.addError('TIMEOUT', `Round timed out with only ${this.state.updates.size}/${this.state.minParticipants} updates`, false);
+            this.updateStatus(types_1.RoundStatus.TIMED_OUT);
+            this.emitEvent({
+                type: RoundEventType.ROUND_TIMED_OUT,
+                timestamp: Date.now(),
+                details: {
+                    updatesReceived: this.state.updates.size,
+                    minRequired: this.state.minParticipants,
+                },
+            });
+            if (this.completionReject) {
+                this.completionReject(new types_1.FederatedError('Round timed out', types_1.FederatedErrorCode.ROUND_TIMEOUT));
+            }
+        }
+    }
+    // ============================================
+    // Helper Methods
+    // ============================================
+    /**
+     * Get total samples across joined participants
+     */
+    getTotalSamples() {
+        let total = 0;
+        for (const p of this.state.participants.values()) {
+            total += p.sampleCount;
+        }
+        return total;
+    }
+    /**
+     * Recalculate weights for all participants
+     */
+    recalculateWeights() {
+        const totalSamples = this.getTotalSamples();
+        if (totalSamples === 0)
+            return;
+        for (const participant of this.state.participants.values()) {
+            participant.weight = participant.sampleCount / totalSamples;
+        }
+    }
+    /**
+     * Compute aggregated loss from updates
+     */
+    computeAggregatedLoss(updates) {
+        if (updates.length === 0)
+            return 0;
+        const totalSamples = updates.reduce((sum, u) => sum + u.sampleCount, 0);
+        let weightedLoss = 0;
+        for (const update of updates) {
+            const weight = update.sampleCount / totalSamples;
+            weightedLoss += weight * update.localLoss;
+        }
+        return weightedLoss;
+    }
+    /**
+     * Create initial metrics object
+     */
+    createInitialMetrics() {
+        return {
+            participantsJoined: 0,
+            participantsSubmitted: 0,
+            participationRate: 0,
+            totalSamples: 0,
+            aggregatedLoss: 0,
+            lossImprovement: 0,
+            duration: 0,
+            communicationBytes: 0,
+        };
+    }
+    /**
+     * Update round status
+     */
+    updateStatus(status) {
+        const previousStatus = this.state.status;
+        this.state.status = status;
+        this.emitEvent({
+            type: RoundEventType.STATUS_CHANGED,
+            timestamp: Date.now(),
+            details: { from: previousStatus, to: status },
+        });
+    }
+    /**
+     * Add an error to the round
+     */
+    addError(type, message, recoverable) {
+        this.state.errors.push({
+            type,
+            message,
+            timestamp: Date.now(),
+            recoverable,
+        });
+    }
+    /**
+     * Cleanup timers and resources
+     */
+    cleanup() {
+        if (this.timeoutTimer) {
+            clearTimeout(this.timeoutTimer);
+            this.timeoutTimer = null;
+        }
+        if (this.collectionTimer) {
+            clearTimeout(this.collectionTimer);
+            this.collectionTimer = null;
+        }
+    }
+    // ============================================
+    // Event Handling
+    // ============================================
+    /**
+     * Add event handler
+     */
+    on(handler) {
+        this.eventHandlers.push(handler);
+    }
+    /**
+     * Remove event handler
+     */
+    off(handler) {
+        const index = this.eventHandlers.indexOf(handler);
+        if (index !== -1) {
+            this.eventHandlers.splice(index, 1);
+        }
+    }
+    /**
+     * Emit event to handlers
+     */
+    emitEvent(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch {
+                // Ignore handler errors
+            }
+        }
+    }
+    // ============================================
+    // Getters
+    // ============================================
+    /**
+     * Get round ID
+     */
+    getRoundId() {
+        return this.state.roundId;
+    }
+    /**
+     * Get round number
+     */
+    getRoundNumber() {
+        return this.state.roundNumber;
+    }
+    /**
+     * Get current status
+     */
+    getStatus() {
+        return this.state.status;
+    }
+    /**
+     * Get round state
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Get round metrics
+     */
+    getMetrics() {
+        return { ...this.state.metrics };
+    }
+    /**
+     * Get participants
+     */
+    getParticipants() {
+        return new Map(this.state.participants);
+    }
+    /**
+     * Get updates received
+     */
+    getUpdates() {
+        return new Map(this.state.updates);
+    }
+    /**
+     * Get aggregated model
+     */
+    getAggregatedModel() {
+        return this.state.aggregatedModel;
+    }
+    /**
+     * Get errors
+     */
+    getErrors() {
+        return [...this.state.errors];
+    }
+    /**
+     * Get time remaining until timeout
+     */
+    getTimeRemaining() {
+        if (this.isFinished())
+            return 0;
+        return Math.max(0, this.state.timeoutAt - Date.now());
+    }
+}
+exports.FederatedRound = FederatedRound;
+// ============================================
+// Factory Function
+// ============================================
+/**
+ * Create a new federated round
+ */
+function createFederatedRound(config) {
+    return new FederatedRound(config);
+}
+//# sourceMappingURL=FederatedRound.js.map