@buley/hexgrid-3d 1.0.0 → 1.1.1

package/src/Snapshot.ts

@@ -1,31 +1,31 @@
 /**
  * Unified Snapshot API
- * 
+ *
  * Single comprehensive API to get ALL statistics, predictions, and insights
  * about the current game state in one easy method call.
- * 
+ *
  * @module Snapshot
- * 
+ *
  * @example Basic Usage
  * ```typescript
  * import { generateSnapshot } from '@buley/hexgrid-3d'
- * 
+ *
  * const snapshot = generateSnapshot(cells, history, conquests, getNeighbors)
- * 
+ *
  * // Access player data
  * console.log(snapshot.players[0].winProbability)  // 0.72
  * console.log(snapshot.players[0].sparklineAscii)  // "▁▂▃▅▆█"
- * 
+ *
  * // Access game state
  * console.log(snapshot.indices.dominance)  // 0.65
  * console.log(snapshot.predictions.likelyWinner)  // 2
- * 
+ *
  * // Get insights
  * console.log(snapshot.insights)
  * // ["🏆 Player 2 dominates with 65.2% of territory",
  * //  "🚀 Leader's territory growing steadily"]
  * ```
- * 
+ *
  * @example Full Response Object
  * ```typescript
  * // GameSnapshot example response:
@@ -35,7 +35,7 @@
  *   totalCells: 1000,
  *   occupiedCells: 850,
  *   playerCount: 4,
- *   
+ *
  *   players: [{
  *     id: 2,
  *     cellCount: 320,
@@ -64,7 +64,7 @@
  *     leadOverSecond: 45,
  *     turnsUntilOvertake: null
  *   }, ...],
- *   
+ *
  *   inequality: {
  *     gini: 0.42,
  *     theil: 0.35,
@@ -74,7 +74,7 @@
  *     zipfCoefficient: 1.15,
  *     interpretation: "Emerging dominance"
  *   },
- *   
+ *
  *   indices: {
  *     dominance: 0.65,
  *     volatility: 0.35,
@@ -82,7 +82,7 @@
  *     competitiveness: 0.45,
  *     stability: 0.68
  *   },
- *   
+ *
  *   predictions: {
  *     likelyWinner: 2,
  *     winnerConfidence: 0.72,
@@ -91,13 +91,13 @@
  *     secondPlaceChallenger: 3,
  *     comebackPossibility: 0.28
  *   },
- *   
+ *
  *   anomalies: {
  *     outliers: [{ playerId: 4, type: 'growth_explosion', ... }],
  *     hasAnomalies: true,
  *     anomalyCount: 1
  *   },
- *   
+ *
  *   insights: [
  *     "📈 Player 2 leads with majority control (37.6%)",
  *     "🚀 Leader's territory growing steadily (slope: 4.2/turn)",
@@ -134,8 +134,8 @@ import {
   sparkline,
   sparklineSvg,
   computeTerritoryStats,
-  type TerritoryStats
-} from './algorithms/AdvancedStatistics'
+  type TerritoryStats,
+} from './algorithms/AdvancedStatistics';
 
 import {
   BetaDistribution,
@@ -159,8 +159,8 @@ import {
   bayesianConquestRate,
   bayesianChangepoint,
   generateProbabilitySnapshot,
-  type ProbabilitySnapshot
-} from './algorithms/BayesianStatistics'
+  type ProbabilitySnapshot,
+} from './algorithms/BayesianStatistics';
 
 import {
   detectOutliersZScore,
@@ -178,10 +178,13 @@ import {
   type OutlierResult,
   type TimeSeriesAnomaly,
   type GameAnomaly,
-  type MultivariateOutlierResult
-} from './algorithms/OutlierDetection'
+  type MultivariateOutlierResult,
+} from './algorithms/OutlierDetection';
 
-import { findConnectedComponents, analyzeTerritorBoundaries } from './algorithms/GraphAlgorithms'
+import {
+  findConnectedComponents,
+  analyzeTerritorBoundaries,
+} from './algorithms/GraphAlgorithms';
 
 // ═══════════════════════════════════════════════════════════════════════════
 // UNIFIED SNAPSHOT TYPES
@@ -189,7 +192,7 @@ import { findConnectedComponents, analyzeTerritorBoundaries } from './algorithms
 
 /**
  * Player-specific statistics
- * 
+ *
  * @example
  * ```typescript
  * const player: PlayerSnapshot = {
@@ -224,76 +227,76 @@ import { findConnectedComponents, analyzeTerritorBoundaries } from './algorithms
  */
 export interface PlayerSnapshot {
   /** Unique player identifier */
-  id: number
-  
+  id: number;
+
   // Territory
   /** Current number of cells owned */
-  cellCount: number
+  cellCount: number;
   /** Fraction of total occupied cells (0-1) */
-  shareOfTotal: number
+  shareOfTotal: number;
   /** Current ranking (1 = leader) */
-  rank: number
-  
+  rank: number;
+
   // History
   /** Number of turns of history available */
-  historyLength: number
+  historyLength: number;
   /** Territory count history (last 20 turns unless includeFullHistory=true) */
-  history: number[]
+  history: number[];
   /** Recent territory trend direction */
-  recentTrend: 'growing' | 'shrinking' | 'stable'
+  recentTrend: 'growing' | 'shrinking' | 'stable';
   /** Linear regression slope (cells per turn) */
-  trendSlope: number
+  trendSlope: number;
   /** R² confidence in trend (0-1) */
-  trendConfidence: number
-  
+  trendConfidence: number;
+
   // Predictions
   /** Bayesian probability of winning (0-1) */
-  winProbability: number
+  winProbability: number;
   /** 95% credible interval for win probability */
-  winCredibleInterval: [number, number]
+  winCredibleInterval: [number, number];
   /** Forecasted territory for next 10 turns */
-  forecastNext10: number[]
+  forecastNext10: number[];
   /** Kalman filter smoothed estimate */
-  kalmanEstimate: number
+  kalmanEstimate: number;
   /** Kalman filter uncertainty (±) */
-  kalmanUncertainty: number
-  
+  kalmanUncertainty: number;
+
   // Performance
   /** Bayesian conquest success rate */
-  conquestRate: number
+  conquestRate: number;
   /** 95% credible interval for conquest rate */
-  conquestRateCI: [number, number]
+  conquestRateCI: [number, number];
   /** Average cells gained per turn */
-  avgGrowthPerTurn: number
+  avgGrowthPerTurn: number;
   /** Territory volatility (coefficient of variation) */
-  volatility: number
-  
+  volatility: number;
+
   // Topology
   /** Number of disconnected territory regions */
-  numRegions: number
+  numRegions: number;
   /** Size of largest connected region */
-  largestRegionSize: number
+  largestRegionSize: number;
   /** Number of cells on territory border */
-  borderCellCount: number
+  borderCellCount: number;
   /** Territory shape compactness (0-1, higher = more compact) */
-  compactness: number
-  
+  compactness: number;
+
   // Sparklines
   /** ASCII sparkline visualization of history */
-  sparklineAscii: string
+  sparklineAscii: string;
   /** SVG path data for sparkline */
-  sparklineSvgPath: string
-  
+  sparklineSvgPath: string;
+
   // Relative metrics
   /** Lead over second place (null if not leader) */
-  leadOverSecond: number | null
+  leadOverSecond: number | null;
   /** Estimated turns until this player could overtake leader */
-  turnsUntilOvertake: number | null
+  turnsUntilOvertake: number | null;
 }
 
 /**
  * Inequality metrics for territory distribution
- * 
+ *
  * @example
  * ```typescript
  * const inequality: InequalityMetrics = {
@@ -308,18 +311,18 @@ export interface PlayerSnapshot {
  * ```
  */
 export interface InequalityMetrics {
-  gini: number
-  theil: number
-  atkinson: number
-  herfindahl: number
-  paretoRatio: number
-  zipfCoefficient: number
-  interpretation: string
+  gini: number;
+  theil: number;
+  atkinson: number;
+  herfindahl: number;
+  paretoRatio: number;
+  zipfCoefficient: number;
+  interpretation: string;
 }
 
 /**
  * Diversity/entropy metrics for territory distribution
- * 
+ *
  * @example
  * ```typescript
  * const diversity: DiversityMetrics = {
@@ -332,16 +335,16 @@ export interface InequalityMetrics {
  * ```
  */
 export interface DiversityMetrics {
-  shannon: number
-  normalized: number
-  renyi: number
-  tsallis: number
-  interpretation: string
+  shannon: number;
+  normalized: number;
+  renyi: number;
+  tsallis: number;
+  interpretation: string;
 }
 
 /**
  * Distribution statistics for territory counts
- * 
+ *
  * @example
  * ```typescript
  * const distribution: DistributionMetrics = {
@@ -359,21 +362,21 @@ export interface DiversityMetrics {
  * ```
  */
 export interface DistributionMetrics {
-  mean: number
-  median: number
-  stdDev: number
-  skewness: number
-  kurtosis: number
-  coefficientOfVariation: number
-  iqr: number
-  min: number
-  max: number
-  range: number
+  mean: number;
+  median: number;
+  stdDev: number;
+  skewness: number;
+  kurtosis: number;
+  coefficientOfVariation: number;
+  iqr: number;
+  min: number;
+  max: number;
+  range: number;
 }
 
 /**
  * Game state indices (0-1 scale)
- * 
+ *
  * @example
  * ```typescript
  * const indices: GameIndices = {
@@ -387,20 +390,20 @@ export interface DistributionMetrics {
  */
 export interface GameIndices {
   /** How dominated by a single player (0=even, 1=total domination) */
-  dominance: number
+  dominance: number;
   /** How much territory changes each turn (0=static, 1=chaotic) */
-  volatility: number
+  volatility: number;
   /** How predictable outcomes are (0=random, 1=deterministic) */
-  predictability: number
+  predictability: number;
   /** How close the competition (0=decided, 1=neck-and-neck) */
-  competitiveness: number
+  competitiveness: number;
   /** How stable territory boundaries are (0=fluid, 1=locked) */
-  stability: number
+  stability: number;
 }
 
 /**
  * Game outcome predictions
- * 
+ *
  * @example
  * ```typescript
  * const predictions: GamePredictions = {
@@ -415,22 +418,22 @@ export interface GameIndices {
  */
 export interface GamePredictions {
   /** Player ID most likely to win */
-  likelyWinner: number | null
+  likelyWinner: number | null;
   /** Confidence in winner prediction (0-1) */
-  winnerConfidence: number
+  winnerConfidence: number;
   /** Estimated turns until victory condition */
-  estimatedTurnsToVictory: number | null
+  estimatedTurnsToVictory: number | null;
   /** Whether game is in endgame phase */
-  isEndgame: boolean
+  isEndgame: boolean;
   /** Second place player who could challenge */
-  secondPlaceChallenger: number | null
+  secondPlaceChallenger: number | null;
   /** Probability of comeback by non-leader */
-  comebackPossibility: number
+  comebackPossibility: number;
 }
 
 /**
  * Territory topology metrics
- * 
+ *
  * @example
  * ```typescript
  * const topology: TopologyMetrics = {
@@ -444,20 +447,20 @@ export interface GamePredictions {
  */
 export interface TopologyMetrics {
   /** Total disconnected regions across all players */
-  totalRegions: number
+  totalRegions: number;
   /** Average cells per region */
-  averageRegionSize: number
+  averageRegionSize: number;
   /** How fragmented territories are (0=solid, 1=scattered) */
-  territoryFragmentation: number
+  territoryFragmentation: number;
   /** Percentage of cells that are border cells */
-  borderCellPercentage: number
+  borderCellPercentage: number;
   /** Average compactness across all territories */
-  avgCompactness: number
+  avgCompactness: number;
 }
 
 /**
  * Time series analysis metrics
- * 
+ *
  * @example
  * ```typescript
  * const timeSeries: TimeSeriesMetrics = {
@@ -471,20 +474,20 @@ export interface TopologyMetrics {
  */
 export interface TimeSeriesMetrics {
   /** Overall trend type */
-  overallTrend: 'convergent' | 'divergent' | 'cyclical' | 'chaotic'
+  overallTrend: 'convergent' | 'divergent' | 'cyclical' | 'chaotic';
   /** Turn numbers where significant changes occurred */
-  changePoints: number[]
+  changePoints: number[];
   /** Strength of overall trend (0-1) */
-  trendStrength: number
+  trendStrength: number;
   /** Autocorrelation coefficient */
-  autocorrelation: number
+  autocorrelation: number;
   /** Whether periodic patterns detected */
-  seasonality: boolean
+  seasonality: boolean;
 }
 
 /**
  * Comparison metrics with past states
- * 
+ *
  * @example
  * ```typescript
  * const comparisons: ComparisonMetrics = {
@@ -497,18 +500,18 @@ export interface TimeSeriesMetrics {
  */
 export interface ComparisonMetrics {
   /** Territory change per player vs 5 turns ago */
-  vs5TurnsAgo: { [playerId: number]: number }
+  vs5TurnsAgo: { [playerId: number]: number };
   /** Territory change per player vs 10 turns ago */
-  vs10TurnsAgo: { [playerId: number]: number }
+  vs10TurnsAgo: { [playerId: number]: number };
   /** KL divergence from uniform distribution */
-  divergenceFromUniform: number
+  divergenceFromUniform: number;
   /** JS divergence from previous turn */
-  divergenceFromPrevious: number
+  divergenceFromPrevious: number;
 }
 
 /**
  * Anomaly detection summary
- * 
+ *
  * @example
  * ```typescript
  * const anomalies: AnomalySummary = {
@@ -528,18 +531,18 @@ export interface ComparisonMetrics {
  */
 export interface AnomalySummary {
   /** Detected game anomalies */
-  outliers: GameAnomaly[]
+  outliers: GameAnomaly[];
   /** Whether any anomalies were detected */
-  hasAnomalies: boolean
+  hasAnomalies: boolean;
   /** Total count of anomalies */
-  anomalyCount: number
+  anomalyCount: number;
   /** Type of most severe anomaly (if any) */
-  mostSevere: string | null
+  mostSevere: string | null;
 }
 
 /**
  * Complete game snapshot with all statistics
- * 
+ *
  * @example Full Response Structure
  * ```typescript
  * const snapshot: GameSnapshot = {
@@ -548,16 +551,16 @@ export interface AnomalySummary {
  *   totalCells: 1000,
  *   occupiedCells: 850,
  *   playerCount: 4,
- *   
+ *
  *   players: [
  *     { id: 2, cellCount: 320, shareOfTotal: 0.376, rank: 1, ... },
  *     { id: 1, cellCount: 210, shareOfTotal: 0.247, rank: 2, ... },
  *     { id: 3, cellCount: 180, shareOfTotal: 0.212, rank: 3, ... },
  *     { id: 4, cellCount: 140, shareOfTotal: 0.165, rank: 4, ... }
  *   ],
- *   
+ *
  *   territoryStats: { ... },
- *   
+ *
  *   inequality: {
  *     gini: 0.42,
  *     theil: 0.35,
@@ -567,7 +570,7 @@ export interface AnomalySummary {
  *     zipfCoefficient: 1.15,
  *     interpretation: "Emerging dominance"
  *   },
- *   
+ *
  *   diversity: {
  *     shannon: 1.85,
  *     normalized: 0.92,
@@ -575,14 +578,14 @@ export interface AnomalySummary {
  *     tsallis: 1.52,
  *     interpretation: "High diversity"
  *   },
- *   
+ *
  *   distribution: {
  *     mean: 212.5, median: 195, stdDev: 68.2,
  *     skewness: 0.65, kurtosis: 2.8,
  *     coefficientOfVariation: 0.32,
  *     iqr: 95, min: 140, max: 320, range: 180
  *   },
- *   
+ *
  *   indices: {
  *     dominance: 0.65,
  *     volatility: 0.35,
@@ -590,7 +593,7 @@ export interface AnomalySummary {
  *     competitiveness: 0.45,
  *     stability: 0.68
  *   },
- *   
+ *
  *   predictions: {
  *     likelyWinner: 2,
  *     winnerConfidence: 0.72,
@@ -599,19 +602,19 @@ export interface AnomalySummary {
  *     secondPlaceChallenger: 1,
  *     comebackPossibility: 0.28
  *   },
- *   
+ *
  *   anomalies: {
  *     outliers: [],
  *     hasAnomalies: false,
  *     anomalyCount: 0,
  *     mostSevere: null
  *   },
- *   
+ *
  *   probability: { winProbabilities: Map, ... },
  *   topology: { totalRegions: 8, ... },
  *   timeSeries: { overallTrend: 'divergent', ... },
  *   comparisons: { vs5TurnsAgo: {...}, ... },
- *   
+ *
  *   insights: [
  *     "📈 Player 2 leads with 37.6% of territory",
  *     "🚀 Leader's territory growing steadily",
@@ -623,67 +626,67 @@ export interface AnomalySummary {
 export interface GameSnapshot {
   // Basic
   /** Unix timestamp when snapshot was generated */
