@cs2dak/presentation 1.0.0

package/src/season-validation.test.ts

@@ -0,0 +1,111 @@
+/**
+ * C 阶段：55 张真实 ZIP 数据验收
+ * 验证：排序合理性、null 分布、AWP/R 是否趋零、FK/MK/C 数值范围、
+ * 多账号合并、强项/弱项百分位。
+ */
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { loadDemoPackageFromZip } from "@cs2dak/core";
+import { buildSeasonCohort } from "@cs2dak/cohort";
+import { buildSeasonLeaderboardModel, buildAllPlayerSeasonProfiles } from "./index";
+
+const ZIP_DIR = fileURLToPath(new URL("../../../fixtures/output/nju-rivals-2026", import.meta.url));
+const REPORT_FILE = fileURLToPath(new URL("../../../fixtures/output/_c-phase-report.txt", import.meta.url));
+const integrationTimeoutMs = 120_000;
+const reportLines: string[] = [];
+
+function report(msg: string) {
+  reportLines.push(msg);
+  console.log(msg);
+}
+
+async function dirExists(path: string): Promise<boolean> {
+  try {
+    const stat = await (await import("node:fs/promises")).stat(path);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+async function njuCohort() {
+  const names = (await readdir(ZIP_DIR)).filter((n) => n.endsWith(".zip")).sort();
+  const demos = await Promise.all(
+    names.map(async (name) => ({
+      matchId: name.replace(/\.zip$/, ""),
+      pkg: await loadDemoPackageFromZip(await readFile(join(ZIP_DIR, name)))
+    }))
+  );
+  return { bundle: buildSeasonCohort(demos), matchCount: names.length };
+}
+
+describe("55-ZIP season verification", () => {
+  it(
+    "builds cohort + leaderboard + profiles from 55 real ZIPs",
+    async () => {
+      if (!(await dirExists(ZIP_DIR))) {
+        report("ZIP 目录不存在，跳过验证（CI 环境无预导出 ZIP）");
+        return;
+      }
+      const { bundle, matchCount } = await njuCohort();
+      expect(matchCount).toBeGreaterThanOrEqual(50);
+      expect(bundle.players.length).toBeGreaterThan(30);
+
+      const leaderboard = buildSeasonLeaderboardModel(bundle);
+      const profiles = buildAllPlayerSeasonProfiles(bundle);
+      expect(leaderboard.rows).toHaveLength(bundle.players.length);
+      expect(profiles).toHaveLength(bundle.players.length);
+
+      // 排序是 React SeasonLeaderboard 组件的职责，不在 builder 侧。
+      // 这里只验证数据完整性和范围合理。组件排序测试在 SeasonLeaderboard.test.ts。
+
+      // AWP/R 应该大部分接近 0（非狙手无 AWP 击杀）
+      const awprValues = leaderboard.rows
+        .map((r) => r.metrics.awpKillsPerRound)
+        .filter((v): v is number => v != null);
+      if (awprValues.length > 0) {
+        const belowPoint1 = awprValues.filter((v) => v < 0.1).length;
+        const pctBelow = (belowPoint1 / awprValues.length) * 100;
+        report(`AWP/R: ${awprValues.length} non-null, ${pctBelow.toFixed(0)}% < 0.1`);
+        // 非狙手主导的场景，AWP/R 趋近 0 的比例应高
+        expect(pctBelow).toBeGreaterThan(50);
+      }
+
+      // FK/MK/C 每 100 回合数值范围：合理范围 0–30，极端值检查
+      for (const key of ["firstKillPer100", "multiKillPer100", "clutchPer100"] as const) {
+        const values = leaderboard.rows
+          .map((r) => r.metrics[key])
+          .filter((v): v is number => v != null);
+        if (values.length > 0) {
+          const sorted = [...values].sort((a, b) => a - b);
+          const p95 = sorted[Math.floor(sorted.length * 0.95)];
+          report(`${key}: n=${values.length} p50=${sorted[Math.floor(sorted.length * 0.5)].toFixed(1)} p95=${p95.toFixed(1)}`);
+          // FK/100r p95 不应超过 30（每 100 回合 30 首杀极端异常）
+          expect(p95).toBeLessThan(30);
+        }
+      }
+
+      // 选手页前 3 名有有意义的内容
+      const top3 = leaderboard.rows
+        .filter((r) => r.metrics.rivalhubRR != null)
+        .sort((a, b) => (b.metrics.rivalhubRR ?? 0) - (a.metrics.rivalhubRR ?? 0))
+        .slice(0, 3);
+      for (const row of top3) {
+        const profile = profiles.find((p) => p.playerKey === row.playerKey)!;
+        expect(profile.rating.rivalhubRR).toBeGreaterThan(0);
+        expect(profile.perMatch.length).toBeGreaterThanOrEqual(1);
+        if (profile.style) {
+          expect(profile.style.axes).toHaveLength(8);
+        }
+        report(`Top: ${profile.name} RR=${profile.rating.rivalhubRR.toFixed(2)} maps=${profile.mapCount} strengths=[${profile.strengths.join(",")}]`);
+      }
+
+      // 写入报告文件供后续查看
+      await (await import("node:fs/promises")).writeFile(REPORT_FILE, reportLines.join("\n") + "\n");
+      report(`\n报告已写入 ${REPORT_FILE}`);
+    },
+    integrationTimeoutMs
+  );
+});

package/src/series.test.ts

@@ -0,0 +1,81 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { loadDemoPackageFromZip } from "@cs2dak/core";
+import { mvpRecommendationSchema, seriesSummarySchema } from "@cs2dak/contract";
+import { buildMatchWorkspaceModel, buildSeriesSummary, recommendMatchMvp } from "./index";
+
+async function buildWorkspace() {
+  const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
+  return buildMatchWorkspaceModel(await loadDemoPackageFromZip(zip));
+}
+
+describe("recommendMatchMvp", () => {
+  it("ranks candidates from accountRR, HLTV Rating 2.0 and confidence", async () => {
+    const model = await buildWorkspace();
+    const recommendation = recommendMatchMvp(model);
+
+    expect(() => mvpRecommendationSchema.parse(recommendation)).not.toThrow();
+    expect(recommendation.candidates.length).toBeGreaterThan(0);
+    expect(recommendation.recommended.playerKey).toBe(recommendation.candidates[0]?.playerKey);
+    expect(recommendation.candidates.map((row) => row.recommendationScore)).toEqual(
+      [...recommendation.candidates.map((row) => row.recommendationScore)].sort((a, b) => b - a)
+    );
+    expect(recommendation.recommended.explanation).toHaveLength(3);
+    expect(recommendation).not.toHaveProperty("winnerUserId");
+  });
+});
+
+describe("buildSeriesSummary", () => {
+  it("aggregates counts and round-weighted rates across maps", async () => {
+    const model = await buildWorkspace();
+    const summary = buildSeriesSummary([
+      { matchId: "map-1", model },
+      { matchId: "map-2", model }
+    ]);
+
+    expect(() => seriesSummarySchema.parse(summary)).not.toThrow();
+    expect(summary.mapCount).toBe(2);
+    expect(summary.maps).toHaveLength(2);
+    expect(summary.scoreboard).toHaveLength(model.scoreboard.length);
+    expect(summary.mvpCandidates.length).toBeGreaterThan(0);
+
+    const source = model.scoreboard[0]!;
+    const aggregate = summary.scoreboard.find((row) => row.playerKey === source.steamId64)!;
+    expect(aggregate.mapCount).toBe(2);
+    expect(aggregate.kills).toBe(source.kills * 2);
+    expect(aggregate.deaths).toBe(source.deaths * 2);
+    expect(aggregate.adr).toBe(source.adr);
+    expect(aggregate.kast).toBe(source.kast);
+    expect(aggregate.perMap).toHaveLength(2);
+  });
+
+  it("rejects an empty series", () => {
+    expect(() => buildSeriesSummary([])).toThrow(/at least one/);
+  });
+
+  it("accepts an external team map instead of owning team identity", async () => {
+    const model = await buildWorkspace();
+    const renamed = {
+      ...model,
+      teams: {
+        teamA: { ...model.teams.teamA, name: "Alias A" },
+        teamB: { ...model.teams.teamB, name: "Alias B" }
+      }
+    };
+    const summary = buildSeriesSummary(
+      [{ matchId: "map-1", model }, { matchId: "map-2", model: renamed }],
+      {
+        teamMap: {
+          "map-1:teamA": { teamKey: "team-alpha", name: "Team Alpha" },
+          "map-2:teamA": { teamKey: "team-alpha", name: "Team Alpha" },
+          "map-1:teamB": { teamKey: "team-beta", name: "Team Beta" },
+          "map-2:teamB": { teamKey: "team-beta", name: "Team Beta" }
+        }
+      }
+    );
+
+    expect(summary.teams.map((team) => team.teamKey).sort()).toEqual(["team-alpha", "team-beta"]);
+    expect(summary.scoreboard.every((row) => ["Team Alpha", "Team Beta"].includes(row.teamName))).toBe(true);
+  });
+});

package/src/series.ts

@@ -0,0 +1,213 @@
+import {
+  mvpRecommendationSchema,
+  seriesSummarySchema,
+  type MatchWorkspaceModel,
+  type MvpCandidate,
+  type MvpRecommendation,
+  type SeriesMatchInput,
+  type SeriesPlayerRow,
+  type SeriesSummary
+} from "@cs2dak/contract";
+import { round } from "./season-metrics.js";
+
+const MVP_CANDIDATE_LIMIT = 3;
+
+interface MvpSource {
+  playerKey: string;
+  name: string;
+  teamName: string;
+  rivalhubRR: number;
+  hltvRating: number;
+  confidence: number;
+}
+
+function candidateFrom(source: MvpSource): MvpCandidate {
+  const recommendationScore = round(
+    source.rivalhubRR * 0.45 + source.hltvRating * 0.4 + source.confidence * 0.15,
+    4
+  );
+  return {
+    ...source,
+    recommendationScore,
+    explanation: [
+      `RivalHub RR ${source.rivalhubRR.toFixed(3)}（45%）`,
+      `HLTV Rating 2.0 ${source.hltvRating.toFixed(2)}（40%）`,
+      `数据可信度 ${(source.confidence * 100).toFixed(0)}%（15%）`
+    ]
+  };
+}
+
+function rankMvpCandidates(sources: MvpSource[]): MvpCandidate[] {
+  return sources
+    .map(candidateFrom)
+    .sort((a, b) =>
+      b.recommendationScore - a.recommendationScore
+      || b.rivalhubRR - a.rivalhubRR
+      || b.hltvRating - a.hltvRating
+    )
+    .slice(0, MVP_CANDIDATE_LIMIT);
+}
+
+export function recommendMatchMvp(model: MatchWorkspaceModel): MvpRecommendation {
+  const candidates = rankMvpCandidates(model.scoreboard.map((row) => ({
+    playerKey: row.steamId64,
+    name: row.name,
+    teamName: model.teams[row.teamKey].name,
+    rivalhubRR: row.accountRR,
+    hltvRating: row.rr,
+    confidence: row.confidence
+  })));
+  if (candidates.length === 0) throw new Error("match MVP recommendation requires at least one player");
+  return mvpRecommendationSchema.parse({
+    version: "cs2-demo-analysis-kit/mvp-recommendation-0.1",
+    recommended: candidates[0],
+    candidates
+  });
+}
+
+interface SeriesAccumulator {
+  playerKey: string;
+  name: string;
+  teamName: string;
+  mapCount: number;
+  totalRounds: number;
+  kills: number;
+  deaths: number;
+  assists: number;
+  damage: number;
+  kastRounds: number;
+  rivalhubRRRounds: number;
+  hltvRatingRounds: number;
+  confidenceRounds: number;
+  perMap: SeriesPlayerRow["perMap"];
+}
+
+export interface SeriesTeamIdentity {
+  teamKey: string;
+  name: string;
+}
+
+export interface SeriesSummaryOptions {
+  /** Key format: `${matchId}:teamA` / `${matchId}:teamB`. Identity remains product-owned. */
+  teamMap?: Record<string, SeriesTeamIdentity>;
+}
+
+function stableTeamKey(name: string): string {
+  return name.trim().toLowerCase().replace(/\s+/g, "-");
+}
+
+function teamIdentity(
+  matchId: string,
+  side: "teamA" | "teamB",
+  model: MatchWorkspaceModel,
+  options: SeriesSummaryOptions
+): SeriesTeamIdentity {
+  return options.teamMap?.[`${matchId}:${side}`] ?? {
+    teamKey: stableTeamKey(model.teams[side].name),
+    name: model.teams[side].name
+  };
+}
+
+export function buildSeriesSummary(
+  matches: SeriesMatchInput[],
+  options: SeriesSummaryOptions = {}
+): SeriesSummary {
+  if (matches.length === 0) throw new Error("series summary requires at least one match");
+
+  const players = new Map<string, SeriesAccumulator>();
+  const teams = new Map<string, { teamKey: string; name: string; mapsWon: number }>();
+
+  for (const { matchId, model } of matches) {
+    const identity = {
+      teamA: teamIdentity(matchId, "teamA", model, options),
+      teamB: teamIdentity(matchId, "teamB", model, options)
+    };
+    for (const team of [identity.teamA, identity.teamB]) {
+      if (!teams.has(team.teamKey)) teams.set(team.teamKey, { ...team, mapsWon: 0 });
+    }
+    const winnerSide = model.teams.teamA.score === model.teams.teamB.score
+      ? null
+      : model.teams.teamA.score > model.teams.teamB.score ? "teamA" : "teamB";
+    if (winnerSide) teams.get(identity[winnerSide].teamKey)!.mapsWon += 1;
+
+    for (const row of model.scoreboard) {
+      const rounds = model.players.find((player) => player.row.steamId64 === row.steamId64)?.roundFacts.length
+        ?? model.rounds.length;
+      const teamName = identity[row.teamKey].name;
+      const acc = players.get(row.steamId64) ?? {
+        playerKey: row.steamId64,
+        name: row.name,
+        teamName,
+        mapCount: 0,
+        totalRounds: 0,
+        kills: 0,
+        deaths: 0,
+        assists: 0,
+        damage: 0,
+        kastRounds: 0,
+        rivalhubRRRounds: 0,
+        hltvRatingRounds: 0,
+        confidenceRounds: 0,
+        perMap: []
+      };
+      acc.mapCount += 1;
+      acc.totalRounds += rounds;
+      acc.kills += row.kills;
+      acc.deaths += row.deaths;
+      acc.assists += row.assists;
+      acc.damage += row.adr * rounds;
+      acc.kastRounds += (row.kast / 100) * rounds;
+      acc.rivalhubRRRounds += row.accountRR * rounds;
+      acc.hltvRatingRounds += row.rr * rounds;
+      acc.confidenceRounds += row.confidence * rounds;
+      acc.perMap.push({
+        matchId,
+        mapName: model.mapName,
+        rivalhubRR: row.accountRR,
+        hltvRating: row.rr,
+        adr: row.adr,
+        kast: row.kast
+      });
+      players.set(row.steamId64, acc);
+    }
+  }
+
+  const scoreboard = [...players.values()]
+    .map((row): SeriesPlayerRow => ({
+      playerKey: row.playerKey,
+      name: row.name,
+      teamName: row.teamName,
+      mapCount: row.mapCount,
+      totalRounds: row.totalRounds,
+      kills: row.kills,
+      deaths: row.deaths,
+      assists: row.assists,
+      adr: round(row.damage / row.totalRounds, 1),
+      kast: round((row.kastRounds / row.totalRounds) * 100, 1),
+      rivalhubRR: round(row.rivalhubRRRounds / row.totalRounds, 3),
+      hltvRating: round(row.hltvRatingRounds / row.totalRounds, 2),
+      confidence: round(row.confidenceRounds / row.totalRounds, 3),
+      perMap: row.perMap
+    }))
+    .sort((a, b) => b.rivalhubRR - a.rivalhubRR || b.hltvRating - a.hltvRating);
+
+  return seriesSummarySchema.parse({
+    version: "cs2-demo-analysis-kit/series-summary-0.1",
+    mapCount: matches.length,
+    maps: matches.map(({ matchId, model }) => ({
+      matchId,
+      mapName: model.mapName,
+      scoreline: model.scoreline,
+      teamAName: teamIdentity(matchId, "teamA", model, options).name,
+      teamBName: teamIdentity(matchId, "teamB", model, options).name,
+      winnerName: model.teams.teamA.score === model.teams.teamB.score
+        ? null
+        : model.teams.teamA.score > model.teams.teamB.score
+          ? teamIdentity(matchId, "teamA", model, options).name
+          : teamIdentity(matchId, "teamB", model, options).name
+    })),
+    teams: [...teams.values()].sort((a, b) => b.mapsWon - a.mapsWon || a.name.localeCompare(b.name)),
+    scoreboard,
+    mvpCandidates: rankMvpCandidates(scoreboard)
+  });
+}

package/src/team.test.ts

@@ -0,0 +1,77 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { loadDemoPackageFromZip } from "@cs2dak/core";
+import { buildSeasonCohort } from "@cs2dak/cohort";
+import { teamCohortSummarySchema } from "@cs2dak/contract";
+import { buildTeamCohortSummary } from "./index";
+
+const fixtureDir = fileURLToPath(new URL("../../../fixtures/input/cohort", import.meta.url));
+const integrationTimeoutMs = 20_000;
+let cohortFixtures: ReturnType<typeof buildCohort> | null = null;
+
+async function buildCohort() {
+  const names = (await readdir(fixtureDir)).filter((name) => name.endsWith(".zip")).sort();
+  const demos = await Promise.all(
+    names.map(async (name) => ({
+      matchId: name.replace(/\.zip$/, ""),
+      pkg: await loadDemoPackageFromZip(await readFile(join(fixtureDir, name)))
+    }))
+  );
+  return buildSeasonCohort(demos);
+}
+
+function getCohort() {
+  cohortFixtures ??= buildCohort();
+  return cohortFixtures;
+}
+
+describe("buildTeamCohortSummary", () => {
+  it(
+    "builds a product-neutral team summary from an externally supplied roster",
+    async () => {
+      const bundle = await getCohort();
+      const roster = bundle.players.slice(0, 5);
+      const summary = buildTeamCohortSummary(bundle, {
+        teamKey: "rivals-alpha",
+        name: "Rivals Alpha",
+        playerKeys: roster.map((player) => player.playerKey)
+      });
+
+      expect(() => teamCohortSummarySchema.parse(summary)).not.toThrow();
+      expect(summary.teamKey).toBe("rivals-alpha");
+      expect(summary.name).toBe("Rivals Alpha");
+      expect(summary.members).toHaveLength(5);
+      expect(summary.coreMembers).toHaveLength(5);
+      expect(summary.averages.rivalhubRR).toBeCloseTo(
+        roster.reduce((sum, player) => sum + player.accountRR, 0) / roster.length,
+        2
+      );
+      expect(summary.leaders.map((leader) => leader.metric)).toEqual([
+        "rivalhubRR",
+        "adr",
+        "kast",
+        "firstKillPer100"
+      ]);
+      expect(summary.performance.firstKills).toBeGreaterThanOrEqual(0);
+      expect(summary.performance.firstDeaths).toBeGreaterThanOrEqual(0);
+      expect(summary.performance.openingDuelWinRate).toBeGreaterThanOrEqual(0);
+      expect(summary.performance.clutchAttempts).toBeGreaterThanOrEqual(summary.performance.clutchWins);
+      expect(summary.roleComplementarity.coverageScore).toBeGreaterThanOrEqual(0);
+      expect(summary.roleComplementarity.coverageScore).toBeLessThanOrEqual(100);
+      expect(summary).not.toHaveProperty("userId");
+    },
+    integrationTimeoutMs
+  );
+
+  it("rejects an empty or unknown roster", async () => {
+    const bundle = await getCohort();
+    expect(() =>
+      buildTeamCohortSummary(bundle, { teamKey: "empty", name: "Empty", playerKeys: [] })
+    ).toThrow(/at least one/);
+    expect(() =>
+      buildTeamCohortSummary(bundle, { teamKey: "unknown", name: "Unknown", playerKeys: ["missing"] })
+    ).toThrow(/not found/);
+  }, integrationTimeoutMs);
+});

package/src/team.ts

@@ -0,0 +1,137 @@
+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);
+}
+
+function memberSummary(player: SeasonCohortBundle["players"][number]): TeamMemberSummary {
+  return {
+    playerKey: player.playerKey,
+    name: player.name,
+    mapCount: player.mapCount,
+    confidence: player.confidence,
+    metrics: computeSeasonMetrics(player)
+  };
+}
+
+function metricValues(members: TeamMemberSummary[], key: LeaderboardMetricKey): number[] {
+  return members.map((member) => member.metrics[key]).filter((value): value is number => value != null);
+}
+
+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
+    },
+    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)
+    }
+  });
+}

