@cs2dak/core 0.2.1 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cs2dak/core",
-  "version": "0.2.1",
+  "version": "1.0.0",
   "type": "module",
   "license": "MIT",
   "exports": {
@@ -9,7 +9,7 @@
   "dependencies": {
     "@rivalhub/rival-rating": "^0.1.0",
     "jszip": "^3.10.1",
-    "@cs2dak/contract": "0.2.1"
+    "@cs2dak/contract": "1.0.0"
   },
   "files": [
     "src"

package/src/economy.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import type { EconomyPoint } from "@cs2dak/contract";
-import { buildEconomyConversion, economyLabelCn } from "./economy";
+import { buildEconomyConversion } from "./economy";
 
 function pt(p: Partial<EconomyPoint> & Pick<EconomyPoint, "teamAEconomy" | "teamBEconomy" | "winnerTeamKey">): EconomyPoint {
   return {
@@ -35,17 +35,3 @@ describe("buildEconomyConversion", () => {
     expect(buildEconomyConversion([])).toEqual({ teamA: {}, teamB: {} });
   });
 });
-
-describe("economyLabelCn", () => {
-  it("maps known economy types to Chinese labels", () => {
-    expect(economyLabelCn("full")).toBe("全枪全弹");
-    expect(economyLabelCn("ECO")).toBe("纯ECO");
-    // conversion 与 full 同义（长枪局），不单独区分。
-    expect(economyLabelCn("conversion")).toBe(economyLabelCn("full"));
-  });
-
-  it("passes through unknowns and empties", () => {
-    expect(economyLabelCn(null)).toBe("");
-    expect(economyLabelCn("mystery")).toBe("mystery");
-  });
-});

package/src/economy.ts

@@ -16,25 +16,6 @@ export interface MatchEconomyConversion {
   teamB: EconomyConversion;
 }
 
-const ECONOMY_LABELS_CN: Record<string, string> = {
-  pistol: "手枪局",
-  eco: "纯ECO",
-  semi: "半起",
-  force: "强起",
-  full: "全枪全弹",
-  // conversion = 长枪局，与 full 同义，不单独区分。
-  conversion: "全枪全弹",
-};
-
-/**
- * 经济类型中文标签（转化率面板 / 榜单展示用）。
- * 统一了 RivalHub `economy-series.ts` 的 `economyLabelCn`。未知值原样返回。
- */
-export function economyLabelCn(type: string | null | undefined): string {
-  if (!type) return "";
-  return ECONOMY_LABELS_CN[type.toLowerCase()] ?? type;
-}
-
 function tally(
   acc: Map<string, { played: number; won: number }>,
   type: TeamEconomyType,

package/src/index.test.ts

@@ -3,69 +3,34 @@ import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import {
   analyzeDemoPackage,
-  buildMatchWorkspaceModel,
-  buildDemoViewModel,
   computeAccountRatingsV2,
   deriveAccountSignalsV2,
+  derivePlayerWeaponHighlights,
   deriveRRIndicators,
   loadDemoPackageFromZip
 } from "./index";
 
 describe("analyzeDemoPackage", () => {
-  it("builds a match workspace model with replay and user-facing modules from a strict v2 export", async () => {
-    const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
-    const pkg = await loadDemoPackageFromZip(zip);
-    const workspace = buildMatchWorkspaceModel(pkg);
-
-    expect(workspace.version).toBe("cs2-demo-analysis-kit/workspace-0.1");
-    expect(workspace.title).toBe("Team A vs Team B");
-    expect(workspace.tabs.map((tab) => tab.key)).toEqual(["overview", "rounds", "players", "economy", "map", "replay"]);
-    expect(workspace.overview.kpis.map((kpi) => kpi.key)).not.toContain("qa");
-    expect(workspace.overview.kpis.map((kpi) => kpi.key)).not.toContain("economySwing");
-    expect(workspace.rounds).toHaveLength(21);
-    expect(workspace.rounds[0]?.events.some((event) => event.type === "kill")).toBe(true);
-    expect(workspace.players).toHaveLength(10);
-    expect(workspace.players[0]?.rrBreakdown.length).toBe(5);
-    expect(workspace.map.modes.map((mode) => mode.key)).toEqual(["death", "kill", "grenade", "bomb", "position"]);
-    expect(workspace.replay.available).toBe(true);
-    expect(workspace.replay.rounds.length).toBeGreaterThan(0);
-    expect(workspace.replay.rounds[0]?.players[0]?.frames.length).toBeGreaterThan(0);
-    expect(workspace.replay.capabilities.hasDefuseKit).toBe(true);
-    expect(workspace.replay.capabilities.hasBombPosition).toBe(false);
-    expect(workspace.replay.rounds.some((round) => round.players.some((player) => player.frames.some((frame) => frame.weapon && /^\d+$/.test(frame.weapon))))).toBe(false);
-    expect(workspace.overview.story.length).toBeGreaterThan(0);
-    // 开场 beat 必出：含地图显示名 + 比分，且用胜负动词之一描述结果。
-    expect(workspace.overview.story[0]).toContain("Ancient");
-    expect(workspace.overview.story[0]).toContain("13:8");
-    expect(workspace.overview.story[0]).toMatch(/碾压|险胜|拿下/);
-    expect(workspace.overview.story.join("\n")).not.toContain("打成");
-    expect(workspace.adminQa.summary.errorCount).toBe(0);
-  });
-
   it("builds reusable analysis and view-model artifacts from a strict v2 export", async () => {
     const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
     const pkg = await loadDemoPackageFromZip(zip);
     const bundle = analyzeDemoPackage(pkg);
-    const viewModel = buildDemoViewModel(bundle);
-
     expect(bundle.sourceSchemaVersion).toBe("cs2-demo-format/2.0");
-    expect(bundle.version).toBe("cs2-demo-analysis-kit/0.2");
+    expect(bundle.version).toBe("cs2-demo-analysis-kit/1.0");
+    expect(bundle.provenance.sourceSchemaVersion).toBe("cs2-demo-format/2.0");
+    expect(bundle.provenance.ratingVersions.rr).toBeTruthy();
     expect(bundle.scoreboard).toHaveLength(10);
     expect(bundle.scoreboard[0]?.rr).toBeGreaterThan(0);
-    expect(bundle.playerIndicators[0]?.indicators.totalRounds).toBe(21);
-    expect(bundle.playerRoundFacts).toHaveLength(210);
-    expect(bundle.economy).toHaveLength(21);
-    expect(bundle.timeline.filter((event) => event.type === "kill")).toHaveLength(142);
-    expect(bundle.timeline.filter((event) => event.type === "bomb")).toHaveLength(94);
-    expect(bundle.heatmap.filter((point) => point.kind === "death")).toHaveLength(142);
+    expect(bundle.playerIndicators[0]?.indicators.totalRounds).toBe(16);
+    expect(bundle.playerRoundFacts).toHaveLength(160);
+    expect(bundle.economy).toHaveLength(16);
+    expect(bundle.timeline.filter((event) => event.type === "kill")).toHaveLength(119);
+    expect(bundle.timeline.filter((event) => event.type === "bomb")).toHaveLength(51);
+    expect(bundle.heatmap.filter((point) => point.kind === "death")).toHaveLength(119);
     expect(bundle.timeline.some((event) => event.type === "kill")).toBe(true);
     expect(bundle.heatmap.some((point) => point.kind === "death")).toBe(true);
     expect(bundle.timeline.find((event) => event.type === "round-end")?.clockPhase).toBe("round-end");
     expect(bundle.timeline.find((event) => event.type === "kill")?.clockLabel).toMatch(/^\d:\d{2}$/);
-    expect(viewModel.scoreline).toBe("13:8");
-    expect(viewModel.map.name).toBe("de_ancient");
-    expect(viewModel.map.radarImageUrl).toBe("./maps/radars/de_ancient.png");
-    expect(viewModel.qa.summary.errorCount).toBe(0);
   });
 
   it("derives value-account signals and computes v2 RR from the strict v2 fixture", async () => {
@@ -76,10 +41,10 @@ describe("analyzeDemoPackage", () => {
 
     expect(signals).toHaveLength(10);
     expect(ratings).toHaveLength(10);
-    expect(signals[0]?.rounds).toBe(21);
-    expect(signals[0]?.combat.killsByBuyDelta).toEqual({ disadvantage: 0, even: 2, advantage: 5 });
-    expect(signals[0]?.combat.killsByManState).toEqual({ manDown: 1, even: 5, manUp: 1 });
-    expect(signals[0]?.trade.tradedOpeningDeaths).toBe(1);
+    expect(signals[0]?.rounds).toBe(16);
+    expect(signals[0]?.combat.killsByBuyDelta).toEqual({ disadvantage: 2, even: 3, advantage: 8 });
+    expect(signals[0]?.combat.killsByManState).toEqual({ manDown: 2, even: 5, manUp: 6 });
+    expect(signals[0]?.trade.tradedOpeningDeaths).toBe(0);
     expect(ratings[0]?.rr.model).toBe("value-accounts-v2-lite");
     expect(ratings[0]?.rr.rr).toBeGreaterThan(0);
   });
@@ -152,11 +117,11 @@ describe("analyzeDemoPackage", () => {
     const bundle = analyzeDemoPackage(pkg);
     const row = bundle.scoreboard[0]!;
 
-    expect(row.combatDeathCount).toBe(11);
+    expect(row.combatDeathCount).toBe(9);
     expect(row.bombDeathCount).toBe(0);
-    expect(row.bombPlantCount).toBe(4);
+    expect(row.bombPlantCount).toBe(0);
     expect(row.noScopeKillCount).toBe(0);
-    expect(row.throughSmokeKillCount).toBe(2);
+    expect(row.throughSmokeKillCount).toBe(0);
     expect(row.fieldAvailability).toEqual({
       playerStats: "available",
       economy: "available",
@@ -168,6 +133,28 @@ describe("analyzeDemoPackage", () => {
     expect(row.confidence).toBeCloseTo(0.917, 3);
   });
 
+  it("derives reusable per-player weapon kill distribution and highlight facts", async () => {
+    const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
+    const pkg = await loadDemoPackageFromZip(zip);
+    const facts = derivePlayerWeaponHighlights(pkg);
+    const bundle = analyzeDemoPackage(pkg);
+
+    expect(facts).toHaveLength(pkg.players.length);
+    expect(bundle.playerWeaponHighlights).toEqual(facts);
+    expect(facts.every((row) => row.weapons.reduce((sum, weapon) => sum + weapon.kills, 0) === row.totalKills)).toBe(true);
+    expect(facts.flatMap((row) => row.weapons).some((weapon) => weapon.weapon === "ak47")).toBe(true);
+    expect(facts.flatMap((row) => row.weapons).every((weapon) =>
+      weapon.headshotKills <= weapon.kills
+      && weapon.tradeKills <= weapon.kills
+      && weapon.noScopeKills <= weapon.kills
+      && weapon.throughSmokeKills <= weapon.kills
+      && weapon.wallbangKills <= weapon.kills
+    )).toBe(true);
+    expect(facts.every((row) => row.highlights.wallbangKills != null)).toBe(true);
+    expect(facts.every((row) => row.highlights.noScopeKills != null)).toBe(true);
+    expect(facts.every((row) => row.highlights.throughSmokeKills != null)).toBe(true);
+  });
+
   it("emits null context buckets (not zero) when the data source is missing", async () => {
     const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
     const pkg = await loadDemoPackageFromZip(zip);

package/src/index.ts

@@ -4,19 +4,21 @@ import { buildQaReport } from "./qa.js";
 import { buildPlayerRoundFacts, buildPlayerIndicators, buildScoreboard } from "./scoreboard.js";
 import { computeAccountRatingsV2 } from "./signals.js";
 import { buildTimeline, buildEconomy, buildHeatmap } from "./timeline.js";
+import { buildPlayerWeaponHighlights } from "./weapon-highlights.js";
 
 export { loadDemoPackageFromZip } from "./loader.js";
 export { normalizeDemoPackage } from "./normalize.js";
 export { deriveAccountSignalsV2, computeAccountRatingsV2 } from "./signals.js";
 export { deriveRRIndicators } from "./scoreboard.js";
-export { buildDemoViewModel, buildMatchWorkspaceModel } from "./workspace.js";
-export { displayWeaponName } from "./weapons.js";
-export { buildEconomyConversion, economyLabelCn } from "./economy.js";
+export { derivePlayerWeaponHighlights } from "./weapon-highlights.js";
+export { buildEconomyConversion } from "./economy.js";
+export { buildTeamSideWinRates } from "./side-win-rate.js";
 export type {
   EconomyTypeStats,
   EconomyConversion,
   MatchEconomyConversion,
 } from "./economy.js";
+export type { SideWinRateStats, TeamSideWinRates } from "./side-win-rate.js";
 
 export function analyzeDemoPackage(input: unknown): AnalysisBundle {
   const pkg = normalizeDemoPackage(input);
@@ -25,13 +27,25 @@ export function analyzeDemoPackage(input: unknown): AnalysisBundle {
   const playerIndicators = buildPlayerIndicators(pkg, playerRoundFacts);
   const accountRatings = computeAccountRatingsV2(pkg);
   const scoreboard = buildScoreboard(pkg, playerIndicators, accountRatings);
+  const playerWeaponHighlights = buildPlayerWeaponHighlights(pkg);
   const timeline = buildTimeline(pkg);
   const economy = buildEconomy(pkg);
   const heatmap = buildHeatmap(pkg);
 
   return analysisBundleSchema.parse({
-    version: "cs2-demo-analysis-kit/0.2",
+    version: "cs2-demo-analysis-kit/1.0",
     sourceSchemaVersion: pkg.manifest.schemaVersion,
+    provenance: {
+      analysisVersion: "cs2-demo-analysis-kit/1.0",
+      sourceSchemaVersion: pkg.manifest.schemaVersion,
+      sourceDemoHash: pkg.manifest.demo?.hash ?? null,
+      exporter: pkg.manifest.exporter,
+      parser: pkg.manifest.parser,
+      ratingVersions: {
+        rr: playerIndicators[0]?.rr.weightsVersion ?? null,
+        valueAccounts: accountRatings[0]?.rr.weightsVersion ?? null
+      }
+    },
     mapName: pkg.match.mapName,
     tickrate: pkg.match.tickrate,
     teams: {
@@ -39,6 +53,7 @@ export function analyzeDemoPackage(input: unknown): AnalysisBundle {
       teamB: { name: pkg.match.teamB.name ?? "Team B", score: pkg.match.teamB.score }
     },
     scoreboard,
+    playerWeaponHighlights,
     playerIndicators,
     playerRoundFacts,
     timeline,

package/src/normalize.ts

@@ -1,158 +1,9 @@
-import { demoPackageSchema, type DemoPackage, type TeamKey } from "@cs2dak/contract";
+import { demoPackageSchema, type DemoPackage } from "@cs2dak/contract";
 
 export function parsePackageJson(text: string): unknown {
   return JSON.parse(text.replace(/\bNaN\b/g, "null"));
 }
 
 export function normalizeDemoPackage(input: unknown): DemoPackage {
-  const raw = input as Record<string, unknown>;
-  const manifest = raw.manifest as Record<string, unknown> | undefined;
-
-  if (manifest?.schemaVersion === "cs2-demo-format/1.0") {
-    return demoPackageSchema.parse(normalizeV1Package(raw));
-  }
-
   return demoPackageSchema.parse(input);
 }
-
-function normalizeV1Package(raw: Record<string, unknown>): Record<string, unknown> {
-  const match = raw.match as Record<string, unknown>;
-  const rounds = asRecords(raw.rounds).filter((round) => numberValue(round.roundNumber) > 0);
-  const roundByNumber = new Map(rounds.map((round) => [numberValue(round.roundNumber), round]));
-
-  return {
-    manifest: {
-      ...(raw.manifest as Record<string, unknown>),
-      schemaVersion: "cs2-demo-format/2.0"
-    },
-    match: {
-      ...match,
-      durationSeconds: numberValue(match.durationSeconds) > 0 ? match.durationSeconds : undefined
-    },
-    players: raw.players,
-    rounds: rounds.map((round) => normalizeV1Round(round)),
-    playerEconomies: asRecords(raw.playerEconomies)
-      .filter((row) => numberValue(row.roundNumber) > 0)
-      .map((row) => ({ ...row, type: normalizeEconomyType(row.type) })),
-    playerStats: raw.playerStats ?? [],
-    kills: asRecords(raw.kills)
-      .filter((kill) => numberValue(kill.roundNumber) > 0)
-      .map((kill) => normalizeV1Kill(kill, roundByNumber)),
-    damages: asRecords(raw.damages)
-      .filter((row) => numberValue(row.roundNumber) > 0)
-      .map((row) => normalizeV1Damage(row, roundByNumber)),
-    blinds: asRecords(raw.blinds).filter((row) => numberValue(row.roundNumber) > 0),
-    grenades: asRecords(raw.grenades)
-      .filter((row) => numberValue(row.roundNumber) > 0)
-      .map((row) => normalizeV1Grenade(row, roundByNumber)),
-    clutches: asRecords(raw.clutches).filter((row) => numberValue(row.roundNumber) > 0)
-  };
-}
-
-function asRecords(value: unknown): Record<string, unknown>[] {
-  return Array.isArray(value) ? value.filter((row): row is Record<string, unknown> => !!row && typeof row === "object" && !Array.isArray(row)) : [];
-}
-
-function normalizeV1Round(round: Record<string, unknown>): Record<string, unknown> {
-  return {
-    ...round,
-    startTick: positiveInt(round.startTick),
-    freezeEndTick: positiveInt(round.freezeEndTick),
-    endTick: positiveInt(round.endTick),
-    teamASide: normalizeSide(round.teamASide) ?? "t",
-    teamBSide: normalizeSide(round.teamBSide) ?? "ct",
-    teamAEconomy: normalizeEconomyType(round.teamAEconomy),
-    teamBEconomy: normalizeEconomyType(round.teamBEconomy),
-    winnerSide: normalizeSide(round.winnerSide) ?? sideForTeam(round.winnerTeamKey, round) ?? "t"
-  };
-}
-
-function normalizeV1Kill(kill: Record<string, unknown>, rounds: Map<number, Record<string, unknown>>): Record<string, unknown> {
-  const round = rounds.get(numberValue(kill.roundNumber));
-  return {
-    ...kill,
-    tick: positiveInt(kill.tick),
-    killerTeamKey: normalizeTeamKey(kill.killerTeamKey),
-    victimTeamKey: normalizeTeamKey(kill.victimTeamKey) ?? "teamA",
-    killerSide: normalizeSide(kill.killerSide) ?? sideForTeam(kill.killerTeamKey, round),
-    victimSide: normalizeSide(kill.victimSide) ?? sideForTeam(kill.victimTeamKey, round) ?? "t",
-    killerPosition: sanitizeNullablePosition(kill.killerPosition),
-    victimPosition: sanitizePosition(kill.victimPosition)
-  };
-}
-
-function normalizeV1Damage(row: Record<string, unknown>, rounds: Map<number, Record<string, unknown>>): Record<string, unknown> {
-  const round = rounds.get(numberValue(row.roundNumber));
-  return {
-    ...row,
-    tick: positiveInt(row.tick),
-    weapon: typeof row.weapon === "string" && row.weapon.length > 0 ? row.weapon : "unknown",
-    attackerTeamKey: normalizeTeamKey(row.attackerTeamKey),
-    victimTeamKey: normalizeTeamKey(row.victimTeamKey) ?? "teamA",
-    attackerSide: normalizeSide(row.attackerSide) ?? sideForTeam(row.attackerTeamKey, round),
-    victimSide: normalizeSide(row.victimSide) ?? sideForTeam(row.victimTeamKey, round) ?? "t",
-    attackerPosition: sanitizeNullablePosition(row.attackerPosition),
-    victimPosition: sanitizeNullablePosition(row.victimPosition) ?? undefined
-  };
-}
-
-function normalizeV1Grenade(row: Record<string, unknown>, rounds: Map<number, Record<string, unknown>>): Record<string, unknown> {
-  const round = rounds.get(numberValue(row.roundNumber));
-  const teamKey = normalizeTeamKey(row.throwerTeamKey ?? row.teamKey);
-  return {
-    roundNumber: row.roundNumber,
-    tick: positiveInt(row.effectTick ?? row.throwTick ?? row.tick),
-    steamId64: row.throwerSteamId64 ?? row.steamId64 ?? null,
-    teamKey,
-    side: normalizeSide(row.throwerSide ?? row.side) ?? sideForTeam(teamKey, round),
-    grenadeType: typeof row.grenade === "string" && row.grenade.length > 0 ? row.grenade : row.grenadeType ?? "unknown",
-    eventType: row.eventType ?? "effect",
-    position: sanitizeNullablePosition(row.effectPosition ?? row.throwPosition ?? row.position)
-  };
-}
-
-function sideForTeam(teamKey: unknown, round: Record<string, unknown> | undefined): "t" | "ct" | null {
-  const team = normalizeTeamKey(teamKey);
-  if (!team || !round) {
-    return null;
-  }
-  return normalizeSide(team === "teamA" ? round.teamASide : round.teamBSide);
-}
-
-function normalizeTeamKey(value: unknown): TeamKey | null {
-  return value === "teamA" || value === "teamB" ? value : null;
-}
-
-function normalizeSide(value: unknown): "t" | "ct" | null {
-  return value === "t" || value === "ct" ? value : null;
-}
-
-function normalizeEconomyType(value: unknown): "pistol" | "eco" | "semi" | "force" | "full" | "conversion" {
-  return value === "pistol" || value === "eco" || value === "semi" || value === "force" || value === "full" || value === "conversion" ? value : "full";
-}
-
-function numberValue(value: unknown): number {
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-
-function positiveInt(value: unknown): number {
-  return Math.max(1, Math.trunc(numberValue(value)));
-}
-
-function sanitizeNullablePosition(value: unknown): { x: number; y: number; z: number } | null {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return null;
-  }
-  const point = value as Record<string, unknown>;
-  const x = numberValue(point.x);
-  const y = numberValue(point.y);
-  const z = numberValue(point.z);
-  if (x === 0 && y === 0 && z === 0) {
-    return null;
-  }
-  return { x, y, z };
-}
-
-function sanitizePosition(value: unknown): { x: number; y: number; z: number } {
-  return sanitizeNullablePosition(value) ?? { x: 0, y: 0, z: 0 };
-}

package/src/side-win-rate.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import type { DemoPackage } from "@cs2dak/contract";
+import { buildTeamSideWinRates } from "./side-win-rate";
+
+describe("buildTeamSideWinRates", () => {
+  it("aggregates T/CT win rates for both teams from canonical rounds", () => {
+    const pkg = {
+      rounds: [
+        { teamASide: "ct", teamBSide: "t", winnerTeamKey: "teamA" },
+        { teamASide: "ct", teamBSide: "t", winnerTeamKey: "teamB" },
+        { teamASide: "t", teamBSide: "ct", winnerTeamKey: "teamA" }
+      ]
+    } as DemoPackage;
+
+    expect(buildTeamSideWinRates(pkg)).toEqual({
+      teamA: {
+        ct: { played: 2, won: 1, winRate: 0.5 },
+        t: { played: 1, won: 1, winRate: 1 }
+      },
+      teamB: {
+        t: { played: 2, won: 1, winRate: 0.5 },
+        ct: { played: 1, won: 0, winRate: 0 }
+      }
+    });
+  });
+
+  it("returns empty team summaries when rounds are unavailable", () => {
+    expect(buildTeamSideWinRates({ rounds: [] } as unknown as DemoPackage)).toEqual({
+      teamA: {},
+      teamB: {}
+    });
+  });
+});

package/src/side-win-rate.ts

@@ -0,0 +1,49 @@
+import type { DemoPackage, Side, TeamKey } from "@cs2dak/contract";
+
+export interface SideWinRateStats {
+  played: number;
+  won: number;
+  winRate: number;
+}
+
+export type TeamSideWinRates = Record<TeamKey, Partial<Record<Side, SideWinRateStats>>>;
+
+interface SideRoundResult {
+  side: Side;
+  won: boolean;
+}
+
+function aggregateSideWinRates(rows: SideRoundResult[]): Partial<Record<Side, SideWinRateStats>> {
+  const groups = new Map<Side, { played: number; won: number }>();
+  for (const row of rows) {
+    const group = groups.get(row.side) ?? { played: 0, won: 0 };
+    group.played += 1;
+    if (row.won) group.won += 1;
+    groups.set(row.side, group);
+  }
+
+  return Object.fromEntries(
+    [...groups.entries()].map(([side, stats]) => [
+      side,
+      { ...stats, winRate: stats.played > 0 ? stats.won / stats.played : 0 }
+    ])
+  );
+}
+
+/**
+ * 按 T/CT side 汇总一场比赛中两队的回合胜率。
+ *
+ * 取代产品从数据库行重新拼装的 half-side 聚合；产品只负责选择 DemoPackage。
+ */
+export function buildTeamSideWinRates(pkg: DemoPackage): TeamSideWinRates {
+  return {
+    teamA: aggregateSideWinRates(pkg.rounds.map((round) => ({
+      side: round.teamASide,
+      won: round.winnerTeamKey === "teamA"
+    }))),
+    teamB: aggregateSideWinRates(pkg.rounds.map((round) => ({
+      side: round.teamBSide,
+      won: round.winnerTeamKey === "teamB"
+    })))
+  };
+}

package/src/signals.ts

@@ -48,7 +48,7 @@ export function deriveAccountSignalsV2(input: unknown): AccountSignalsV2[] {
     return {
       steamId64: player.steamId64,
       rounds,
-      sourceVersion: "cs2-demo-analysis-kit/0.3",
+      sourceVersion: "cs2-demo-analysis-kit/1.0",
       combat: {
         kills: stats?.kills ?? playerKills.length,
         deaths: stats?.deaths ?? playerDeaths.length,

package/src/weapon-highlights.ts

@@ -0,0 +1,55 @@
+import {
+  playerWeaponHighlightFactsSchema,
+  type DemoPackage,
+  type PlayerWeaponHighlightFacts
+} from "@cs2dak/contract";
+import { normalizeDemoPackage } from "./normalize.js";
+import { killWeaponName } from "./utils.js";
+
+export function derivePlayerWeaponHighlights(input: unknown): PlayerWeaponHighlightFacts[] {
+  return buildPlayerWeaponHighlights(normalizeDemoPackage(input));
+}
+
+export function buildPlayerWeaponHighlights(pkg: DemoPackage): PlayerWeaponHighlightFacts[] {
+  const statsBySteamId = new Map(pkg.playerStats.map((row) => [row.steamId64, row]));
+
+  return pkg.players.map((player) => {
+    const stats = statsBySteamId.get(player.steamId64);
+    const kills = pkg.kills.filter((kill) => kill.killerSteamId64 === player.steamId64);
+    const weaponCounts = new Map<string, PlayerWeaponHighlightFacts["weapons"][number]>();
+    for (const kill of kills) {
+      const weapon = killWeaponName(kill);
+      const row = weaponCounts.get(weapon) ?? {
+        weapon,
+        kills: 0,
+        headshotKills: 0,
+        tradeKills: 0,
+        noScopeKills: 0,
+        throughSmokeKills: 0,
+        wallbangKills: 0,
+        penetratedObjects: 0
+      };
+      row.kills += 1;
+      if (kill.headshot) row.headshotKills += 1;
+      if (kill.tradeKill) row.tradeKills += 1;
+      if (kill.noScope) row.noScopeKills += 1;
+      if (kill.throughSmoke) row.throughSmokeKills += 1;
+      if ((kill.penetratedObjects ?? 0) > 0) row.wallbangKills += 1;
+      row.penetratedObjects += kill.penetratedObjects ?? 0;
+      weaponCounts.set(weapon, row);
+    }
+
+    return playerWeaponHighlightFactsSchema.parse({
+      steamId64: player.steamId64,
+      totalKills: kills.length,
+      weapons: [...weaponCounts.values()]
+        .sort((a, b) => b.kills - a.kills || a.weapon.localeCompare(b.weapon)),
+      highlights: {
+        wallbangKills: stats?.wallbangKillCount ?? kills.filter((kill) => (kill.penetratedObjects ?? 0) > 0).length,
+        noScopeKills: stats?.noScopeKillCount ?? kills.filter((kill) => kill.noScope).length,
+        throughSmokeKills: kills.filter((kill) => kill.throughSmoke).length,
+        collateralKills: stats?.collateralKillCount ?? null
+      }
+    });
+  });
+}

package/src/weapons.test.ts

@@ -1,32 +0,0 @@
-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);
-    }
-  });
-});