-  timestamp: number
+  timestamp: number;
   /** Current turn number */
-  turnNumber: number
+  turnNumber: number;
   /** Total cells on the grid */
-  totalCells: number
+  totalCells: number;
   /** Number of cells with an owner */
-  occupiedCells: number
-  
+  occupiedCells: number;
+
   // Players
   /** Number of active players */
-  playerCount: number
+  playerCount: number;
   /** Detailed stats for each player, sorted by rank */
-  players: PlayerSnapshot[]
-  
+  players: PlayerSnapshot[];
+
   // Overall territory stats
   /** Aggregate territory statistics */
-  territoryStats: TerritoryStats
-  
+  territoryStats: TerritoryStats;
+
   // Inequality metrics (all players)
   /** Inequality measures for territory distribution */
-  inequality: InequalityMetrics
-  
+  inequality: InequalityMetrics;
+
   // Entropy/diversity
   /** Diversity/entropy measures */
-  diversity: DiversityMetrics
-  
+  diversity: DiversityMetrics;
+
   // Distribution metrics
   /** Statistical distribution of territory counts */
-  distribution: DistributionMetrics
-  
+  distribution: DistributionMetrics;
+
   // Game state indices
   /** Normalized game state indicators */
-  indices: GameIndices
-  
+  indices: GameIndices;
+
   // Predictions
   /** Game outcome predictions */