package/src/weapons.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { displayWeaponName } from "./weapons";
+
+describe("displayWeaponName", () => {
+  it("maps raw codes to canonical display names", () => {
+    expect(displayWeaponName("ak47")).toBe("AK-47");
+    expect(displayWeaponName("m4a1_silencer")).toBe("M4A1-S");
+    expect(displayWeaponName("awp")).toBe("AWP");
+    expect(displayWeaponName("deagle")).toBe("Desert Eagle");
+  });
+
+  it("strips the weapon_ prefix and is case-insensitive", () => {
+    expect(displayWeaponName("weapon_ak47")).toBe("AK-47");
+    expect(displayWeaponName("WEAPON_AWP")).toBe("AWP");
+  });
+
+  it("collapses every knife/bayonet variant to a single label", () => {
+    expect(displayWeaponName("knife")).toBe("knife");
+    expect(displayWeaponName("knife_karambit")).toBe("knife");
+    expect(displayWeaponName("weapon_bayonet")).toBe("knife");
+  });
+
+  it("falls back to the normalized code instead of an unknown placeholder", () => {
+    expect(displayWeaponName("weapon_some_future_gun")).toBe("some_future_gun");
+  });
+
+  it("never returns a purely numeric string for a named weapon", () => {
+    for (const raw of ["ak47", "m4a1_silencer", "knife_m9_bayonet", "future_gun"]) {
+      expect(/^\d+$/.test(displayWeaponName(raw))).toBe(false);
+    }
+  });
+});