0xray 4.0.36 → 4.0.38

package/dist/session/session-cleanup-manager.js

@@ -13,6 +13,8 @@ export class SessionCleanupManager {
     cleanupInterval;
     _sessionMetadata;
     _metadataLoaded = false;
+    /** Same object the store holds, so a one-field write does not clone every session. */
+    metadataRecord = {};
     sessionMonitor;
     constructor(stateManager, config = {}, sessionMonitor) {
         this.stateManager = stateManager;
@@ -40,6 +42,7 @@ export class SessionCleanupManager {
     set sessionMetadata(value) {
         this._sessionMetadata = value;
         this._metadataLoaded = true;
+        this.metadataRecord = Object.fromEntries(value);
     }
     /**
      * Initialize cleanup manager and start auto-cleanup if enabled
@@ -228,19 +231,21 @@ export class SessionCleanupManager {
         const now = Date.now();
         let expiredCount = 0;
         let idleCount = 0;
+        let activeSessions = 0;
         for (const metadata of this.sessionMetadata.values()) {
             if (!metadata.isActive)
                 continue;
+            activeSessions += 1;
             if (now - metadata.createdAt > metadata.ttlMs) {
-                expiredCount++;
+                expiredCount += 1;
             }
             else if (now - metadata.lastActivity > this.config.idleTimeoutMs) {
-                idleCount++;
+                idleCount += 1;
             }
         }
         return {
             totalSessions: this.sessionMetadata.size,
-            activeSessions: Array.from(this.sessionMetadata.values()).filter((m) => m.isActive).length,
+            activeSessions,
             expiredSessions: expiredCount,
             idleSessions: idleCount,
             nextCleanup: this.cleanupInterval
@@ -292,19 +297,29 @@ export class SessionCleanupManager {
      * Load session metadata from state manager (lazy loading)
      */
     loadSessionMetadata() {
+        this._sessionMetadata = new Map();
+        this.metadataRecord = {};
         try {
             const storedMetadata = this.stateManager.get("cleanup:session_metadata");
-            this._sessionMetadata = new Map();
             if (storedMetadata &&
                 typeof storedMetadata === "object" &&
                 !Array.isArray(storedMetadata)) {
+                const loaded = new Map();
+                this._sessionMetadata = loaded;
+                let dropped = false;
                 for (const [sessionId, metadata] of Object.entries(storedMetadata)) {
                     if (metadata && typeof metadata === "object" && metadata.sessionId) {
-                        this._sessionMetadata.set(sessionId, metadata);
+                        loaded.set(sessionId, metadata);
+                    }
+                    else {
+                        dropped = true;
                     }
                 }
+                this.metadataRecord = dropped
+                    ? Object.fromEntries(loaded)
+                    : storedMetadata;
                 frameworkLogger.log("session-cleanup", "load-metadata", "info", {
-                    sessionsLoaded: this._sessionMetadata.size,
+                    sessionsLoaded: loaded.size,
                 });
             }
             else if (storedMetadata) {
@@ -316,13 +331,19 @@ export class SessionCleanupManager {
                 error,
             });
         }
+        this._metadataLoaded = true;
     }
     /**
      * Persist session metadata to state manager
      */
     persistSessionMetadata(sessionId, metadata) {
-        const allMetadata = Object.fromEntries(this.sessionMetadata);
-        this.stateManager.set("cleanup:session_metadata", allMetadata);
+        if (this._sessionMetadata?.has(sessionId)) {
+            this.metadataRecord[sessionId] = metadata;
+        }
+        else {
+            delete this.metadataRecord[sessionId];
+        }
+        this.stateManager.set("cleanup:session_metadata", this.metadataRecord);
     }
     /**
      * Cleanup a specific session

package/dist/session/session-monitor.d.ts

@@ -74,6 +74,13 @@ export declare class SessionMonitor {
     private interactionHistory;
     private sessionResponseTimes;
     private sessionErrors;
+    /** Stable store records. A field write patches one session instead of cloning the map. */
+    private healthRecord;
+    private metricsRecord;
+    private alertRecord;
+    private interactionRecord;
+    private responseTotals;
+    private outcomeTotals;
     constructor(stateManager: XrayStateManager, sessionCoordinator: SessionCoordinator, cleanupManager: SessionCleanupManager, config?: Partial<MonitorConfig>);
     start(): void;
     registerSession(sessionId: string): void;
@@ -96,14 +103,15 @@ export declare class SessionMonitor {
     private startMetricsCollection;
     private generateAlerts;
     private loadPersistedData;
-    private persistHealthData;
-    private persistMetricsData;
-    private persistAlertData;
+    private persistHealth;
     shutdown(): void;
     /**
      * Record an interaction for tracking
      */
     recordInteraction(sessionId: string, interaction: InteractionRecord): void;
+    private persistInteractions;
+    private seedInteractionTotals;
+    private adoptStoreRecord;
     /**
      * Get interaction history for a session
      */
@@ -115,6 +123,9 @@ export declare class SessionMonitor {
     /**
      * Calculate failure ratio from interactions
      */
+    private outcomeOf;
+    private responseAverage;
+    private hasDiverseRecentAgents;
     private calculateFailureRatio;
     /**
      * Calculate conflict resolution rate from interactions
@@ -124,7 +135,6 @@ export declare class SessionMonitor {
      * Calculate coordination efficiency from interactions
      */
     private calculateCoordinationEfficiency;
-    private persistInteractionData;
     private calculateSessionMemoryUsage;
     private countSessionConflicts;
     private calculateAverageResponseTime;

package/dist/session/session-monitor.js

@@ -20,6 +20,13 @@ export class SessionMonitor {
     interactionHistory = new Map();
     sessionResponseTimes = new Map();
     sessionErrors = new Map();
+    /** Stable store records. A field write patches one session instead of cloning the map. */
+    healthRecord = {};
+    metricsRecord = {};
+    alertRecord = {};
+    interactionRecord = {};
+    responseTotals = new Map();
+    outcomeTotals = new Map();
     constructor(stateManager, sessionCoordinator, cleanupManager, config = {}) {
         this.stateManager = stateManager;
         this.sessionCoordinator = sessionCoordinator;
@@ -61,7 +68,7 @@ export class SessionMonitor {
         };
         this.healthChecks.set(sessionId, health);
         this.metricsHistory.set(sessionId, []);
-        this.persistHealthData();
+        this.persistHealth(sessionId);
         frameworkLogger.log("session-monitor", "session-registered", "info", {
             sessionId,
         });
@@ -75,7 +82,7 @@ export class SessionMonitor {
                 alert.resolvedAt = Date.now();
             }
         }
-        this.persistHealthData();
+        this.persistHealth(sessionId);
         frameworkLogger.log("session-monitor", "session-unregistered", "info", {
             sessionId,
         });
@@ -83,10 +90,15 @@ export class SessionMonitor {
     async performHealthCheck(sessionId) {
         const jobId = `session-health-check-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
         const startTime = Date.now();
-        const health = this.healthChecks.get(sessionId);
-        if (!health) {
+        const current = this.healthChecks.get(sessionId);
+        if (!current) {
             throw new Error(`Session ${sessionId} not registered for monitoring`);
         }
+        // Readers keep the last published session until every field is ready.
+        const health = {
+            ...current,
+            issues: [...current.issues],
+        };
         const issues = [];
         let status = "healthy";
         try {
@@ -109,7 +121,9 @@ export class SessionMonitor {
             }
             else {
                 health.activeAgents = sessionStatus.agentCount;
-                this.performComprehensiveHealthChecks(sessionId, health, issues, sessionStatus);
+                const checked = this.performComprehensiveHealthChecks(sessionId, issues, sessionStatus);
+                if (status === "healthy")
+                    status = checked;
                 if (health.errorCount > 10) {
                     issues.push(`High error count: ${health.errorCount} errors detected`);
                     status = "degraded";
@@ -118,8 +132,7 @@ export class SessionMonitor {
                     issues.push(`Critical response time: ${health.responseTime}ms (exceeded 2x threshold)`);
                     status = "critical";
                 }
-                const recentInteractions = this.interactionHistory.get(sessionId) || [];
-                const failedRatio = this.calculateFailureRatio(recentInteractions);
+                const failedRatio = this.calculateFailureRatio(sessionId);
                 if (failedRatio > this.config.alertThresholds.maxErrorRate) {
                     issues.push(`High failure rate: ${(failedRatio * 100).toFixed(1)}% failed interactions`);
                     status = status === "healthy" ? "degraded" : status;
@@ -166,11 +179,12 @@ export class SessionMonitor {
         health.lastCheck = Date.now();
         health.responseTime = responseTime;
         health.issues = issues;
-        this.persistHealthData();
+        this.healthChecks.set(sessionId, health);
+        this.persistHealth(sessionId);
         if (issues.length > 0 && this.config.enableAlerts) {
             this.generateAlerts(sessionId, issues, status);
         }
-        return { ...health };
+        return health;
     }
     collectMetrics(sessionId) {
         const sessionStatus = this.sessionCoordinator.getSessionStatus(sessionId);
@@ -178,16 +192,10 @@ export class SessionMonitor {
             return null;
         const metadata = this.cleanupManager?.getSessionMetadata(sessionId);
         const interactions = this.interactionHistory.get(sessionId) || [];
-        const responseTimes = this.sessionResponseTimes.get(sessionId) || [];
-        const errorCount = this.sessionErrors.get(sessionId) || 0;
-        const successfulInteractions = interactions.filter(i => i.success).length;
-        const failedInteractions = interactions.filter(i => !i.success).length;
-        const totalInteractions = interactions.length;
-        const avgResponseTime = responseTimes.length > 0
-            ? responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length
-            : 0;
-        const conflictResolutionRate = this.calculateConflictResolutionRate(sessionId, interactions);
-        const coordinationEfficiency = this.calculateCoordinationEfficiency(sessionId, interactions);
+        const { success: successfulInteractions, failed: failedInteractions, total: totalInteractions } = this.outcomeOf(sessionId);
+        const avgResponseTime = this.responseAverage(sessionId);
+        const conflictResolutionRate = this.calculateConflictResolutionRate(sessionId);
+        const coordinationEfficiency = this.calculateCoordinationEfficiency(sessionId, interactions ?? []);
         const metrics = {
             timestamp: Date.now(),
             sessionId,
@@ -200,13 +208,21 @@ export class SessionMonitor {
             memoryUsage: metadata?.memoryUsage || this.calculateSessionMemoryUsage(sessionId),
             agentCount: sessionStatus.agentCount,
         };
-        const history = this.metricsHistory.get(sessionId) || [];
+        let history = this.metricsHistory.get(sessionId);
+        if (!history) {
+            history = [];
+            this.metricsHistory.set(sessionId, history);
+        }
         history.push(metrics);
         if (history.length > 100) {
             history.shift();
         }
-        this.metricsHistory.set(sessionId, history);
-        this.persistMetricsData();
+        this.metricsRecord[sessionId] = history;
+        for (const key of Object.keys(this.metricsRecord)) {
+            if (!this.metricsHistory.has(key))
+                delete this.metricsRecord[key];
+        }
+        this.stateManager.set("monitor:metrics", this.metricsRecord);
         return metrics;
     }
     getHealthStatus(sessionId) {
@@ -217,11 +233,14 @@ export class SessionMonitor {
         return history.slice(-limit);
     }
     getActiveAlerts(sessionId) {
-        const alerts = Array.from(this.activeAlerts.values());
-        if (sessionId) {
-            return alerts.filter((alert) => alert.sessionId === sessionId);
+        if (!sessionId)
+            return Array.from(this.activeAlerts.values());
+        const matched = [];
+        for (const alert of this.activeAlerts.values()) {
+            if (alert.sessionId === sessionId)
+                matched.push(alert);
         }
-        return alerts;
+        return matched;
     }
     resolveAlert(alertId) {
         const alert = this.activeAlerts.get(alertId);
@@ -229,7 +248,8 @@ export class SessionMonitor {
             alert.resolved = true;
             alert.resolvedAt = Date.now();
             this.activeAlerts.delete(alertId);
-            this.persistAlertData();
+            delete this.alertRecord[alertId];
+            this.stateManager.set("monitor:alerts", this.alertRecord);
             frameworkLogger.log("session-monitor", "alert-resolved", "info", {
                 alertId,
             });
@@ -314,44 +334,56 @@ export class SessionMonitor {
                 resolved: false,
             };
             this.activeAlerts.set(alert.id, alert);
+            this.alertRecord[alert.id] = alert;
             frameworkLogger.log("session-monitor", "alert-generated", "info", {
                 sessionId,
                 issue,
             });
         }
-        this.persistAlertData();
+        this.stateManager.set("monitor:alerts", this.alertRecord);
     }
     loadPersistedData() {
         const healthData = this.stateManager.get("monitor:health");
-        if (healthData) {
+        if (healthData && typeof healthData === "object" && !Array.isArray(healthData)) {
+            this.healthRecord = healthData;
             for (const [sessionId, health] of Object.entries(healthData)) {
                 this.healthChecks.set(sessionId, health);
             }
         }
         const metricsData = this.stateManager.get("monitor:metrics");
-        if (metricsData) {
+        if (metricsData && typeof metricsData === "object" && !Array.isArray(metricsData)) {
+            this.metricsRecord = metricsData;
             for (const [sessionId, history] of Object.entries(metricsData)) {
                 this.metricsHistory.set(sessionId, history);
             }
         }
         const alertData = this.stateManager.get("monitor:alerts");
-        if (alertData) {
+        if (alertData && typeof alertData === "object" && !Array.isArray(alertData)) {
+            this.alertRecord = alertData;
             for (const [alertId, alert] of Object.entries(alertData)) {
                 this.activeAlerts.set(alertId, alert);
             }
         }
+        const interactionData = this.stateManager.get("monitor:interactions");
+        if (interactionData &&
+            typeof interactionData === "object" &&
+            !Array.isArray(interactionData)) {
+            this.interactionRecord = interactionData;
+            for (const [sessionId, history] of Object.entries(interactionData)) {
+                if (!Array.isArray(history))
+                    continue;
+                this.interactionHistory.set(sessionId, history);
+                this.seedInteractionTotals(sessionId, history);
+            }
+        }
     }
-    persistHealthData() {
-        const healthData = Object.fromEntries(this.healthChecks);
-        this.stateManager.set("monitor:health", healthData);
-    }
-    persistMetricsData() {
-        const metricsData = Object.fromEntries(this.metricsHistory);
-        this.stateManager.set("monitor:metrics", metricsData);
-    }
-    persistAlertData() {
-        const alertData = Object.fromEntries(this.activeAlerts);
-        this.stateManager.set("monitor:alerts", alertData);
+    persistHealth(sessionId) {
+        const health = this.healthChecks.get(sessionId);
+        if (health)
+            this.healthRecord[sessionId] = health;
+        else
+            delete this.healthRecord[sessionId];
+        this.stateManager.set("monitor:health", this.healthRecord);
     }
     shutdown() {
         if (this.healthCheckInterval) {
@@ -368,23 +400,77 @@ export class SessionMonitor {
      * Record an interaction for tracking
      */
     recordInteraction(sessionId, interaction) {
-        if (!this.interactionHistory.has(sessionId)) {
-            this.interactionHistory.set(sessionId, []);
+        let interactions = this.interactionHistory.get(sessionId);
+        if (!interactions) {
+            interactions = [];
+            this.interactionHistory.set(sessionId, interactions);
         }
-        const interactions = this.interactionHistory.get(sessionId);
+        this.interactionRecord[sessionId] = interactions;
         interactions.push(interaction);
+        let outcomes = this.outcomeTotals.get(sessionId);
+        if (!outcomes) {
+            outcomes = { success: 0, failed: 0 };
+            this.outcomeTotals.set(sessionId, outcomes);
+        }
+        if (interaction.success)
+            outcomes.success += 1;
+        else
+            outcomes.failed += 1;
         if (interactions.length > 100) {
-            interactions.shift();
+            const removed = interactions.shift();
+            if (removed) {
+                if (removed.success)
+                    outcomes.success -= 1;
+                else
+                    outcomes.failed -= 1;
+            }
         }
-        if (!this.sessionResponseTimes.has(sessionId)) {
-            this.sessionResponseTimes.set(sessionId, []);
+        let responseTimes = this.sessionResponseTimes.get(sessionId);
+        if (!responseTimes) {
+            responseTimes = [];
+            this.sessionResponseTimes.set(sessionId, responseTimes);
         }
-        this.sessionResponseTimes.get(sessionId).push(interaction.duration);
+        responseTimes.push(interaction.duration);
+        const totals = this.responseTotals.get(sessionId) ?? { sum: 0, count: 0 };
+        totals.sum += interaction.duration;
+        totals.count += 1;
+        this.responseTotals.set(sessionId, totals);
         if (!interaction.success) {
             const currentErrors = this.sessionErrors.get(sessionId) || 0;
             this.sessionErrors.set(sessionId, currentErrors + 1);
         }
-        this.persistInteractionData();
+        this.persistInteractions();
+    }
+    persistInteractions() {
+        this.interactionRecord = this.adoptStoreRecord("monitor:interactions", this.interactionRecord);
+        this.stateManager.set("monitor:interactions", this.interactionRecord);
+    }
+    seedInteractionTotals(sessionId, history) {
+        let success = 0;
+        let failed = 0;
+        let sum = 0;
+        for (const item of history) {
+            if (item.success)
+                success += 1;
+            else
+                failed += 1;
+            sum += item.duration;
+        }
+        this.outcomeTotals.set(sessionId, { success, failed });
+        this.responseTotals.set(sessionId, { sum, count: history.length });
+    }
+    adoptStoreRecord(key, record) {
+        const existing = this.stateManager.get(key);
+        if (!existing ||
+            typeof existing !== "object" ||
+            Array.isArray(existing) ||
+            existing === record) {
+            return record;
+        }
+        for (const [id, value] of Object.entries(record)) {
+            existing[id] = value;
+        }
+        return existing;
     }
     /**
      * Get interaction history for a session
@@ -396,75 +482,90 @@ export class SessionMonitor {
     /**
      * Perform comprehensive health checks on a session
      */
-    performComprehensiveHealthChecks(sessionId, health, issues, sessionStatus) {
+    performComprehensiveHealthChecks(sessionId, issues, sessionStatus) {
+        let status = "healthy";
         if (!sessionStatus.active) {
             issues.push("Session is not active");
-            health.status = "degraded";
+            status = "degraded";
         }
-        const interactions = this.interactionHistory.get(sessionId) || [];
-        const recentWindow = interactions.slice(-20);
+        const interactions = this.interactionHistory.get(sessionId);
+        const lastInteraction = interactions && interactions.length > 0
+            ? interactions[interactions.length - 1]
+            : undefined;
         const staleThreshold = 5 * 60 * 1000;
-        if (recentWindow.length > 0) {
-            const lastInteraction = recentWindow[recentWindow.length - 1];
-            if (lastInteraction) {
-                const timeSinceLastInteraction = Date.now() - lastInteraction.timestamp;
-                if (timeSinceLastInteraction > staleThreshold) {
-                    issues.push(`Stale session: no activity for ${Math.round(timeSinceLastInteraction / 1000)}s`);
-                    health.status = "degraded";
-                }
+        if (lastInteraction) {
+            const timeSinceLastInteraction = Date.now() - lastInteraction.timestamp;
+            if (timeSinceLastInteraction > staleThreshold) {
+                issues.push(`Stale session: no activity for ${Math.round(timeSinceLastInteraction / 1000)}s`);
+                status = "degraded";
             }
         }
-        const responseTimes = this.sessionResponseTimes.get(sessionId) || [];
-        if (responseTimes.length > 0) {
-            const avgResponseTime = responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length;
-            if (avgResponseTime > this.config.alertThresholds.maxResponseTime * 1.5) {
-                issues.push(`Elevated response time: ${avgResponseTime.toFixed(0)}ms average`);
-            }
+        const avgResponseTime = this.responseAverage(sessionId);
+        if (avgResponseTime > this.config.alertThresholds.maxResponseTime * 1.5) {
+            issues.push(`Elevated response time: ${avgResponseTime.toFixed(0)}ms average`);
         }
-        const coordinationEfficiency = this.calculateCoordinationEfficiency(sessionId, interactions);
+        const coordinationEfficiency = this.calculateCoordinationEfficiency(sessionId, interactions ?? []);
         if (coordinationEfficiency < this.config.alertThresholds.minCoordinationEfficiency) {
             issues.push(`Low coordination efficiency: ${(coordinationEfficiency * 100).toFixed(0)}%`);
-            health.status = "degraded";
+            status = "degraded";
         }
+        return status;
     }
     /**
      * Calculate failure ratio from interactions
      */
-    calculateFailureRatio(interactions) {
-        if (interactions.length === 0)
+    outcomeOf(sessionId) {
+        const outcomes = this.outcomeTotals.get(sessionId);
+        const success = outcomes?.success ?? 0;
+        const failed = outcomes?.failed ?? 0;
+        return { success, failed, total: success + failed };
+    }
+    responseAverage(sessionId) {
+        const totals = this.responseTotals.get(sessionId);
+        if (!totals || totals.count === 0)
+            return 0;
+        return totals.sum / totals.count;
+    }
+    hasDiverseRecentAgents(interactions) {
+        const start = Math.max(0, interactions.length - 10);
+        let first;
+        for (let index = start; index < interactions.length; index += 1) {
+            const agentId = interactions[index]?.agentId;
+            if (!agentId)
+                continue;
+            if (first === undefined)
+                first = agentId;
+            else if (agentId !== first)
+                return true;
+        }
+        return false;
+    }
+    calculateFailureRatio(sessionId) {
+        const { failed, total } = this.outcomeOf(sessionId);
+        if (total === 0)
             return 0;
-        const failures = interactions.filter(i => !i.success).length;
-        return failures / interactions.length;
+        return failed / total;
     }
     /**
      * Calculate conflict resolution rate from interactions
      */
-    calculateConflictResolutionRate(sessionId, interactions) {
-        if (interactions.length === 0)
+    calculateConflictResolutionRate(sessionId) {
+        const { success, total } = this.outcomeOf(sessionId);
+        if (total === 0)
             return 1.0;
-        const successfulInteractions = interactions.filter(i => i.success).length;
-        return successfulInteractions / interactions.length;
+        return success / total;
     }
     /**
      * Calculate coordination efficiency from interactions
      */
     calculateCoordinationEfficiency(sessionId, interactions) {
-        if (interactions.length === 0)
+        const { success, total } = this.outcomeOf(sessionId);
+        if (total === 0)
             return 1.0;
-        const successfulInteractions = interactions.filter(i => i.success).length;
-        const baseEfficiency = successfulInteractions / interactions.length;
-        const recentInteractions = interactions.slice(-10);
-        const hasMultipleAgents = new Set(recentInteractions.map(i => i.agentId).filter(Boolean)).size > 1;
-        const agentDiversityBonus = hasMultipleAgents ? 0.1 : 0;
+        const baseEfficiency = success / total;
+        const agentDiversityBonus = this.hasDiverseRecentAgents(interactions) ? 0.1 : 0;
         return Math.min(1.0, baseEfficiency + agentDiversityBonus);
     }
-    persistInteractionData() {
-        const interactionData = {};
-        for (const [sessionId, history] of this.interactionHistory) {
-            interactionData[sessionId] = history;
-        }
-        this.stateManager.set("monitor:interactions", interactionData);
-    }
     calculateSessionMemoryUsage(sessionId) {
         // Estimate memory usage based on session activity
         const interactions = this.interactionHistory.get(sessionId) || [];
@@ -475,26 +576,27 @@ export class SessionMonitor {
         return baseMemory + totalInteractions * perInteractionMemory;
     }
     countSessionConflicts(sessionId) {
-        // Estimate conflicts based on failed interactions
-        const interactions = this.interactionHistory.get(sessionId) || [];
-        const failedInteractions = interactions.filter(i => !i.success).length;
         // Conflicts are estimated as failed interactions that might indicate coordination issues
-        return Math.floor(failedInteractions * 0.1); // Assume 10% of failures are conflicts
+        return Math.floor(this.outcomeOf(sessionId).failed * 0.1);
     }
     calculateAverageResponseTime(sessionId) {
-        // Calculate average response time from recent metrics
-        const history = this.getMetricsHistory(sessionId, 10); // Last 10 metrics
-        if (history.length === 0)
+        const history = this.metricsHistory.get(sessionId);
+        if (!history || history.length === 0)
             return 0;
-        const totalResponseTime = history.reduce((sum, metric) => {
-            // Estimate response time based on coordination efficiency
-            // This is a simplified calculation
-            return (sum +
-                (metric.successfulInteractions > 0
+        const start = Math.max(0, history.length - 10);
+        let totalResponseTime = 0;
+        let counted = 0;
+        for (let index = start; index < history.length; index += 1) {
+            const metric = history[index];
+            if (!metric)
+                continue;
+            totalResponseTime +=
+                metric.successfulInteractions > 0
                     ? 1000 / metric.successfulInteractions
-                    : 1000));
-        }, 0);
-        return totalResponseTime / history.length;
+                    : 1000;
+            counted += 1;
+        }
+        return counted === 0 ? 0 : totalResponseTime / counted;
     }
 }
 export const createSessionMonitor = (stateManager, sessionCoordinator, cleanupManager, config) => {

package/dist/session/session-state-manager.d.ts

@@ -48,6 +48,10 @@ export declare class SessionStateManager {
     private dependencies;
     private sessionGroups;
     private failoverConfigs;
+    /** Stable store records. A field write patches one key instead of cloning the map. */
+    private dependencyRecord;
+    private groupRecord;
+    private failoverRecord;
     constructor(stateManager: XrayStateManager, sessionCoordinator: SessionCoordinator);
     /**
      * Share state between sessions
@@ -136,9 +140,16 @@ export declare class SessionStateManager {
     };
     private propagateDependencyUpdate;
     private rollbackMigration;
+    private trackDependency;
+    private trackGroup;
+    private trackFailover;
     private persistDependencies;
     private persistSessionGroups;
     private persistFailoverConfigs;
+    private loadPersistedRecords;
+    private readStoreRecord;
+    /** Patch the stored object so a pre-seeded key survives the first write. */
+    private adoptStoreRecord;
     shutdown(): void;
 }
 export declare const createSessionStateManager: (stateManager: XrayStateManager, sessionCoordinator: SessionCoordinator) => SessionStateManager;