-  predictions: GamePredictions
-  
+  predictions: GamePredictions;
+
   // Anomaly detection
   /** Detected anomalies and outliers */
-  anomalies: AnomalySummary
-  
+  anomalies: AnomalySummary;
+
   // Probability snapshot (Bayesian)
   /** Full Bayesian probability analysis */
-  probability: ProbabilitySnapshot
-  
+  probability: ProbabilitySnapshot;
+
   // Topology
   /** Territory topology metrics */
-  topology: TopologyMetrics
-  
+  topology: TopologyMetrics;
+
   // Time series insights
   /** Time series analysis */
-  timeSeries: TimeSeriesMetrics
-  
+  timeSeries: TimeSeriesMetrics;
+
   // Comparisons
   /** Comparisons with past states */
-  comparisons: ComparisonMetrics
-  
+  comparisons: ComparisonMetrics;
+
   // Recommendations / insights
   /** Human-readable insights and observations */
-  insights: string[]
+  insights: string[];
 }
 
 // Re-export all types for easy importing
@@ -693,8 +696,8 @@ export type {
   OutlierResult,
   TimeSeriesAnomaly,
   GameAnomaly,
-  MultivariateOutlierResult
-}
+  MultivariateOutlierResult,
+};
 
 // ═══════════════════════════════════════════════════════════════════════════
 // SNAPSHOT GENERATOR
