@cs2dak/presentation 1.0.0 → 2.0.0

package/src/team.ts

@@ -1,137 +1,317 @@
-import { PRISM_AXIS_ORDER, type PrismAxisKey } from "@rivalhub/rival-rating";
-import {
-  teamCohortSummarySchema,
-  type LeaderboardMetricKey,
-  type SeasonCohortBundle,
-  type TeamCohortSummary,
-  type TeamMemberSummary,
-  type TeamRosterInput
-} from "@cs2dak/contract";
-import { buildAllPlayerSeasonProfiles } from "./player.js";
-import { computeSeasonMetrics, round } from "./season-metrics.js";
-
-const AXIS_LABEL: Record<PrismAxisKey, string> = {
-  firepower: "火力",
-  opening: "首杀",
-  clutch: "残局",
-  sniping: "狙击",
-  survival: "生存",
-  utility: "道具",
-  trading: "补枪",
-  entry: "突破"
-};
-
-const LEADERS: Array<{ metric: "rivalhubRR" | "adr" | "kast" | "firstKillPer100"; label: string }> = [
-  { metric: "rivalhubRR", label: "RR" },
-  { metric: "adr", label: "ADR" },
-  { metric: "kast", label: "KAST%" },
-  { metric: "firstKillPer100", label: "FK/100r" }
-];
-
-function average(values: number[]): number {
-  return values.length === 0 ? 0 : round(values.reduce((sum, value) => sum + value, 0) / values.length, 2);
+import { round } from "./season-metrics.js";
+import { displayWeaponName } from "./weapons.js";
+import type { DemoPackage, TeamMapRoleMatrix } from "@cs2dak/contract";
+
+export interface TeamComparisonPlayerRow {
+  teamName: string;
+  steamId64: string;
+  name: string;
+  rr: number | null;
+  adr: number | null;
+  kast: number | null;
+  kpr: number | null;
+  dpr: number | null;
 }
 
-function memberSummary(player: SeasonCohortBundle["players"][number]): TeamMemberSummary {
-  return {
-    playerKey: player.playerKey,
-    name: player.name,
-    mapCount: player.mapCount,
-    confidence: player.confidence,
-    metrics: computeSeasonMetrics(player)
-  };
+/** 该队某场比赛的概览（赛前侦察用，可点跳回放）。 */
+export interface TeamComparisonSideMatch {
+  matchId: string;
+  mapName: string;
+  opponent: string;
+  roundsWon: number;
+  roundsLost: number;
+  won: boolean;
 }
 
-function metricValues(members: TeamMemberSummary[], key: LeaderboardMetricKey): number[] {
-  return members.map((member) => member.metrics[key]).filter((value): value is number => value != null);
+export interface TeamComparisonSide {
+  teamName: string;
+  matchCount: number;
+  players: TeamComparisonPlayerRow[];
+  weaponPreference: Array<{ weapon: string; label: string; kills: number; sharePercent: number }>;
+  economyWinRate: Array<{ economyType: string; rounds: number; wins: number; winRatePercent: number | null }>;
+  /** 该队在 cohort 内打过的比赛（按场次自然序）。 */
+  matches: TeamComparisonSideMatch[];
 }
 
-export function buildTeamCohortSummary(
-  bundle: SeasonCohortBundle,
-  roster: TeamRosterInput
-): TeamCohortSummary {
-  if (roster.playerKeys.length === 0) throw new Error("team roster requires at least one playerKey");
-
-  const byKey = new Map(bundle.players.map((player) => [player.playerKey, player]));
-  const players = roster.playerKeys.map((playerKey) => {
-    const player = byKey.get(playerKey);
-    if (!player) throw new Error(`playerKey not found in cohort: ${playerKey}`);
-    return player;
-  });
-  const members = players.map(memberSummary);
-  const firstKills = players.reduce((sum, player) => sum + player.indicators.firstKillCount, 0);
-  const firstDeaths = players.reduce((sum, player) => sum + player.indicators.firstDeathCount, 0);
-  const clutchAttempts = players.reduce((sum, player) => sum + player.indicators.clutchAttempts, 0);
-  const clutchWins = players.reduce((sum, player) => sum + player.indicators.clutchWins, 0);
-  const profilesByKey = new Map(buildAllPlayerSeasonProfiles(bundle).map((profile) => [profile.playerKey, profile]));
-  const styled = players
-    .map((player) => profilesByKey.get(player.playerKey)!)
-    .filter((profile) => profile.style != null);
-
-  const teamAxes = styled.length === 0
-    ? null
-    : PRISM_AXIS_ORDER.map((key) => ({
-        key,
-        label: AXIS_LABEL[key],
-        percentile: average(styled.map((profile) => profile.style!.axes.find((axis) => axis.key === key)!.percentile))
-      }));
-
-  const specialists = styled.length === 0
-    ? []
-    : PRISM_AXIS_ORDER.map((key) => {
-        const top = styled
-          .map((profile) => ({
-            playerKey: profile.playerKey,
-            name: profile.name,
-            percentile: profile.style!.axes.find((axis) => axis.key === key)!.percentile
-          }))
-          .sort((a, b) => b.percentile - a.percentile)[0]!;
-        return { key, label: AXIS_LABEL[key], ...top };
-      });
-  const dominantAxes = new Set(
-    styled.map((profile) =>
-      [...profile.style!.axes].sort((a, b) => b.percentile - a.percentile)[0]!.key
-    )
-  );
-
-  return teamCohortSummarySchema.parse({
-    version: "cs2-demo-analysis-kit/team-summary-0.1",
-    weightsVersion: bundle.weightsVersion,
-    teamKey: roster.teamKey,
-    name: roster.name,
-    members,
-    coreMembers: [...members]
-      .sort((a, b) => b.mapCount - a.mapCount || (b.metrics.rivalhubRR ?? 0) - (a.metrics.rivalhubRR ?? 0))
-      .slice(0, 5),
-    averages: {
-      rivalhubRR: average(metricValues(members, "rivalhubRR")),
-      hltvRating: average(metricValues(members, "hltvRating")),
-      adr: average(metricValues(members, "adr")),
-      kd: metricValues(members, "kd").length > 0 ? average(metricValues(members, "kd")) : null,
-      kast: average(metricValues(members, "kast")),
-      confidence: average(members.map((member) => member.confidence))
-    },
-    performance: {
-      firstKills,
-      firstDeaths,
-      openingDuelWinRate: firstKills + firstDeaths > 0
-        ? round(firstKills / (firstKills + firstDeaths), 4)
-        : null,
-      clutchAttempts,
-      clutchWins,
-      clutchWinRate: clutchAttempts > 0 ? round(clutchWins / clutchAttempts, 4) : null
+export interface TeamComparisonModel {
+  /** 0.2：服务"赛前侦察"——两队各自跨全部己方比赛聚合，无需互相交手；去掉旧的噪声 evidence，改 per-team 比赛列表。 */
+  version: "cs2-demo-analysis-kit/team-comparison-0.2";
+  teams: [TeamComparisonSide, TeamComparisonSide] | [];
+  radar: Array<{ metric: string; label: string; a: number | null; b: number | null; delta: number | null }>;
+  /** cohort 内全部队伍（按场次降序），供 UI 选 A/B 两队。 */
+  availableTeams: Array<{ name: string; matches: number }>;
+}
+
+/** 队伍总览只编排已有跨场事实；不推导强弱项、因果或对策。 */
+export interface TeamOverviewModel {
+  version: "cs2-demo-analysis-kit/team-overview-0.2";
+  teamName: string;
+  matchCount: number;
+  wins: number;
+  losses: number;
+  roundsWon: number;
+  roundsLost: number;
+  maps: Array<{ mapName: string; matches: number; wins: number; losses: number; roundsWon: number; roundsLost: number }>;
+  roster: TeamComparisonPlayerRow[];
+  weaponPreference: TeamComparisonSide["weaponPreference"];
+  economyWinRate: TeamComparisonSide["economyWinRate"];
+  matches: TeamComparisonSideMatch[];
+  /** Declaration-neutral map/side responsibility summary; consumers may render the full matrices separately. */
+  roleMatrixSummary: Array<{ mapName: string; side: "t" | "ct"; status: TeamMapRoleMatrix["status"]; positionConcentration: number | null; unstableCoverage: boolean }>;
+}
+
+export interface TeamComparisonInput {
+  matchId: string;
+  pkg: DemoPackage;
+}
+
+export interface TeamComparisonFacts {
+  matchId: string;
+  mapName: string;
+  teams: Record<"teamA" | "teamB", string>;
+  players: Array<{ steamId64: string; name: string; teamKey: "teamA" | "teamB" }>;
+  playerStats: Array<{
+    playerSteamId64: string;
+    rounds: number;
+    kills: number;
+    deaths: number;
+    damageHealth: number;
+    kastRounds: number;
+  }>;
+  kills: Array<{ killerSteamId64: string | null; roundNumber: number; tick: number; weapon: string }>;
+  rounds: Array<{ teamAEconomy: string; teamBEconomy: string; winnerTeamKey: "teamA" | "teamB" }>;
+}
+
+function teamName(pkg: DemoPackage, key: string): string {
+  return key === "teamA" ? (pkg.match.teamA.name ?? "Team A") : (pkg.match.teamB.name ?? "Team B");
+}
+
+function averageNullable(values: Array<number | null | undefined>): number | null {
+  const nums = values.filter((value): value is number => value != null && Number.isFinite(value));
+  return nums.length > 0 ? round(nums.reduce((sum, value) => sum + value, 0) / nums.length, 2) : null;
+}
+
+export function extractTeamComparisonFacts(input: TeamComparisonInput): TeamComparisonFacts {
+  const { pkg } = input;
+  return {
+    matchId: input.matchId,
+    mapName: pkg.match.mapName,
+    teams: {
+      teamA: teamName(pkg, "teamA"),
+      teamB: teamName(pkg, "teamB")
     },
-    style: teamAxes == null ? null : { axes: teamAxes },
-    leaders: LEADERS.map(({ metric, label }) => {
-      const leader = [...members]
-        .filter((member) => member.metrics[metric] != null)
-        .sort((a, b) => b.metrics[metric]! - a.metrics[metric]!)[0]!;
-      return { metric, label, playerKey: leader.playerKey, name: leader.name, value: leader.metrics[metric]! };
-    }),
-    roleComplementarity: {
-      coverageScore: styled.length === 0 ? 0 : round((dominantAxes.size / Math.min(styled.length, 8)) * 100, 1),
-      specialists,
-      weakAxes: (teamAxes ?? []).filter((axis) => axis.percentile < 50)
+    players: pkg.players.map((player) => ({
+      steamId64: player.steamId64,
+      name: player.name,
+      teamKey: player.teamKey
+    })),
+    playerStats: pkg.playerStats.map((stat) => {
+      const player = pkg.players[stat.playerIndex];
+      return {
+        playerSteamId64: player?.steamId64 ?? "",
+        rounds: stat.rounds,
+        kills: stat.kills,
+        deaths: stat.deaths,
+        damageHealth: stat.damageHealth,
+        kastRounds: stat.kastRounds
+      };
+    }).filter((row) => row.playerSteamId64 !== ""),
+    kills: pkg.kills.map((kill) => ({
+      killerSteamId64: kill.killerIndex != null ? (pkg.players[kill.killerIndex]?.steamId64 ?? null) : null,
+      roundNumber: kill.roundNumber,
+      tick: kill.tick,
+      weapon: kill.weapon
+    })),
+    rounds: pkg.rounds.map((roundRow) => ({
+      teamAEconomy: roundRow.teamAEconomy,
+      teamBEconomy: roundRow.teamBEconomy,
+      winnerTeamKey: roundRow.winnerTeamKey
+    }))
+  };
+}
+
+/**
+ * @param inputs  cohort 内全部比赛的 facts
+ * @param requestedPair  指定要对比的两队名（如 UI 选了 A/B）；缺省取场次最多的两队。
+ *                       两队**无需互相交手**——各自跨全部己方比赛聚合，服务赛前侦察。
+ */
+export function buildTeamComparisonFromFacts(
+  inputs: TeamComparisonFacts[],
+  requestedPair?: [string, string]
+): TeamComparisonModel {
+  const matchCounts = new Map<string, number>();
+  for (const input of inputs) {
+    for (const teamName of [input.teams.teamA, input.teams.teamB]) {
+      matchCounts.set(teamName, (matchCounts.get(teamName) ?? 0) + 1);
     }
+  }
+  const availableTeams = [...matchCounts.entries()]
+    .map(([name, matches]) => ({ name, matches }))
+    .sort((a, b) => b.matches - a.matches || a.name.localeCompare(b.name));
+
+  const empty = (): TeamComparisonModel => ({
+    version: "cs2-demo-analysis-kit/team-comparison-0.2",
+    teams: [],
+    radar: [],
+    availableTeams
   });
+
+  const valid = (name: string | undefined): name is string => name != null && matchCounts.has(name);
+  const teamNames =
+    requestedPair && valid(requestedPair[0]) && valid(requestedPair[1]) && requestedPair[0] !== requestedPair[1]
+      ? [requestedPair[0], requestedPair[1]]
+      : availableTeams.slice(0, 2).map((team) => team.name);
+  if (teamNames.length < 2) return empty();
+
+  const sides = teamNames.map((name): TeamComparisonSide => {
+    const playerRows = new Map<string, TeamComparisonPlayerRow & { rounds: number; kills: number; deaths: number; damage: number; kastRounds: number }>();
+    const weaponKills = new Map<string, number>();
+    const economy = new Map<string, { rounds: number; wins: number }>();
+    const matches: TeamComparisonSideMatch[] = [];
+    for (const input of inputs) {
+      const playerBySteam = new Map(input.players.map((player) => [player.steamId64, player]));
+      for (const [teamKey, candidate] of [["teamA", input.teams.teamA], ["teamB", input.teams.teamB]] as const) {
+        if (candidate !== name) continue;
+        let roundsWon = 0;
+        let roundsLost = 0;
+        for (const round of input.rounds) {
+          if (round.winnerTeamKey === teamKey) roundsWon += 1;
+          else roundsLost += 1;
+        }
+        matches.push({
+          matchId: input.matchId,
+          mapName: input.mapName,
+          opponent: teamKey === "teamA" ? input.teams.teamB : input.teams.teamA,
+          roundsWon,
+          roundsLost,
+          won: roundsWon > roundsLost
+        });
+        for (const stat of input.playerStats) {
+          const player = playerBySteam.get(stat.playerSteamId64);
+          if (!player || player.teamKey !== teamKey) continue;
+          const current = playerRows.get(player.steamId64) ?? {
+            teamName: name,
+            steamId64: player.steamId64,
+            name: player.name,
+            rr: null,
+            adr: null,
+            kast: null,
+            kpr: null,
+            dpr: null,
+            rounds: 0,
+            kills: 0,
+            deaths: 0,
+            damage: 0,
+            kastRounds: 0
+          };
+          current.rounds += stat.rounds;
+          current.kills += stat.kills;
+          current.deaths += stat.deaths;
+          current.damage += stat.damageHealth;
+          current.kastRounds += stat.kastRounds;
+          playerRows.set(player.steamId64, current);
+        }
+        for (const kill of input.kills) {
+          if (kill.killerSteamId64 == null) continue;
+          const killer = playerBySteam.get(kill.killerSteamId64);
+          if (!killer || killer.teamKey !== teamKey) continue;
+          const weapon = killWeaponLabel(kill.weapon);
+          weaponKills.set(weapon, (weaponKills.get(weapon) ?? 0) + 1);
+        }
+        for (const round of input.rounds) {
+          const type = teamKey === "teamA" ? round.teamAEconomy : round.teamBEconomy;
+          const cell = economy.get(type) ?? { rounds: 0, wins: 0 };
+          cell.rounds += 1;
+          if (round.winnerTeamKey === teamKey) cell.wins += 1;
+          economy.set(type, cell);
+        }
+      }
+    }
+    const players = [...playerRows.values()].map((row) => ({
+      teamName: row.teamName,
+      steamId64: row.steamId64,
+      name: row.name,
+      rr: row.rounds > 0 ? round((row.kills - row.deaths) / row.rounds + row.damage / row.rounds / 100, 3) : null,
+      adr: row.rounds > 0 ? round(row.damage / row.rounds, 1) : null,
+      kast: row.rounds > 0 ? round(row.kastRounds / row.rounds * 100, 1) : null,
+      kpr: row.rounds > 0 ? round(row.kills / row.rounds, 3) : null,
+      dpr: row.rounds > 0 ? round(row.deaths / row.rounds, 3) : null
+    })).sort((a, b) => (b.rr ?? 0) - (a.rr ?? 0));
+    const totalWeaponKills = [...weaponKills.values()].reduce((sum, value) => sum + value, 0);
+    return {
+      teamName: name,
+      matchCount: matches.length,
+      players,
+      weaponPreference: [...weaponKills.entries()]
+        .map(([weapon, kills]) => ({ weapon, label: displayWeaponName(weapon), kills, sharePercent: totalWeaponKills > 0 ? round(kills / totalWeaponKills * 100, 1) : 0 }))
+        .sort((a, b) => b.kills - a.kills)
+        .slice(0, 8),
+      economyWinRate: [...economy.entries()]
+        .map(([economyType, cell]) => ({ economyType, rounds: cell.rounds, wins: cell.wins, winRatePercent: cell.rounds > 0 ? round(cell.wins / cell.rounds * 100, 1) : null }))
+        .sort((a, b) => a.economyType.localeCompare(b.economyType)),
+      matches
+    };
+  }) as [TeamComparisonSide, TeamComparisonSide];
+  const radar = [
+    { metric: "rr", label: "RR", a: averageNullable(sides[0].players.map((row) => row.rr)), b: averageNullable(sides[1].players.map((row) => row.rr)) },
+    { metric: "adr", label: "ADR", a: averageNullable(sides[0].players.map((row) => row.adr)), b: averageNullable(sides[1].players.map((row) => row.adr)) },
+    { metric: "kast", label: "KAST", a: averageNullable(sides[0].players.map((row) => row.kast)), b: averageNullable(sides[1].players.map((row) => row.kast)) },
+    { metric: "kpr", label: "KPR", a: averageNullable(sides[0].players.map((row) => row.kpr)), b: averageNullable(sides[1].players.map((row) => row.kpr)) },
+    { metric: "dpr", label: "DPR", a: averageNullable(sides[0].players.map((row) => row.dpr)), b: averageNullable(sides[1].players.map((row) => row.dpr)) }
+  ].map((row) => ({ ...row, delta: row.a != null && row.b != null ? round(row.a - row.b, 2) : null }));
+  return { version: "cs2-demo-analysis-kit/team-comparison-0.2", teams: sides, radar, availableTeams };
+}
+
+export function buildTeamComparison(
+  inputs: TeamComparisonInput[],
+  requestedPair?: [string, string]
+): TeamComparisonModel {
+  return buildTeamComparisonFromFacts(inputs.map(extractTeamComparisonFacts), requestedPair);
+}
+
+export function buildTeamOverviewFromFacts(inputs: TeamComparisonFacts[], teamName: string, roleMatrices: TeamMapRoleMatrix[] = []): TeamOverviewModel | null {
+  const opponent = inputs
+    .flatMap((input) => [input.teams.teamA, input.teams.teamB])
+    .find((name) => name !== teamName);
+  if (!opponent) return null;
+  const comparison = buildTeamComparisonFromFacts(inputs, [teamName, opponent]);
+  const side = comparison.teams.find((row) => row.teamName === teamName);
+  if (!side) return null;
+
+  const maps = new Map<string, { mapName: string; matches: number; wins: number; losses: number; roundsWon: number; roundsLost: number }>();
+  let roundsWon = 0;
+  let roundsLost = 0;
+  for (const match of side.matches) {
+    const row = maps.get(match.mapName) ?? { mapName: match.mapName, matches: 0, wins: 0, losses: 0, roundsWon: 0, roundsLost: 0 };
+    row.matches += 1;
+    row.wins += match.won ? 1 : 0;
+    row.losses += match.won ? 0 : 1;
+    row.roundsWon += match.roundsWon;
+    row.roundsLost += match.roundsLost;
+    roundsWon += match.roundsWon;
+    roundsLost += match.roundsLost;
+    maps.set(match.mapName, row);
+  }
+  return {
+    version: "cs2-demo-analysis-kit/team-overview-0.2",
+    teamName,
+    matchCount: side.matchCount,
+    wins: side.matches.filter((match) => match.won).length,
+    losses: side.matches.filter((match) => !match.won).length,
+    roundsWon,
+    roundsLost,
+    maps: [...maps.values()].sort((a, b) => b.matches - a.matches || a.mapName.localeCompare(b.mapName)),
+    roster: side.players,
+    weaponPreference: side.weaponPreference,
+    economyWinRate: side.economyWinRate,
+    matches: side.matches,
+    roleMatrixSummary: roleMatrices
+      .filter((matrix) => matrix.teamKey === teamName)
+      .map((matrix) => ({ mapName: matrix.mapName, side: matrix.side, status: matrix.status, positionConcentration: matrix.positionConcentration, unstableCoverage: matrix.unstableCoverage }))
+      .sort((a, b) => a.mapName.localeCompare(b.mapName) || a.side.localeCompare(b.side)),
+  };
+}
+
+function killWeaponLabel(weapon: string): string {
+  return weapon.toLowerCase().replace(/^weapon_/, "");
 }

package/src/test-fixtures.ts

@@ -0,0 +1,191 @@
+import type { SeasonCohortBundle, SeasonPlayerRow } from "@cs2dak/contract";
+import type { PrismAxisKey, PrismAxisResult, PrismResult } from "@rivalhub/rival-rating";
+
+const AXES = [
+  "firepower",
+  "opening",
+  "clutch",
+  "sniping",
+  "survival",
+  "utility",
+  "trading",
+  "entry"
+] as const;
+
+function prism(seed: number, steamId64: string, mapCount: number): PrismResult {
+  const axes = {} as Record<PrismAxisKey, PrismAxisResult>;
+  for (const [index, key] of AXES.entries()) {
+    axes[key] = {
+      involvementRaw: seed + index,
+      efficiencyRaw: seed + index / 10,
+      hasSignal: true,
+      availableSignalWeight: 1,
+      z: (seed + index) / 10,
+      percentile: Math.min(98, 30 + seed * 9 + index * 3)
+    };
+  }
+  return {
+    steamId64,
+    mapCount,
+    weightsVersion: "test-prism",
+    rrPercentile: 40 + seed * 8,
+    axes
+  };
+}
+
+function player(index: number, overrides: Partial<SeasonPlayerRow> = {}): SeasonPlayerRow {
+  const kills = 20 + index * 5;
+  const deaths = index === 4 ? 0 : 18 + index * 2;
+  const totalRounds = 48;
+  const steamId64 = `7656119800000000${index}`;
+  const base: SeasonPlayerRow = {
+    playerKey: `steam:${steamId64}`,
+    steamIds: [steamId64],
+    primarySteamId64: steamId64,
+    externalUserId: null,
+    name: `Player ${index}`,
+    teamKeys: ["teamA"],
+    mapCount: 2 + index,
+    rrV1: 0.9 + index * 0.08,
+    rrV1Percentile: 35 + index * 10,
+    indicators: {
+      steamId64,
+      totalRounds,
+      kills,
+      deaths,
+      assists: 5 + index,
+      kpr: kills / totalRounds,
+      dpr: deaths / totalRounds,
+      apr: (5 + index) / totalRounds,
+      adr: 65 + index * 6,
+      hsPercent: 42 + index,
+      kast: 66 + index * 3,
+      survivalRate: deaths === 0 ? 1 : 1 - deaths / totalRounds,
+      twoKillRounds: 3 + index,
+      threeKillRounds: 1 + index,
+      fourKillRounds: index % 2,
+      fiveKillRounds: 0,
+      multiKillRate: (4 + index) / totalRounds,
+      firstKillCount: 2 + index,
+      firstDeathCount: 1 + index,
+      firstKillRate: (2 + index) / totalRounds,
+      firstDeathRate: (1 + index) / totalRounds,
+      openingDuelRate: (3 + index * 2) / totalRounds,
+      openingDuelWinRate: (2 + index) / (3 + index * 2),
+      tradeKillCount: 2 + index,
+      tradeDeathCount: 1,
+      tradeKillRate: (2 + index) / totalRounds,
+      tradeDeathRate: 1 / totalRounds,
+      clutchAttempts: index,
+      clutchWins: Math.max(0, index - 1),
+      clutchWinRate: index > 0 ? (index - 1) / index : 0,
+      clutchFrequency: index / totalRounds,
+      clutchScore: index * 2,
+      clutchScoreRate: (index * 2) / totalRounds,
+      vsOne: { count: index, won: Math.max(0, index - 1) },
+      vsTwo: { count: 0, won: 0 },
+      vsThree: { count: 0, won: 0 },
+      vsFour: { count: 0, won: 0 },
+      vsFive: { count: 0, won: 0 },
+      awpKills: index,
+      awpKillsPerRound: index / totalRounds,
+      awpKillRate: index / Math.max(1, kills),
+      sniperKills: index,
+      sniperKillRate: index / Math.max(1, kills),
+      awpMultiKillRate: null,
+      awpDuelWinRate: null,
+      utilityDamage: 20 + index * 5,
+      utilityDamagePerRound: (20 + index * 5) / totalRounds,
+      flashAssistCount: index,
+      flashAssistPerRound: index / totalRounds,
+      blindDurationTotal: index * 2,
+      blindDurationPerRound: (index * 2) / totalRounds,
+      enemyFlashDurationSeconds: index * 3,
+      enemyFlashDurationPerRound: (index * 3) / totalRounds,
+      teamFlashDurationSeconds: index,
+      teamFlashDurationPerRound: index / totalRounds,
+      grenadeCount: 10 + index,
+      grenadeCountPerRound: (10 + index) / totalRounds,
+      ecoRoundCount: 4,
+      forceRoundCount: 5,
+      fullBuyRoundCount: 30,
+      pistolRoundCount: 4,
+      avgEquipmentValue: 3800 + index * 100,
+      combatDeathCount: deaths,
+      bombDeathCount: 0,
+      wallbangKillCount: index,
+      roundSwingTotal: index * 1.5,
+      roundSwingPerKill: kills > 0 ? (index * 1.5) / kills : null
+    },
+    weaponHighlights: {
+      steamId64,
+      totalKills: kills,
+      weapons: [
+        {
+          weapon: "ak47",
+          kills: kills - index,
+          headshotKills: Math.floor((kills - index) / 2),
+          tradeKills: index,
+          noScopeKills: 0,
+          throughSmokeKills: 1,
+          wallbangKills: index,
+          penetratedObjects: index
+        },
+        {
+          weapon: "awp",
+          kills: index,
+          headshotKills: 0,
+          tradeKills: 0,
+          noScopeKills: index > 2 ? 1 : 0,
+          throughSmokeKills: 0,
+          wallbangKills: 0,
+          penetratedObjects: 0
+        }
+      ],
+      highlights: {
+        wallbangKills: index,
+        noScopeKills: index > 2 ? 1 : 0,
+        throughSmokeKills: 1,
+        collateralKills: 0
+      }
+    },
+    accountRR: 1 + index * 0.1,
+    accountRRRaw: 0.95 + index * 0.1,
+    accountBreakdown: {
+      combat: 0.5 + index,
+      trade: 0.4 + index,
+      mapControl: 0.3 + index,
+      clutch: 0.2 + index,
+      objective: 0.1 + index,
+      utility: index
+    },
+    accountContextStatus: {
+      buyDelta: "available",
+      manState: "available"
+    },
+    prism: index === 6 ? null : prism(index, steamId64, 2 + index),
+    confidence: 0.6 + index * 0.05,
+    perMatch: [
+      { matchId: "m2", steamId64, accountRR: 1 + index * 0.1, rrV1: 0.9 + index * 0.08 },
+      { matchId: "m1", steamId64, accountRR: 0.95 + index * 0.1, rrV1: 0.85 + index * 0.08 }
+    ]
+  };
+  return { ...base, ...overrides };
+}
+
+export function buildTestSeasonCohortBundle(): SeasonCohortBundle {
+  return {
+    version: "cs2-demo-analysis-kit/cohort-1.0",
+    matchCount: 2,
+    weightsVersion: "test-weights",
+    players: [1, 2, 3, 4, 5, 6].map((i) => player(i)),
+    provenance: {
+      cohortVersion: "cs2-demo-analysis-kit/cohort-1.0",
+      sourceSchemaVersion: "cs2-demo-format/3.0",
+      matches: [
+        { matchId: "m1", sourceDemoHash: "hash-1" },
+        { matchId: "m2", sourceDemoHash: "hash-2" }
+      ]
+    }
+  };
+}