@@ -702,15 +705,15 @@ export type {
 
 export interface SnapshotConfig {
   /** Number of turns for forecasting */
-  forecastHorizon?: number
+  forecastHorizon?: number;
   /** Number of Monte Carlo samples */
-  monteCarloSamples?: number
+  monteCarloSamples?: number;
   /** Include detailed history */
-  includeFullHistory?: boolean
+  includeFullHistory?: boolean;
   /** Calculate topology (can be expensive) */
-  calculateTopology?: boolean
+  calculateTopology?: boolean;
   /** Generate insights */
-  generateInsights?: boolean
+  generateInsights?: boolean;
 }
 
 /**
@@ -728,174 +731,220 @@ export function generateSnapshot(
     monteCarloSamples = 1000,
     includeFullHistory = false,
     calculateTopology = true,
-    generateInsights = true
-  } = config
-  
-  const timestamp = Date.now()
-  const totalCells = cells.length
-  
+    generateInsights = true,
+  } = config;
+
+  const timestamp = Date.now();
+  const totalCells = cells.length;
+
   // Count territories
-  const territoryCounts = new Map<number, number>()
+  const territoryCounts = new Map<number, number>();
   for (const cell of cells) {
     if (cell.owner !== 0) {
-      territoryCounts.set(cell.owner, (territoryCounts.get(cell.owner) ?? 0) + 1)
+      territoryCounts.set(
+        cell.owner,
+        (territoryCounts.get(cell.owner) ?? 0) + 1
+      );
     }
   }
-  
-  const occupiedCells = Array.from(territoryCounts.values()).reduce((a, b) => a + b, 0)
-  const players = Array.from(territoryCounts.keys()).sort((a, b) => a - b)
-  const playerCount = players.length
-  
+
+  const occupiedCells = Array.from(territoryCounts.values()).reduce(
+    (a, b) => a + b,
+    0
+  );
+  const players = Array.from(territoryCounts.keys()).sort((a, b) => a - b);
+  const playerCount = players.length;
+
   // Sort by territory size for ranking
-  const sortedBySize = [...players].sort((a, b) => 
-    (territoryCounts.get(b) ?? 0) - (territoryCounts.get(a) ?? 0)
-  )
-  
+  const sortedBySize = [...players].sort(
+    (a, b) => (territoryCounts.get(b) ?? 0) - (territoryCounts.get(a) ?? 0)
+  );
+
   // Compute turn number from history length
-  const turnNumber = Math.max(...Array.from(territoryHistory.values()).map(h => h.length), 0)
-  
-  // Territory stats
-  const territoryStats = computeTerritoryStats(territoryCounts, territoryHistory)
-  
-  // Get probability snapshot
-  const probability = generateProbabilitySnapshot(territoryHistory, conquestCounts, {
-    forecastSteps: forecastHorizon,
-    samples: monteCarloSamples
-  })
-  
+  const turnNumber = Math.max(
+    ...Array.from(territoryHistory.values()).map((h) => h.length),
+    0
+  );
+
+  // Territory stats - computeTerritoryStats expects Array<{ area: number; perimeter: number }>
+  // For now, create a simplified version
+  const territoryAreas = Array.from(territoryCounts.entries()).map(
+    ([_, count]) => ({
+      area: count,
+      perimeter: Math.sqrt(count) * 4, // Simplified perimeter calculation
+    })
+  );
+  const territoryStats = computeTerritoryStats(territoryAreas);
+
+  // Get probability snapshot - generateProbabilitySnapshot only takes labels: string[]
+  const playerLabels = Array.from(territoryCounts.keys()).map(String);
+  const probability = generateProbabilitySnapshot(playerLabels);
+
   // Compute player snapshots
-  const playerSnapshots: PlayerSnapshot[] = []
-  
+  const playerSnapshots: PlayerSnapshot[] = [];
+
   for (let rankIdx = 0; rankIdx < sortedBySize.length; rankIdx++) {
-    const playerId = sortedBySize[rankIdx]
-    const cellCount = territoryCounts.get(playerId) ?? 0
-    const history = territoryHistory.get(playerId) ?? []
-    
+    const playerId = sortedBySize[rankIdx];
+    const cellCount = territoryCounts.get(playerId) ?? 0;
+    const history = territoryHistory.get(playerId) ?? [];
+
     // Trend detection
-    const trend = history.length > 3 ? detectTrend(history) : null
-    
-    // Forecast
-    const { forecast } = history.length > 2 
-      ? doubleExponentialSmoothing(history, 0.3, 0.1)
-      : { forecast: () => [] }
-    const forecastNext10 = forecast(forecastHorizon)
-    
+    const trend = history.length > 3 ? detectTrend(history) : null;
+
+    // Forecast - doubleExponentialSmoothing returns number[], not an object with forecast method
+    const forecastValues =
+      history.length > 2 ? doubleExponentialSmoothing(history, 0.3, 0.1) : [];
+    const forecastNext10 = forecastValues.slice(0, forecastHorizon);
+
     // Kalman filter
-    let kalmanEstimate = cellCount
-    let kalmanUncertainty = 0
+    let kalmanEstimate = cellCount;
+    let kalmanUncertainty = 0;
     if (history.length > 3) {
-      const variance = history.slice(1).reduce((sum, v, i) => 
-        sum + (v - history[i]) ** 2, 0) / history.length
-      
+      const variance =
+        history.slice(1).reduce((sum, v, i) => sum + (v - history[i]) ** 2, 0) /
+        history.length;
+
       const filter = new KalmanFilter(
         history[0],
         variance || 1,
         (variance || 1) * 0.1,
         (variance || 1) * 0.5
-      )
-      
+      );
+
       for (const measurement of history) {
-        filter.step(measurement)
+        filter.update(measurement);
       }
-      
-      kalmanEstimate = filter.getState()
-      kalmanUncertainty = filter.getUncertainty()
+
+      kalmanEstimate = filter.getState();
+      kalmanUncertainty = filter.getUncertainty();
     }
-    
-    // Win probability
-    const winProb = probability.winProbabilities.get(playerId) ?? 0
-    const winCI = probability.winCredibleIntervals.get(playerId) ?? [0, 0]
-    
-    // Conquest rate
-    const conquests = conquestCounts.get(playerId) ?? { successes: 0, opportunities: 0 }
-    const conquestResult = bayesianConquestRate(conquests.successes, conquests.opportunities)
-    
+
+    // Win probability - ProbabilitySnapshot only has probabilities array
+    const playerProb = probability.probabilities.find(
+      (p) => p.label === String(playerId)
+    );
+    const winProb = playerProb?.probability ?? 0;
+    const winCI: [number, number] = [
+      Math.max(0, winProb - 0.1),
+      Math.min(1, winProb + 0.1),
+    ]; // Simplified CI
+
+    // Conquest rate - bayesianConquestRate returns a number, not an object
+    const conquests = conquestCounts.get(playerId) ?? {
+      successes: 0,
+      opportunities: 0,
+    };
+    const conquestRate = bayesianConquestRate(
+      conquests.successes,
+      conquests.opportunities
+    );
+    const conquestRateCI: [number, number] = [
+      Math.max(0, conquestRate - 0.1),
+      Math.min(1, conquestRate + 0.1),
+    ]; // Simplified CI
+
     // Volatility
-    const volatility = history.length > 1
-      ? Math.sqrt(history.slice(1).reduce((sum, v, i) => 
-          sum + (v - history[i]) ** 2, 0) / (history.length - 1)) / (cellCount || 1)
-      : 0
-    
+    const volatility =
+      history.length > 1
+        ? Math.sqrt(
+            history
+              .slice(1)
+              .reduce((sum, v, i) => sum + (v - history[i]) ** 2, 0) /
+              (history.length - 1)
+          ) / (cellCount || 1)
+        : 0;
+
     // Avg growth
-    const avgGrowth = history.length > 1
-      ? (history[history.length - 1] - history[0]) / history.length
-      : 0
-    
+    const avgGrowth =
+      history.length > 1
+        ? (history[history.length - 1] - history[0]) / history.length
+        : 0;
+
     // Topology
-    let numRegions = 1
-    let largestRegionSize = cellCount
-    let borderCellCount = 0
-    let playerCompactness = 0
-    
+    let numRegions = 1;
+    let largestRegionSize = cellCount;
+    let borderCellCount = 0;
+    let playerCompactness = 0;
+
     if (calculateTopology && cellCount > 0) {
-      const playerCells = new Set<number>()
+      const playerCells = new Set<number>();
       cells.forEach((cell, idx) => {
-        if (cell.owner === playerId) playerCells.add(idx)
-      })
-      
+        if (cell.owner === playerId) playerCells.add(idx);
+      });
+
       // Count regions using BFS
-      const visited = new Set<number>()
-      const regionSizes: number[] = []
-      
+      const visited = new Set<number>();
+      const regionSizes: number[] = [];
+
       for (const cellIdx of playerCells) {
-        if (visited.has(cellIdx)) continue
-        
-        const queue = [cellIdx]
-        visited.add(cellIdx)
-        let regionSize = 0
-        
+        if (visited.has(cellIdx)) continue;
+
+        const queue = [cellIdx];
+        visited.add(cellIdx);
+        let regionSize = 0;
+
         while (queue.length > 0) {
-          const current = queue.shift()!
-          regionSize++
-          
+          const current = queue.shift()!;
+          regionSize++;
+
           for (const neighbor of getNeighbors(current)) {
             if (playerCells.has(neighbor) && !visited.has(neighbor)) {
-              visited.add(neighbor)
-              queue.push(neighbor)
+              visited.add(neighbor);
+              queue.push(neighbor);
             }
           }
         }
-        
-        regionSizes.push(regionSize)
+
+        regionSizes.push(regionSize);
       }
-      
-      numRegions = regionSizes.length
-      largestRegionSize = Math.max(...regionSizes, 0)
-      
+
+      numRegions = regionSizes.length;
+      largestRegionSize = Math.max(...regionSizes, 0);
+
       // Border cells
       for (const cellIdx of playerCells) {
-        const neighbors = getNeighbors(cellIdx)
-        if (neighbors.some(n => !playerCells.has(n))) {
-          borderCellCount++
+        const neighbors = getNeighbors(cellIdx);
+        if (neighbors.some((n) => !playerCells.has(n))) {
+          borderCellCount++;
         }
       }
-      
-      // Compactness
-      playerCompactness = compactness(playerCells, getNeighbors)
+
+      // Compactness - compactness expects (area: number, perimeter: number)
+      const area = playerCells.size;
+      const perimeter = borderCellCount;
+      playerCompactness = compactness(area, perimeter);
     }
-    
+
     // Lead over second
-    const leadOverSecond = rankIdx === 0 && sortedBySize.length > 1
-      ? cellCount - (territoryCounts.get(sortedBySize[1]) ?? 0)
-      : null
-    
+    const leadOverSecond =
+      rankIdx === 0 && sortedBySize.length > 1
+        ? cellCount - (territoryCounts.get(sortedBySize[1]) ?? 0)
+        : null;
+
     // Turns until overtake (for non-leaders)
-    let turnsUntilOvertake: number | null = null
+    let turnsUntilOvertake: number | null = null;
     if (rankIdx > 0 && forecastNext10.length > 0) {
-      const leaderHistory = territoryHistory.get(sortedBySize[0]) ?? []
+      const leaderHistory = territoryHistory.get(sortedBySize[0]) ?? [];
       if (leaderHistory.length > 2) {
-        const { forecast: leaderForecast } = doubleExponentialSmoothing(leaderHistory, 0.3, 0.1)
-        const leaderPred = leaderForecast(forecastHorizon)
-        
-        for (let t = 0; t < forecastHorizon; t++) {
-          if (forecastNext10[t] > leaderPred[t]) {
-            turnsUntilOvertake = t + 1
-            break
+        const leaderForecast = doubleExponentialSmoothing(
+          leaderHistory,
+          0.3,
+          0.1
+        );
+        const leaderPred =
+          leaderForecast[leaderForecast.length - 1] ??
+          leaderHistory[leaderHistory.length - 1] ??
+          0;
+
+        for (let t = 0; t < forecastHorizon && t < forecastNext10.length; t++) {
+          if (forecastNext10[t] > leaderPred) {
+            turnsUntilOvertake = t + 1;
+            break;
           }
         }
       }
     }
-    
+
     playerSnapshots.push({
       id: playerId,
       cellCount,
@@ -903,7 +952,12 @@ export function generateSnapshot(
       rank: rankIdx + 1,
       historyLength: history.length,
       history: includeFullHistory ? [...history] : history.slice(-20),
-      recentTrend: trend?.direction === 'increasing' ? 'growing' : trend?.direction === 'decreasing' ? 'shrinking' : 'stable',
+      recentTrend:
+        trend?.direction === 'increasing'
+          ? 'growing'
+          : trend?.direction === 'decreasing'
+          ? 'shrinking'
+          : 'stable',
       trendSlope: trend?.slope ?? 0,
       trendConfidence: trend?.rSquared ?? 0,
       winProbability: winProb,
@@ -911,321 +965,424 @@ export function generateSnapshot(
       forecastNext10,
       kalmanEstimate,
       kalmanUncertainty,
-      conquestRate: conquestResult.pointEstimate,
-      conquestRateCI: conquestResult.credibleInterval,
+      conquestRate: conquestRate,
+      conquestRateCI: conquestRateCI,
       avgGrowthPerTurn: avgGrowth,
       volatility,
       numRegions,
       largestRegionSize,
       borderCellCount,
       compactness: playerCompactness,
-      sparklineAscii: sparkline(history.slice(-30), 20),
+      sparklineAscii: sparkline(history.slice(-30)),
       sparklineSvgPath: sparklineSvg(history.slice(-30), 100, 30),
       leadOverSecond,
-      turnsUntilOvertake
-    })
+      turnsUntilOvertake,
+    });
   }
-  
+
   // Inequality metrics
-  const values = Array.from(territoryCounts.values())
-  const gini = giniCoefficient(values)
-  const theil = theilIndex(values)
-  const atkinson = atkinsonIndex(values)
-  const herfindahl = herfindahlIndex(values)
-  const pareto = paretoRatio(values, 0.2)
-  const zipf = zipfCoefficient(values)
-  
-  let inequalityInterpretation: string
-  if (gini < 0.2) inequalityInterpretation = 'Highly balanced - fierce competition'
-  else if (gini < 0.4) inequalityInterpretation = 'Moderately balanced'
-  else if (gini < 0.6) inequalityInterpretation = 'Emerging dominance'
-  else if (gini < 0.8) inequalityInterpretation = 'Clear leader emerging'
-  else inequalityInterpretation = 'Near monopoly - game almost decided'
-  
+  const values = Array.from(territoryCounts.values());
+  const gini = giniCoefficient(values);
+  const theil = theilIndex(values);
+  const atkinson = atkinsonIndex(values, 0.5); // epsilon = 0.5 for standard calculation
+  const herfindahl = herfindahlIndex(values);
+  const pareto = paretoRatio(values, 0.2);
+  const zipf = zipfCoefficient(values);
+
+  let inequalityInterpretation: string;
+  if (gini < 0.2)
+    inequalityInterpretation = 'Highly balanced - fierce competition';
+  else if (gini < 0.4) inequalityInterpretation = 'Moderately balanced';
+  else if (gini < 0.6) inequalityInterpretation = 'Emerging dominance';
+  else if (gini < 0.8) inequalityInterpretation = 'Clear leader emerging';
+  else inequalityInterpretation = 'Near monopoly - game almost decided';
+
   // Diversity metrics
-  const shannon = shannonEntropy(values)
-  const normalized = normalizedEntropy(values)
-  const renyi = renyiEntropy(values)
-  const tsallis = tsallisEntropy(values)
-  
-  let diversityInterpretation: string
-  if (normalized > 0.9) diversityInterpretation = 'Maximum diversity - all players equal'
-  else if (normalized > 0.7) diversityInterpretation = 'High diversity'
-  else if (normalized > 0.5) diversityInterpretation = 'Moderate diversity'
-  else if (normalized > 0.3) diversityInterpretation = 'Low diversity - consolidation'
-  else diversityInterpretation = 'Minimal diversity - game nearly over'
-  
+  const shannon = shannonEntropy(values);
+  const normalized = normalizedEntropy(values);
+  const renyi = renyiEntropy(values, 2); // alpha = 2 for standard Renyi entropy
+  const tsallis = tsallisEntropy(values, 2); // q = 2 for standard Tsallis entropy
+
+  let diversityInterpretation: string;
+  if (normalized > 0.9)
+    diversityInterpretation = 'Maximum diversity - all players equal';
+  else if (normalized > 0.7) diversityInterpretation = 'High diversity';
+  else if (normalized > 0.5) diversityInterpretation = 'Moderate diversity';
+  else if (normalized > 0.3)
+    diversityInterpretation = 'Low diversity - consolidation';
+  else diversityInterpretation = 'Minimal diversity - game nearly over';
+
   // Distribution metrics
-  const sorted = [...values].sort((a, b) => a - b)
-  const mean = values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0
-  const median = values.length > 0 
-    ? (values.length % 2 === 0 
-        ? (sorted[values.length / 2 - 1] + sorted[values.length / 2]) / 2 
-        : sorted[Math.floor(values.length / 2)])
-    : 0
-  const variance = values.length > 0
-    ? values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length
-    : 0
-  const stdDev = Math.sqrt(variance)
-  
-  let m3 = 0, m4 = 0
+  const sorted = [...values].sort((a, b) => a - b);
+  const mean =
+    values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0;
+  const median =
+    values.length > 0
+      ? values.length % 2 === 0
+        ? (sorted[values.length / 2 - 1] + sorted[values.length / 2]) / 2
+        : sorted[Math.floor(values.length / 2)]
+      : 0;
+  const variance =
+    values.length > 0
+      ? values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length
+      : 0;
+  const stdDev = Math.sqrt(variance);
+
+  let m3 = 0,
+    m4 = 0;
   for (const v of values) {
-    const diff = v - mean
-    m3 += diff ** 3
-    m4 += diff ** 4
+    const diff = v - mean;
+    m3 += diff ** 3;
+    m4 += diff ** 4;
   }
-  const skewness = values.length > 0 && stdDev > 0 
-    ? (m3 / values.length) / (stdDev ** 3) 
-    : 0
-  const kurtosis = values.length > 0 && stdDev > 0 
-    ? (m4 / values.length) / (stdDev ** 4) - 3 
-    : 0
-  
-  const q1 = sorted[Math.floor(sorted.length * 0.25)] ?? 0
-  const q3 = sorted[Math.floor(sorted.length * 0.75)] ?? 0
-  
-  // Game state indices
-  const dominance = probability.dominanceIndex
-  const volatility = probability.volatilityIndex
-  const predictability = probability.predictability
-  
+  const skewness =
+    values.length > 0 && stdDev > 0 ? m3 / values.length / stdDev ** 3 : 0;
+  const kurtosis =
+    values.length > 0 && stdDev > 0 ? m4 / values.length / stdDev ** 4 - 3 : 0;
+
+  const q1 = sorted[Math.floor(sorted.length * 0.25)] ?? 0;
+  const q3 = sorted[Math.floor(sorted.length * 0.75)] ?? 0;
+
+  // Game state indices - ProbabilitySnapshot doesn't have these, calculate from data
+  const topPlayerShare =
+    sortedBySize.length > 0
+      ? (territoryCounts.get(sortedBySize[0]) ?? 0) / occupiedCells
+      : 0;
+  const dominance = topPlayerShare; // Simplified dominance index
+
   // Competitiveness: inverse of lead
-  const topTwoShare = sortedBySize.length >= 2
-    ? ((territoryCounts.get(sortedBySize[0]) ?? 0) + (territoryCounts.get(sortedBySize[1]) ?? 0)) / occupiedCells
-    : 1
-  const competitiveness = sortedBySize.length >= 2
-    ? 1 - Math.abs(
-        (territoryCounts.get(sortedBySize[0]) ?? 0) - (territoryCounts.get(sortedBySize[1]) ?? 0)
-      ) / occupiedCells
-    : 0
-  
+  const topTwoShare =
+    sortedBySize.length >= 2
+      ? ((territoryCounts.get(sortedBySize[0]) ?? 0) +
+          (territoryCounts.get(sortedBySize[1]) ?? 0)) /
+        occupiedCells
+      : 1;
+  const competitiveness =
+    sortedBySize.length >= 2
+      ? 1 -
+        Math.abs(
+          (territoryCounts.get(sortedBySize[0]) ?? 0) -
+            (territoryCounts.get(sortedBySize[1]) ?? 0)
+        ) /
+          occupiedCells
+      : 0;
+
   // Stability: inverse of avg change rate
-  let totalChangeRate = 0
-  let historyCount = 0
+  let totalChangeRate = 0;
+  let historyCount = 0;
   for (const [, history] of territoryHistory) {
     if (history.length > 1) {
-      const changes = history.slice(1).map((v, i) => Math.abs(v - history[i]))
-      const avgChange = changes.reduce((a, b) => a + b, 0) / changes.length
-      totalChangeRate += avgChange / (history[history.length - 1] || 1)
-      historyCount++
+      const changes = history.slice(1).map((v, i) => Math.abs(v - history[i]));
+      const avgChange = changes.reduce((a, b) => a + b, 0) / changes.length;
+      totalChangeRate += avgChange / (history[history.length - 1] || 1);
+      historyCount++;
     }
   }
-  const stability = historyCount > 0 ? Math.max(0, 1 - totalChangeRate / historyCount) : 0.5
-  
+  const stability =
+    historyCount > 0 ? Math.max(0, 1 - totalChangeRate / historyCount) : 0.5;
+
   // Predictions
-  const likelyWinner = probability.estimatedTurnsToVictory !== null ? sortedBySize[0] : null
-  const winnerConfidence = probability.overallConfidence
-  const estimatedTurnsToVictory = probability.estimatedTurnsToVictory
-  
-  const isEndgame = gini > 0.7 || (
-    sortedBySize.length >= 2 &&
-    (territoryCounts.get(sortedBySize[0]) ?? 0) > occupiedCells * 0.6
-  )
-  
-  const secondPlaceChallenger = sortedBySize.length >= 2 ? sortedBySize[1] : null
-  
-  // Comeback possibility based on volatility and current gap
-  const comebackPossibility = sortedBySize.length >= 2
-    ? Math.min(1, volatility + (1 - dominance)) * (1 - winnerConfidence)
-    : 0
-  
-  // Topology summary
-  let totalRegions = 0
-  let totalBorderCells = 0
-  let compactnessSum = 0
-  
-  for (const player of playerSnapshots) {
-    totalRegions += player.numRegions
-    totalBorderCells += player.borderCellCount
-    compactnessSum += player.compactness
+  // Calculate estimated turns to victory from forecast data
+  const likelyWinner = sortedBySize.length > 0 ? sortedBySize[0] : null;
+  const winnerConfidence = topPlayerShare; // Simplified confidence
+  // Estimate turns to victory based on forecast (simplified)
+  let estimatedTurnsToVictory: number | null = null;
+  if (sortedBySize.length > 0 && territoryHistory.has(sortedBySize[0])) {
+    const leaderHistory = territoryHistory.get(sortedBySize[0]) ?? [];
+    if (leaderHistory.length > 0) {
+      const currentShare =
+        (territoryCounts.get(sortedBySize[0]) ?? 0) / occupiedCells;
+      const targetShare = 0.5; // 50% to win
+      if (currentShare < targetShare && leaderHistory.length > 1) {
+        const growthRate =
+          (leaderHistory[leaderHistory.length - 1] - leaderHistory[0]) /
+          leaderHistory.length;
+        if (growthRate > 0) {
+          estimatedTurnsToVictory = Math.ceil(
+            (targetShare * occupiedCells -
+              (territoryCounts.get(sortedBySize[0]) ?? 0)) /
+              growthRate
+          );
+        }
+      }
+    }
   }
-  
-  const averageRegionSize = totalRegions > 0 ? occupiedCells / totalRegions : 0
-  const territoryFragmentation = playerCount > 0 ? (totalRegions - playerCount) / (occupiedCells || 1) : 0
-  const borderCellPercentage = occupiedCells > 0 ? totalBorderCells / occupiedCells : 0
-  const avgCompactness = playerCount > 0 ? compactnessSum / playerCount : 0
-  
+
+  const isEndgame =
+    gini > 0.7 ||
+    (sortedBySize.length >= 2 &&
+      (territoryCounts.get(sortedBySize[0]) ?? 0) > occupiedCells * 0.6);
+
+  const secondPlaceChallenger =
+    sortedBySize.length >= 2 ? sortedBySize[1] : null;
+
+  // Calculate volatility early for use in comebackPossibility
   // Time series insights
-  let overallTrend: 'convergent' | 'divergent' | 'cyclical' | 'chaotic' = 'chaotic'
-  
+  let overallTrend: 'convergent' | 'divergent' | 'cyclical' | 'chaotic' =
+    'chaotic';
+
   // Check if shares are converging or diverging
-  const recentVariances: number[] = []
-  const historyLen = Math.min(...Array.from(territoryHistory.values()).map(h => h.length))
-  
+  const recentVariances: number[] = [];
+  const historyLen = Math.min(
+    ...Array.from(territoryHistory.values()).map((h) => h.length)
+  );
+
   for (let t = Math.max(0, historyLen - 10); t < historyLen; t++) {
-    const sharesAtT = players.map(p => {
-      const h = territoryHistory.get(p) ?? []
-      return h[t] ?? 0
-    })
-    const meanAtT = sharesAtT.reduce((a, b) => a + b, 0) / sharesAtT.length
-    const varAtT = sharesAtT.reduce((sum, s) => sum + (s - meanAtT) ** 2, 0) / sharesAtT.length
-    recentVariances.push(varAtT)
+    const sharesAtT = players.map((p) => {
+      const h = territoryHistory.get(p) ?? [];
+      return h[t] ?? 0;
+    });
+    const meanAtT = sharesAtT.reduce((a, b) => a + b, 0) / sharesAtT.length;
+    const varAtT =
+      sharesAtT.reduce((sum, s) => sum + (s - meanAtT) ** 2, 0) /
+      sharesAtT.length;
+    recentVariances.push(varAtT);
   }
-  
+
+  // Calculate volatility and predictability from recentVariances
+  const volatility =
+    recentVariances.length > 0
+      ? Math.sqrt(
+          recentVariances.reduce((a, b) => a + b, 0) / recentVariances.length
+        )
+      : 0;
+  const predictability = 1 - Math.min(1, volatility); // Simplified predictability (inverse of volatility)
+
+  // Comeback possibility based on volatility and current gap
+  const comebackPossibility =
+    sortedBySize.length >= 2
+      ? Math.min(1, volatility + (1 - dominance)) * (1 - winnerConfidence)
+      : 0;
+
+  // Topology summary
+  let totalRegions = 0;
+  let totalBorderCells = 0;
+  let compactnessSum = 0;
+
+  for (const player of playerSnapshots) {
+    totalRegions += player.numRegions;
+    totalBorderCells += player.borderCellCount;
+    compactnessSum += player.compactness;
+  }
+
+  const averageRegionSize = totalRegions > 0 ? occupiedCells / totalRegions : 0;
+  const territoryFragmentation =
+    playerCount > 0 ? (totalRegions - playerCount) / (occupiedCells || 1) : 0;
+  const borderCellPercentage =
+    occupiedCells > 0 ? totalBorderCells / occupiedCells : 0;
+  const avgCompactness = playerCount > 0 ? compactnessSum / playerCount : 0;
+
   if (recentVariances.length > 3) {
-    const varianceTrend = detectTrend(recentVariances)
-    if (varianceTrend.direction === 'decreasing' && varianceTrend.rSquared > 0.5) {
-      overallTrend = 'convergent'
-    } else if (varianceTrend.direction === 'increasing' && varianceTrend.rSquared > 0.5) {
-      overallTrend = 'divergent'
-    } else if (varianceTrend.rSquared < 0.2) {
-      overallTrend = 'chaotic'
+    const varianceTrend = detectTrend(recentVariances);
+    const rSquared = varianceTrend.rSquared ?? 0;
+    if (varianceTrend.direction === 'decreasing' && rSquared > 0.5) {
+      overallTrend = 'convergent';
+    } else if (varianceTrend.direction === 'increasing' && rSquared > 0.5) {
+      overallTrend = 'divergent';
+    } else if (rSquared < 0.2) {
+      overallTrend = 'chaotic';
     } else {
-      overallTrend = 'cyclical'
+      overallTrend = 'cyclical';
     }
   }
-  
+
   // Overall change points
-  const overallHistory = Array.from(territoryHistory.values())[0] ?? []
-  const changePoints = detectChangePoints(overallHistory, 2.0)
-  
+  const overallHistory = Array.from(territoryHistory.values())[0] ?? [];
+  const changePoints = detectChangePoints(overallHistory);
+
   // Trend strength
-  const overallHistoryTrend = overallHistory.length > 3 ? detectTrend(overallHistory) : null
-  const trendStrength = overallHistoryTrend?.rSquared ?? 0
-  
+  const overallHistoryTrend =
+    overallHistory.length > 3 ? detectTrend(overallHistory) : null;
+  const trendStrength = overallHistoryTrend?.rSquared ?? 0;
+
   // Autocorrelation (lag 1)
-  let autocorrelation = 0
+  let autocorrelation = 0;
   if (overallHistory.length > 5) {
-    const ohMean = overallHistory.reduce((a, b) => a + b, 0) / overallHistory.length
-    let num = 0, denom = 0
+    const ohMean =
+      overallHistory.reduce((a, b) => a + b, 0) / overallHistory.length;
+    let num = 0,
+      denom = 0;
     for (let i = 1; i < overallHistory.length; i++) {
-      num += (overallHistory[i] - ohMean) * (overallHistory[i - 1] - ohMean)
+      num += (overallHistory[i] - ohMean) * (overallHistory[i - 1] - ohMean);
     }
     for (let i = 0; i < overallHistory.length; i++) {
-      denom += (overallHistory[i] - ohMean) ** 2
+      denom += (overallHistory[i] - ohMean) ** 2;
     }
-    autocorrelation = denom > 0 ? num / denom : 0
+    autocorrelation = denom > 0 ? num / denom : 0;
   }
-  
+
   // Seasonality (simple check)
-  const seasonality = false // TODO: implement proper seasonality detection
-  
+  const seasonality = false; // TODO: implement proper seasonality detection
+
   // Comparisons
-  const vs5TurnsAgo: { [playerId: number]: number } = {}
-  const vs10TurnsAgo: { [playerId: number]: number } = {}
-  
+  const vs5TurnsAgo: { [playerId: number]: number } = {};
+  const vs10TurnsAgo: { [playerId: number]: number } = {};
+
   for (const [player, history] of territoryHistory) {
-    const current = history[history.length - 1] ?? 0
-    const fiveAgo = history[history.length - 6] ?? current
-    const tenAgo = history[history.length - 11] ?? current
-    
-    vs5TurnsAgo[player] = current - fiveAgo
-    vs10TurnsAgo[player] = current - tenAgo
+    const current = history[history.length - 1] ?? 0;
+    const fiveAgo = history[history.length - 6] ?? current;
+    const tenAgo = history[history.length - 11] ?? current;
+
+    vs5TurnsAgo[player] = current - fiveAgo;
+    vs10TurnsAgo[player] = current - tenAgo;
   }
-  
+
   // Divergence from uniform
-  const uniformProbs = values.map(() => 1 / values.length)
-  const actualProbs = values.map(v => v / (occupiedCells || 1))
-  const divergenceFromUniform = klDivergence(actualProbs, uniformProbs)
-  
+  const uniformProbs = values.map(() => 1 / values.length);
+  const actualProbs = values.map((v) => v / (occupiedCells || 1));
+  const divergenceFromUniform = klDivergence(actualProbs, uniformProbs);
+
   // Divergence from previous turn
-  let divergenceFromPrevious = 0
+  let divergenceFromPrevious = 0;
   if (historyLen > 1) {
-    const prevProbs = players.map(p => {
-      const h = territoryHistory.get(p) ?? []
-      return (h[h.length - 2] ?? 0) / (occupiedCells || 1)
-    })
-    divergenceFromPrevious = jsDivergence(actualProbs, prevProbs)
+    const prevProbs = players.map((p) => {
+      const h = territoryHistory.get(p) ?? [];
+      return (h[h.length - 2] ?? 0) / (occupiedCells || 1);
+    });
+    divergenceFromPrevious = jsDivergence(actualProbs, prevProbs);
   }
-  
+
   // Generate insights
-  const insights: string[] = []
-  
+  const insights: string[] = [];
+
   if (generateInsights) {
     // Leader insights
     if (sortedBySize.length > 0) {
-      const leader = playerSnapshots.find(p => p.rank === 1)!
-      const leaderShare = leader.shareOfTotal
-      
+      const leader = playerSnapshots.find((p) => p.rank === 1)!;
+      const leaderShare = leader.shareOfTotal;
+
       if (leaderShare > 0.8) {
-        insights.push(`🏆 Player ${leader.id} dominates with ${(leaderShare * 100).toFixed(1)}% of territory`)
+        insights.push(
+          `🏆 Player ${leader.id} dominates with ${(leaderShare * 100).toFixed(
+            1
+          )}% of territory`
+        );
       } else if (leaderShare > 0.5) {
-        insights.push(`📈 Player ${leader.id} leads with majority control (${(leaderShare * 100).toFixed(1)}%)`)
+        insights.push(
+          `📈 Player ${leader.id} leads with majority control (${(
+            leaderShare * 100
+          ).toFixed(1)}%)`
+        );
       }
-      
+
       if (leader.recentTrend === 'growing' && leader.trendConfidence > 0.7) {
-        insights.push(`🚀 Leader's territory growing steadily (slope: ${leader.trendSlope.toFixed(2)}/turn)`)
-      } else if (leader.recentTrend === 'shrinking' && leader.trendConfidence > 0.7) {
-        insights.push(`⚠️ Leader losing ground - opportunity for challengers!`)
+        insights.push(
+          `🚀 Leader's territory growing steadily (slope: ${leader.trendSlope.toFixed(
+            2
+          )}/turn)`
+        );
+      } else if (
+        leader.recentTrend === 'shrinking' &&
+        leader.trendConfidence > 0.7
+      ) {
+        insights.push(`⚠️ Leader losing ground - opportunity for challengers!`);
       }
     }
-    
+
     // Challenger insights
     if (sortedBySize.length >= 2) {
-      const challenger = playerSnapshots.find(p => p.rank === 2)!
-      
+      const challenger = playerSnapshots.find((p) => p.rank === 2)!;
+
       if (challenger.winProbability > 0.3) {
-        insights.push(`🎯 Player ${challenger.id} has ${(challenger.winProbability * 100).toFixed(1)}% chance of winning`)
+        insights.push(
+          `🎯 Player ${challenger.id} has ${(
+            challenger.winProbability * 100
+          ).toFixed(1)}% chance of winning`
+        );
       }
-      
-      if (challenger.turnsUntilOvertake !== null && challenger.turnsUntilOvertake < 5) {
-        insights.push(`⚡ Player ${challenger.id} could overtake in ~${challenger.turnsUntilOvertake} turns!`)
+
+      if (
+        challenger.turnsUntilOvertake !== null &&
+        challenger.turnsUntilOvertake < 5
+      ) {
+        insights.push(
+          `⚡ Player ${challenger.id} could overtake in ~${challenger.turnsUntilOvertake} turns!`
+        );
       }
     }
-    
+
     // Game state insights
     if (isEndgame) {
-      insights.push(`🔚 Endgame detected - victory imminent`)
+      insights.push(`🔚 Endgame detected - victory imminent`);
     }
-    
+
     if (competitiveness > 0.9) {
-      insights.push(`🔥 Extremely close competition - anyone could win!`)
+      insights.push(`🔥 Extremely close competition - anyone could win!`);
     }
-    
+
     if (volatility > 0.7) {
-      insights.push(`🌊 High volatility - expect rapid changes`)
+      insights.push(`🌊 High volatility - expect rapid changes`);
     } else if (volatility < 0.2) {
-      insights.push(`🪨 Low volatility - stable territorial lines`)
+      insights.push(`🪨 Low volatility - stable territorial lines`);
     }
-    
+
     if (comebackPossibility > 0.5) {
-      insights.push(`🔄 Comeback still possible (${(comebackPossibility * 100).toFixed(0)}% chance)`)
+      insights.push(
+        `🔄 Comeback still possible (${(comebackPossibility * 100).toFixed(
+          0
+        )}% chance)`
+      );
     }
-    
+
     // Topology insights
     if (territoryFragmentation > 0.2) {
-      insights.push(`🧩 High fragmentation - territories are scattered`)
+      insights.push(`🧩 High fragmentation - territories are scattered`);
     }
-    
+
     if (avgCompactness < 0.3) {
-      insights.push(`📏 Territories have irregular borders - vulnerable to attack`)
+      insights.push(
+        `📏 Territories have irregular borders - vulnerable to attack`
+      );
     }
-    
+
     // Change point insights
     if (changePoints.length > 0) {
-      const recentChangePoint = changePoints[changePoints.length - 1]
+      const recentChangePoint = changePoints[changePoints.length - 1];
       if (turnNumber - recentChangePoint < 5) {
-        insights.push(`📊 Recent momentum shift detected at turn ${recentChangePoint}`)
+        insights.push(
+          `📊 Recent momentum shift detected at turn ${recentChangePoint}`
+        );
       }
     }
-    
+
     // Trend insights
     if (overallTrend === 'convergent') {
-      insights.push(`📉 Territories are converging - expect stalemate or final push`)
+      insights.push(
+        `📉 Territories are converging - expect stalemate or final push`
+      );
     } else if (overallTrend === 'divergent') {
-      insights.push(`📈 Gap widening - leader pulling ahead`)
+      insights.push(`📈 Gap widening - leader pulling ahead`);
     }
   }
-  
-  // Detect anomalies
-  const gameAnomalies = detectGameAnomalies(territoryHistory)
-  
+
+  // Detect anomalies - detectGameAnomalies expects number[], convert territoryHistory
+  const allHistoryValues: number[] = [];
+  for (const [, history] of territoryHistory) {
+    allHistoryValues.push(...history);
+  }
+  const gameAnomalies = detectGameAnomalies(allHistoryValues);
+
   const anomalies: AnomalySummary = {
     outliers: gameAnomalies,
     hasAnomalies: gameAnomalies.length > 0,
     anomalyCount: gameAnomalies.length,
-    mostSevere: gameAnomalies.length > 0
-      ? gameAnomalies.reduce((max, a) => a.deviationFactor > (max?.deviationFactor ?? 0) ? a : max, gameAnomalies[0]).type
-      : null
-  }
-  
+    mostSevere:
+      gameAnomalies.length > 0
+        ? gameAnomalies.reduce(
+            (max, a) => (a.severity > (max?.severity ?? 0) ? a : max),
+            gameAnomalies[0]
+          ).type
+        : null,
+  };
+
   // Add anomaly insights
   if (generateInsights && anomalies.hasAnomalies) {
-    for (const anomaly of gameAnomalies.slice(0, 3)) {  // Top 3 anomalies
-      insights.push(`⚠️ Anomaly: ${anomaly.description}`)
+    for (const anomaly of gameAnomalies.slice(0, 3)) {
+      // Top 3 anomalies
+      insights.push(`⚠️ Anomaly: ${anomaly.description}`);
     }
   }
-  
+
   return {
     timestamp,
     turnNumber,
@@ -1241,14 +1398,14 @@ export function generateSnapshot(
       herfindahl,
       paretoRatio: pareto.ratioHeld,
       zipfCoefficient: zipf,
-      interpretation: inequalityInterpretation
+      interpretation: inequalityInterpretation,
     },
     diversity: {
       shannon,
       normalized,
       renyi,
       tsallis,
-      interpretation: diversityInterpretation
+      interpretation: diversityInterpretation,
     },
     distribution: {
       mean,
@@ -1260,14 +1417,14 @@ export function generateSnapshot(
       iqr: q3 - q1,
       min: sorted[0] ?? 0,
       max: sorted[sorted.length - 1] ?? 0,
-      range: (sorted[sorted.length - 1] ?? 0) - (sorted[0] ?? 0)
+      range: (sorted[sorted.length - 1] ?? 0) - (sorted[0] ?? 0),
     },
     indices: {
       dominance,
       volatility,
       predictability,
       competitiveness,
-      stability
+      stability,
     },
     predictions: {
       likelyWinner,
@@ -1275,7 +1432,7 @@ export function generateSnapshot(
       estimatedTurnsToVictory,
       isEndgame,
       secondPlaceChallenger,
-      comebackPossibility
+      comebackPossibility,
     },
     anomalies,
     probability,
@@ -1284,119 +1441,167 @@ export function generateSnapshot(
       averageRegionSize,
       territoryFragmentation,
       borderCellPercentage,
-      avgCompactness
+      avgCompactness,
     },
     timeSeries: {
       overallTrend,
       changePoints,
       trendStrength,
       autocorrelation,
-      seasonality
+      seasonality,
     },
     comparisons: {
       vs5TurnsAgo,
       vs10TurnsAgo,
       divergenceFromUniform,
-      divergenceFromPrevious
+      divergenceFromPrevious,
     },
-    insights
-  }
+    insights,
+  };
 }
 
 /**
  * Format snapshot as human-readable text
  */
 export function formatSnapshotAsText(snapshot: GameSnapshot): string {
-  const lines: string[] = []
-  
-  lines.push('═══════════════════════════════════════════════════════════')
-  lines.push(`  GAME SNAPSHOT - Turn ${snapshot.turnNumber}`)
-  lines.push('═══════════════════════════════════════════════════════════')
-  lines.push('')
-  
-  lines.push(`📊 Territory: ${snapshot.occupiedCells}/${snapshot.totalCells} cells occupied`)
-  lines.push(`👥 Players: ${snapshot.playerCount}`)
-  lines.push('')
-  
-  lines.push('┌─────────────────────────────────────────────────────────┐')
-  lines.push('│ PLAYER STANDINGS                                        │')
-  lines.push('├─────────────────────────────────────────────────────────┤')
-  
+  const lines: string[] = [];
+
+  lines.push('═══════════════════════════════════════════════════════════');
+  lines.push(`  GAME SNAPSHOT - Turn ${snapshot.turnNumber}`);
+  lines.push('═══════════════════════════════════════════════════════════');
+  lines.push('');
+
+  lines.push(
+    `📊 Territory: ${snapshot.occupiedCells}/${snapshot.totalCells} cells occupied`
+  );
+  lines.push(`👥 Players: ${snapshot.playerCount}`);
+  lines.push('');
+
+  lines.push('┌─────────────────────────────────────────────────────────┐');
+  lines.push('│ PLAYER STANDINGS                                        │');
+  lines.push('├─────────────────────────────────────────────────────────┤');
+
   for (const player of snapshot.players) {
-    const bar = '█'.repeat(Math.ceil(player.shareOfTotal * 20))
-    const pad = ' '.repeat(20 - bar.length)
-    const trend = player.recentTrend === 'growing' ? '↑' : 
-                  player.recentTrend === 'shrinking' ? '↓' : '→'
-    
-    lines.push(`│ #${player.rank} Player ${player.id}: ${player.cellCount} cells (${(player.shareOfTotal * 100).toFixed(1)}%)`)
-    lines.push(`│    ${bar}${pad} ${trend}`)
-    lines.push(`│    Win Prob: ${(player.winProbability * 100).toFixed(1)}%  Sparkline: ${player.sparklineAscii}`)
-    lines.push('│')
+    const bar = '█'.repeat(Math.ceil(player.shareOfTotal * 20));
+    const pad = ' '.repeat(20 - bar.length);
+    const trend =
+      player.recentTrend === 'growing'
+        ? '↑'
+        : player.recentTrend === 'shrinking'
+        ? '↓'
+        : '→';
+
+    lines.push(
+      `│ #${player.rank} Player ${player.id}: ${player.cellCount} cells (${(
+        player.shareOfTotal * 100
+      ).toFixed(1)}%)`
+    );
+    lines.push(`│    ${bar}${pad} ${trend}`);
+    lines.push(
+      `│    Win Prob: ${(player.winProbability * 100).toFixed(
+        1
+      )}%  Sparkline: ${player.sparklineAscii}`
+    );
+    lines.push('│');
   }
-  
-  lines.push('└─────────────────────────────────────────────────────────┘')
-  lines.push('')
-  
-  lines.push('┌─────────────────────────────────────────────────────────┐')
-  lines.push('│ GAME STATE                                              │')
-  lines.push('├─────────────────────────────────────────────────────────┤')
-  lines.push(`│ Dominance:      ${progressBar(snapshot.indices.dominance)}  ${(snapshot.indices.dominance * 100).toFixed(0)}%`)
-  lines.push(`│ Volatility:     ${progressBar(snapshot.indices.volatility)}  ${(snapshot.indices.volatility * 100).toFixed(0)}%`)
-  lines.push(`│ Competitiveness:${progressBar(snapshot.indices.competitiveness)}  ${(snapshot.indices.competitiveness * 100).toFixed(0)}%`)
-  lines.push(`│ Stability:      ${progressBar(snapshot.indices.stability)}  ${(snapshot.indices.stability * 100).toFixed(0)}%`)
-  lines.push(`│ Predictability: ${progressBar(snapshot.indices.predictability)}  ${(snapshot.indices.predictability * 100).toFixed(0)}%`)
-  lines.push('└─────────────────────────────────────────────────────────┘')
-  lines.push('')
-  
-  lines.push('┌─────────────────────────────────────────────────────────┐')
-  lines.push('│ PREDICTIONS                                             │')
-  lines.push('├─────────────────────────────────────────────────────────┤')
-  
+
+  lines.push('└─────────────────────────────────────────────────────────┘');
+  lines.push('');
+
+  lines.push('┌─────────────────────────────────────────────────────────┐');
+  lines.push('│ GAME STATE                                              │');
+  lines.push('├─────────────────────────────────────────────────────────┤');
+  lines.push(
+    `│ Dominance:      ${progressBar(snapshot.indices.dominance)}  ${(
+      snapshot.indices.dominance * 100
+    ).toFixed(0)}%`
+  );
+  lines.push(
+    `│ Volatility:     ${progressBar(snapshot.indices.volatility)}  ${(
+      snapshot.indices.volatility * 100
+    ).toFixed(0)}%`
+  );
+  lines.push(
+    `│ Competitiveness:${progressBar(snapshot.indices.competitiveness)}  ${(
+      snapshot.indices.competitiveness * 100
+    ).toFixed(0)}%`
+  );
+  lines.push(
+    `│ Stability:      ${progressBar(snapshot.indices.stability)}  ${(
+      snapshot.indices.stability * 100
+    ).toFixed(0)}%`
+  );
+  lines.push(
+    `│ Predictability: ${progressBar(snapshot.indices.predictability)}  ${(
+      snapshot.indices.predictability * 100
+    ).toFixed(0)}%`
+  );
+  lines.push('└─────────────────────────────────────────────────────────┘');
+  lines.push('');
+
+  lines.push('┌─────────────────────────────────────────────────────────┐');
+  lines.push('│ PREDICTIONS                                             │');
+  lines.push('├─────────────────────────────────────────────────────────┤');
+
   if (snapshot.predictions.likelyWinner !== null) {
-    lines.push(`│ Likely Winner: Player ${snapshot.predictions.likelyWinner}`)
-    lines.push(`│ Confidence: ${(snapshot.predictions.winnerConfidence * 100).toFixed(1)}%`)
+    lines.push(`│ Likely Winner: Player ${snapshot.predictions.likelyWinner}`);
+    lines.push(
+      `│ Confidence: ${(snapshot.predictions.winnerConfidence * 100).toFixed(
+        1
+      )}%`
+    );
     if (snapshot.predictions.estimatedTurnsToVictory !== null) {
-      lines.push(`│ Est. Victory In: ${snapshot.predictions.estimatedTurnsToVictory} turns`)
+      lines.push(
+        `│ Est. Victory In: ${snapshot.predictions.estimatedTurnsToVictory} turns`
+      );
     }
   } else {
-    lines.push('│ No clear winner predicted yet')
+    lines.push('│ No clear winner predicted yet');
   }
-  
+
   if (snapshot.predictions.isEndgame) {
-    lines.push('│ ⚠️  ENDGAME DETECTED')
+    lines.push('│ ⚠️  ENDGAME DETECTED');
   }
-  
-  lines.push(`│ Comeback Chance: ${(snapshot.predictions.comebackPossibility * 100).toFixed(0)}%`)
-  lines.push('└─────────────────────────────────────────────────────────┘')
-  lines.push('')
-  
+
+  lines.push(
+    `│ Comeback Chance: ${(
+      snapshot.predictions.comebackPossibility * 100
+    ).toFixed(0)}%`
+  );
+  lines.push('└─────────────────────────────────────────────────────────┘');
+  lines.push('');
+
   if (snapshot.insights.length > 0) {
-    lines.push('┌─────────────────────────────────────────────────────────┐')
-    lines.push('│ INSIGHTS                                                │')
-    lines.push('├─────────────────────────────────────────────────────────┤')
+    lines.push('┌─────────────────────────────────────────────────────────┐');
+    lines.push('│ INSIGHTS                                                │');
+    lines.push('├─────────────────────────────────────────────────────────┤');
     for (const insight of snapshot.insights) {
-      lines.push(`│ ${insight}`)
+      lines.push(`│ ${insight}`);
     }
-    lines.push('└─────────────────────────────────────────────────────────┘')
+    lines.push('└─────────────────────────────────────────────────────────┘');
   }
-  
-  return lines.join('\n')
+
+  return lines.join('\n');
 }
 
 function progressBar(value: number, width: number = 20): string {
-  const filled = Math.round(value * width)
-  const empty = width - filled
-  return '[' + '█'.repeat(filled) + '░'.repeat(empty) + ']'
+  const filled = Math.round(value * width);
+  const empty = width - filled;
+  return '[' + '█'.repeat(filled) + '░'.repeat(empty) + ']';
 }
 
 /**
  * Export snapshot as JSON (removes functions)
  */
 export function exportSnapshotAsJSON(snapshot: GameSnapshot): string {
-  return JSON.stringify(snapshot, (key, value) => {
-    if (value instanceof Map) {
-      return Object.fromEntries(value)
-    }
-    return value
-  }, 2)
+  return JSON.stringify(
+    snapshot,
+    (key, value) => {
+      if (value instanceof Map) {
+        return Object.fromEntries(value);
+      }
+      return value;
+    },
+    2
+  );
 }