@cs2dak/cohort 0.2.1 → 2.0.0

package/LICENSE

@@ -1,3 +1,10 @@
+Licensing note / 适用范围
+-------------------------
+The MIT License below applies to this repository EXCEPT apps/dak-studio/,
+which is licensed under the GNU AGPL-3.0-only (see apps/dak-studio/LICENSE).
+Ecosystem packages (@cs2dak/*, python exporter) are MIT; the DAK Studio
+product is AGPL. Third-party attributions: THIRD-PARTY-NOTICES.md.
+
 MIT License
 
 Copyright (c) 2026 Starfie1d

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@cs2dak/cohort",
-  "version": "0.2.1",
+  "version": "2.0.0",
   "type": "module",
   "license": "MIT",
   "exports": {
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@rivalhub/rival-rating": "^0.1.0",
-    "@cs2dak/contract": "0.2.1",
-    "@cs2dak/core": "0.2.1"
+    "@rivalhub/rival-rating": "^0.3.0",
+    "@cs2dak/contract": "1.1.0",
+    "@cs2dak/core": "2.0.0"
   },
   "files": [
-    "src/index.ts"
+    "src"
   ],
   "publishConfig": {
     "access": "public"

package/src/index.test.ts

@@ -0,0 +1,150 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { beforeAll, describe, expect, it } from "vitest";
+import { derivePlayerWeaponHighlights, deriveRRIndicators, loadDemoPackageFromZip } from "@cs2dak/core";
+import type { DemoPackage } from "@cs2dak/contract";
+import { buildSeasonCohort } from "./index";
+
+const fixtureDir = fileURLToPath(new URL("../../../fixtures/input/cohort", import.meta.url));
+const integrationTimeoutMs = 90_000; // CI 2-core runner 加载 3 场 ZIP + cohort 分析比本机慢 5–10×
+let demos: Awaited<ReturnType<typeof loadCohortFixtures>> | null = null;
+let baselineBundle: ReturnType<typeof buildSeasonCohort> | null = null;
+
+async function loadCohortFixtures() {
+  const names = (await readdir(fixtureDir)).filter((name) => name.endsWith(".zip")).sort();
+  return Promise.all(
+    names.map(async (name) => ({
+      matchId: name.replace(/\.zip$/, ""),
+      pkg: await loadDemoPackageFromZip(await readFile(join(fixtureDir, name)))
+    }))
+  );
+}
+
+beforeAll(async () => {
+  demos = await loadCohortFixtures();
+  baselineBundle = buildSeasonCohort(demos);
+}, integrationTimeoutMs);
+
+describe("buildSeasonCohort", () => {
+  it("builds a season bundle from multiple sanitized demo packages", () => {
+    const bundle = baselineBundle!;
+    const uniquePlayers = new Set(demos!.flatMap((demo) => demo.pkg.players.map((player) => player.steamId64)));
+
+    expect(demos!).toHaveLength(3);
+    expect(bundle.matchCount).toBe(3);
+    expect(bundle.version).toBe("cs2-demo-analysis-kit/cohort-1.0");
+    expect(bundle.provenance.matches).toHaveLength(3);
+    expect(bundle.players).toHaveLength(uniquePlayers.size);
+    expect(bundle.players.length).toBeGreaterThan(10);
+    expect(bundle.players.every((row) => row.prism?.mapCount === row.mapCount)).toBe(true);
+    expect(bundle.players.every((row) => row.playerKey.startsWith("steam:"))).toBe(true);
+  });
+
+  it("merges the same steamId64 across matches and sums season counts", () => {
+    const bundle = baselineBundle!;
+    const repeated = bundle.players.find((row) => row.mapCount > 1);
+    expect(repeated).toBeDefined();
+
+    const expectedKills = demos!.reduce((total, demo) => {
+      const row = deriveRRIndicators(demo.pkg).find((indicator) => repeated!.steamIds.includes(indicator.steamId64));
+      return total + (row?.kills ?? 0);
+    }, 0);
+    const expectedRounds = demos!.reduce((total, demo) => {
+      const row = deriveRRIndicators(demo.pkg).find((indicator) => repeated!.steamIds.includes(indicator.steamId64));
+      return total + (row?.totalRounds ?? 0);
+    }, 0);
+
+    expect(repeated!.indicators.kills).toBe(expectedKills);
+    expect(repeated!.indicators.totalRounds).toBe(expectedRounds);
+    expect(repeated!.perMatch).toHaveLength(repeated!.mapCount);
+  });
+
+  it("can merge borrowed Steam accounts through an external identity map", () => {
+    const firstSteamId = demos![0]!.pkg.players[0]!.steamId64;
+    const borrowedSteamId = demos!
+      .slice(1)
+      .flatMap((demo) => demo.pkg.players.map((player) => player.steamId64))
+      .find((steamId) => steamId !== firstSteamId)!;
+    const bundle = buildSeasonCohort(demos!, {
+      identityMap: {
+        [firstSteamId]: {
+          playerKey: "user:rivalhub-user-1",
+          userId: "rivalhub-user-1",
+          displayName: "Unified Player"
+        },
+        [borrowedSteamId]: {
+          playerKey: "user:rivalhub-user-1",
+          userId: "rivalhub-user-1",
+          displayName: "Unified Player"
+        }
+      }
+    });
+    const merged = bundle.players.find((row) => row.playerKey === "user:rivalhub-user-1");
+
+    expect(bundle.players).toHaveLength(baselineBundle!.players.length - 1);
+    expect(merged).toBeDefined();
+    expect(merged!.name).toBe("Unified Player");
+    expect(merged!.externalUserId).toBe("rivalhub-user-1");
+    expect(merged!.steamIds).toEqual([borrowedSteamId, firstSteamId].sort());
+    expect([...new Set(merged!.perMatch.map((row) => row.steamId64))].sort()).toEqual([borrowedSteamId, firstSteamId].sort());
+    expect(merged!.indicators.steamId64).toBe("user:rivalhub-user-1");
+    expect(merged!.prism?.steamId64).toBe("user:rivalhub-user-1");
+  });
+
+  it("scores season accountRR against the same frozen pro baseline as single matches", () => {
+    const mean = baselineBundle!.players.reduce((sum, row) => sum + row.accountRR, 0) / baselineBundle!.players.length;
+
+    expect(mean).toBeGreaterThan(0);
+    expect(mean).not.toBeCloseTo(1, 2);
+    expect(baselineBundle!.players.some((row) => row.accountRR > 1)).toBe(true);
+    expect(baselineBundle!.players.some((row) => row.accountRR < 1)).toBe(true);
+  });
+
+  it("recomputes rate fields from summed counts and rounds", () => {
+    const bundle = baselineBundle!;
+    const repeated = bundle.players.find((row) => row.mapCount > 1);
+    expect(repeated).toBeDefined();
+
+    const sourceRows = demos!
+      .flatMap((demo) => deriveRRIndicators(demo.pkg))
+      .filter((row) => repeated!.steamIds.includes(row.steamId64));
+    const damage = sourceRows.reduce((sum, row) => sum + row.adr * row.totalRounds, 0);
+    const rounds = sourceRows.reduce((sum, row) => sum + row.totalRounds, 0);
+    const plainAverageAdr = sourceRows.reduce((sum, row) => sum + row.adr, 0) / sourceRows.length;
+
+    expect(repeated!.indicators.adr).toBeCloseTo(damage / rounds, 2);
+    expect(repeated!.indicators.adr).not.toBeCloseTo(plainAverageAdr, 4);
+  });
+
+  it("lowers confidence when context sources are missing", () => {
+    const complete = baselineBundle!;
+    const stripped = buildSeasonCohort(
+      demos!.map((demo) => ({
+        matchId: demo.matchId,
+        pkg: { ...demo.pkg, playerEconomies: [], rounds: [] } satisfies DemoPackage
+      }))
+    );
+
+    expect(complete.players[0]?.confidence).toBeGreaterThan(stripped.players[0]?.confidence ?? 1);
+    expect(stripped.players.every((row) => row.confidence >= 0 && row.confidence <= 1)).toBe(true);
+  });
+
+  it("sums weapon distributions and highlight counts across identities", () => {
+    const bundle = baselineBundle!;
+    const repeated = bundle.players.find((row) => row.mapCount > 1)!;
+    const source = demos!
+      .flatMap((demo) => derivePlayerWeaponHighlights(demo.pkg))
+      .filter((row) => repeated.steamIds.includes(row.steamId64));
+    const expectedTotalKills = source.reduce((sum, row) => sum + row.totalKills, 0);
+    const expectedNoScopes = source.reduce((sum, row) => sum + (row.highlights.noScopeKills ?? 0), 0);
+    const expectedWeaponHeadshots = source
+      .flatMap((row) => row.weapons)
+      .reduce((sum, weapon) => sum + weapon.headshotKills, 0);
+
+    expect(repeated.weaponHighlights.totalKills).toBe(expectedTotalKills);
+    expect(repeated.weaponHighlights.weapons.reduce((sum, row) => sum + row.kills, 0)).toBe(expectedTotalKills);
+    expect(repeated.weaponHighlights.weapons.reduce((sum, row) => sum + row.headshotKills, 0)).toBe(expectedWeaponHeadshots);
+    expect(repeated.weaponHighlights.highlights.noScopeKills).toBe(expectedNoScopes);
+  });
+});

package/src/index.ts

@@ -1,31 +1,77 @@
 import {
-  deriveAccountSignalsV2,
-  deriveRRIndicators,
-  computeAccountRatingsV2
+  deriveRRSignals,
+  derivePlayerWeaponHighlights,
+  deriveRRIndicators
 } from "@cs2dak/core";
 import {
   seasonCohortBundleSchema,
   type AccountContextAvailability,
-  type AccountSignalsV2,
   type DemoPackage,
   type RRIndicators,
+  type RRSignals,
+  type PlayerWeaponHighlightFacts,
   type SeasonCohortBundle,
   type TeamKey,
-  type ValueAccountsWeights
+  type RRSixAccountWeights
 } from "@cs2dak/contract";
 import {
-  computeCohortAccountsRR,
+  computeFrozenProBaselineRR,
   computePrism,
   computeRR,
   prismWeightsV1,
+  rrSixAccountProBaselineV0,
   rrToPercentile,
-  rrValueAccountsV2Lite,
-  rrWeightsV1,
+  hltv2BaselineWeightsV1,
+  rrSixAccountWeightsV1,
+  type ProBaselineConfig,
   type PrismComputeInput,
   type PrismWeights,
   type RRWeights
 } from "@rivalhub/rival-rating";
 
+export { buildOpeningPatternClusters } from "./patterns.js";
+export type { OpeningPatternCluster, OpeningPatternInput, OpeningPatternOptions } from "./patterns.js";
+export {
+  advancedBasisKey,
+  buildTacticalClusters,
+  chokeComboOf,
+  defaultsBasisKey,
+  economyEntryOf,
+  entryEvidenceKey,
+  openingIntentKey,
+  openingPatternKey,
+  positionGroupSetKey,
+  tacticalClusterKey,
+} from "./tactical-clusters.js";
+export type {
+  EconomyEntry,
+  TacticalCluster,
+  TacticalEntryEvidence,
+  TacticalEntryEvidenceRoute,
+  TacticalExecuteBucket,
+  TacticalPatternRow,
+} from "./tactical-clusters.js";
+export {
+  buildPlayerMapRoleEvidence,
+  buildTeamMapResponsibilityEvidence,
+  MAP_ROLE_MODEL_VERSION,
+  MAP_ROLE_THRESHOLDS,
+  type MapRoleEvidenceFacts,
+  type MapRoleEvidenceOptions,
+} from "./map-role-evidence.js";
+export {
+  buildTResponsibilityResearchProjections,
+  scoreFrozenTResponsibilityFeatures,
+  T_RESPONSIBILITY_RESEARCH_MODEL_ID,
+  T_RESPONSIBILITY_RESEARCH_THRESHOLD,
+} from "./t-role-research-projection.js";
+
+
+/**
+ * "Season" 是历史命名：cohort = 任意一组比赛的跨场聚合，不限于赛季。
+ * 同一 API 服务于赛季排行（RivalHub）、单赛事统计（主办方）、个人全量复盘（玩家）
+ * 与自选职业 demo 集（分析师）；范围筛选由调用方决定（如 DAK Studio 的聚合范围过滤）。
+ */
 export interface SeasonCohortInput {
   matchId: string;
   pkg: DemoPackage;
@@ -33,11 +79,22 @@ export interface SeasonCohortInput {
 
 export interface SeasonCohortOptions {
   rrWeights?: RRWeights;
-  valueWeights?: ValueAccountsWeights;
+  valueWeights?: RRSixAccountWeights;
   prismWeights?: PrismWeights;
   identityMap?: PlayerIdentityMap;
 }
 
+export interface SeasonCohortFactRow {
+  matchId: string;
+  sourceDemoHash: string | null;
+  steamId64: string;
+  playerName: string;
+  teamKey: TeamKey;
+  signals: RRSignals;
+  indicators: RRIndicators;
+  weaponHighlight: PlayerWeaponHighlightFacts | null;
+}
+
 export interface PlayerIdentity {
   playerKey: string;
   displayName?: string;
@@ -55,8 +112,9 @@ interface PlayerAccumulator {
   names: Map<string, number>;
   teamKeys: Set<TeamKey>;
   mapCount: number;
-  signals: AccountSignalsV2[];
+  signals: RRSignals[];
   indicators: RRIndicators[];
+  weaponHighlights: PlayerWeaponHighlightFacts[];
   perMatch: Array<{ matchId: string; steamId64: string; accountRR: number; rrV1: number }>;
 }
 
@@ -64,55 +122,87 @@ export function buildSeasonCohort(
   demos: SeasonCohortInput[],
   opts: SeasonCohortOptions = {}
 ): SeasonCohortBundle {
-  const rrWeights = opts.rrWeights ?? (rrWeightsV1 as unknown as RRWeights);
-  const valueWeights = opts.valueWeights ?? (rrValueAccountsV2Lite as unknown as ValueAccountsWeights);
-  const prismWeights = opts.prismWeights ?? (prismWeightsV1 as unknown as PrismWeights);
-  const identityMap = opts.identityMap ?? {};
-  const players = new Map<string, PlayerAccumulator>();
-
+  const rrWeights = opts.rrWeights ?? (hltv2BaselineWeightsV1 as unknown as RRWeights);
+  const valueWeights = opts.valueWeights ?? (rrSixAccountWeightsV1 as unknown as RRSixAccountWeights);
+  const rows: SeasonCohortFactRow[] = [];
   for (const demo of demos) {
-    const signals = deriveAccountSignalsV2(demo.pkg);
+    const signals = deriveRRSignals(demo.pkg);
     const indicators = deriveRRIndicators(demo.pkg);
-    const matchAccounts = computeAccountRatingsV2(demo.pkg);
-    const matchAccountBySteamId = new Map(matchAccounts.map((row) => [row.signals.steamId64, row.rr]));
-    const rrBySteamId = new Map(indicators.map((row) => [row.steamId64, computeRR(row, rrWeights)]));
-
+    const weaponHighlights = derivePlayerWeaponHighlights(demo.pkg);
+    const signalBySteamId = new Map(signals.map((row) => [row.steamId64, row]));
+    const indicatorBySteamId = new Map(indicators.map((row) => [row.steamId64, row]));
+    const weaponHighlightBySteamId = new Map(weaponHighlights.map((row) => [row.steamId64, row]));
     for (const player of demo.pkg.players) {
-      const signal = signals.find((row) => row.steamId64 === player.steamId64);
-      const indicator = indicators.find((row) => row.steamId64 === player.steamId64);
+      const signal = signalBySteamId.get(player.steamId64);
+      const indicator = indicatorBySteamId.get(player.steamId64);
       if (!signal || !indicator) continue;
-      const identity = resolveIdentity(player.steamId64, identityMap);
-
-      const acc = getOrInit(players, identity.playerKey, () => ({
-        playerKey: identity.playerKey,
-        steamIds: new Set<string>(),
-        primarySteamId64: player.steamId64,
-        externalUserId: identity.userId ?? null,
-        displayName: identity.displayName ?? null,
-        names: new Map<string, number>(),
-        teamKeys: new Set<TeamKey>(),
-        mapCount: 0,
-        signals: [],
-        indicators: [],
-        perMatch: []
-      }));
-
-      acc.steamIds.add(player.steamId64);
-      if (!acc.externalUserId && identity.userId) acc.externalUserId = identity.userId;
-      if (!acc.displayName && identity.displayName) acc.displayName = identity.displayName;
-      acc.names.set(player.name, (acc.names.get(player.name) ?? 0) + 1);
-      acc.teamKeys.add(player.teamKey);
-      acc.mapCount += 1;
-      acc.signals.push(signal);
-      acc.indicators.push(indicator);
-      acc.perMatch.push({
+      rows.push({
         matchId: demo.matchId,
+        sourceDemoHash: demo.pkg.manifest.demo?.hash ?? null,
         steamId64: player.steamId64,
-        accountRR: round(matchAccountBySteamId.get(player.steamId64)?.rr ?? 0, 3),
-        rrV1: round(rrBySteamId.get(player.steamId64)?.rr ?? 0, 3)
+        playerName: player.name,
+        teamKey: player.teamKey,
+        signals: signal,
+        indicators: indicator,
+        weaponHighlight: weaponHighlightBySteamId.get(player.steamId64) ?? null
       });
     }
   }
+  return buildSeasonCohortFromRows(rows, {
+    ...opts,
+    rrWeights,
+    valueWeights,
+    matchCount: demos.length
+  });
+}
+
+export function buildSeasonCohortFromRows(
+  rows: SeasonCohortFactRow[],
+  opts: SeasonCohortOptions & { matchCount?: number } = {}
+): SeasonCohortBundle {
+  const rrWeights = opts.rrWeights ?? (hltv2BaselineWeightsV1 as unknown as RRWeights);
+  const valueWeights = opts.valueWeights ?? (rrSixAccountWeightsV1 as unknown as RRSixAccountWeights);
+  const proBaseline = rrSixAccountProBaselineV0 as unknown as ProBaselineConfig;
+  const prismWeights = opts.prismWeights ?? (prismWeightsV1 as unknown as PrismWeights);
+  const identityMap = opts.identityMap ?? {};
+  const players = new Map<string, PlayerAccumulator>();
+
+  for (const row of rows) {
+    const identity = resolveIdentity(row.steamId64, identityMap);
+
+    const acc = getOrInit(players, identity.playerKey, () => ({
+      playerKey: identity.playerKey,
+      steamIds: new Set<string>(),
+      primarySteamId64: row.steamId64,
+      externalUserId: identity.userId ?? null,
+      displayName: identity.displayName ?? null,
+      names: new Map<string, number>(),
+      teamKeys: new Set<TeamKey>(),
+      mapCount: 0,
+      signals: [],
+      indicators: [],
+      weaponHighlights: [],
+      perMatch: []
+    }));
+
+    acc.steamIds.add(row.steamId64);
+    if (!acc.externalUserId && identity.userId) acc.externalUserId = identity.userId;
+    if (!acc.displayName && identity.displayName) acc.displayName = identity.displayName;
+    acc.names.set(row.playerName, (acc.names.get(row.playerName) ?? 0) + 1);
+    acc.teamKeys.add(row.teamKey);
+    acc.mapCount += 1;
+    acc.signals.push(row.signals);
+    acc.indicators.push(row.indicators);
+    if (row.weaponHighlight) acc.weaponHighlights.push(row.weaponHighlight);
+    const accountRR = computeFrozenProBaselineRR(row.signals, valueWeights, proBaseline);
+    const rrV1 = computeRR(row.indicators, rrWeights);
+    acc.perMatch.push({
+      matchId: row.matchId,
+      steamId64: row.steamId64,
+      accountRR: round(accountRR.rr, 3),
+      rrV1: round(rrV1.rr, 3)
+    });
+  }
 
   const seasonRows = [...players.values()].map((acc) => {
     const signals = aggregateAccountSignals(acc.playerKey, acc.signals);
@@ -121,15 +211,11 @@ export function buildSeasonCohort(
     return { acc, signals, indicators, rrV1 };
   });
 
-  // 账户平衡（标准化 + 残差化）由 rival-rating 的 computeCohortAccountsRR 拥有（公式归属）。
-  // scale 对齐到 rrV1 的离散度，使 v2 与已被 HLTV 逆向验证的 v1 量纲可比。详见该库 docs/rr-v2.md
-  // 与本仓库 docs/design/cohort.md。
-  const targetStd = stdev(seasonRows.map((row) => row.rrV1.rr));
   const balancedByKey = new Map(
-    computeCohortAccountsRR(seasonRows.map((row) => row.signals), valueWeights, { targetStd }).map((b) => [
-      b.steamId64,
-      b
-    ])
+    seasonRows.map((row) => {
+      const scored = computeFrozenProBaselineRR(row.signals, valueWeights, proBaseline);
+      return [scored.steamId64, scored] as const;
+    })
   );
   const rrV1Scores = seasonRows.map((row) => row.rrV1.rr);
   const prismInputs: PrismComputeInput[] = seasonRows.map((row) => ({
@@ -140,9 +226,17 @@ export function buildSeasonCohort(
   const prismResults = new Map(computePrism(prismInputs, prismWeights).map((row) => [row.steamId64, row]));
 
   return seasonCohortBundleSchema.parse({
-    version: "cs2-demo-analysis-kit/season-0.1",
-    matchCount: demos.length,
+    version: "cs2-demo-analysis-kit/cohort-1.0",
+    matchCount: opts.matchCount ?? new Set(rows.map((row) => row.matchId)).size,
     weightsVersion: `${rrWeights.version}+${valueWeights.version}+${prismWeights.version}`,
+    provenance: {
+      cohortVersion: "cs2-demo-analysis-kit/cohort-1.0",
+      sourceSchemaVersion: "cs2-demo-format/3.0",
+      matches: [...new Map(rows.map((row) => [row.matchId, {
+        matchId: row.matchId,
+        sourceDemoHash: row.sourceDemoHash
+      }])).values()]
+    },
     players: seasonRows
       .map((row) => {
         const balanced = balancedByKey.get(row.acc.playerKey)!;
@@ -159,11 +253,13 @@ export function buildSeasonCohort(
           rrV1: round(row.rrV1.rr, 3),
           rrV1Percentile: round(rrToPercentile(rrV1Scores, row.rrV1.rr), 1),
           indicators: row.indicators,
+          weaponHighlights: aggregateWeaponHighlights(row.acc.playerKey, row.acc.weaponHighlights),
           accountRR: round(balanced.rr, 3),
           accountRRRaw: round(balanced.rrRaw, 3),
           accountBreakdown: {
             combat: round(balanced.accounts.combat, 4),
             trade: round(balanced.accounts.trade, 4),
+            mapControl: round(balanced.accounts.mapControl, 4),
             clutch: round(balanced.accounts.clutch, 4),
             objective: round(balanced.accounts.objective, 4),
             utility: round(balanced.accounts.utility, 4)
@@ -174,7 +270,6 @@ export function buildSeasonCohort(
           perMatch: row.acc.perMatch.sort((a, b) => a.matchId.localeCompare(b.matchId))
         };
       })
-      .sort((a, b) => b.accountRR - a.accountRR || b.rrV1 - a.rrV1 || a.name.localeCompare(b.name))
   });
 }
 
@@ -185,11 +280,11 @@ function resolveIdentity(steamId64: string, identityMap: PlayerIdentityMap): Pla
   return value;
 }
 
-function aggregateAccountSignals(steamId64: string, rows: AccountSignalsV2[]): AccountSignalsV2 {
+function aggregateAccountSignals(steamId64: string, rows: RRSignals[]): RRSignals {
   return {
     steamId64,
     rounds: sum(rows, (row) => row.rounds),
-    sourceVersion: "cs2-demo-analysis-kit/season-0.1",
+    sourceVersion: "cs2-demo-analysis-kit/cohort-1.0",
     combat: {
       kills: sum(rows, (row) => row.combat.kills),
       deaths: sum(rows, (row) => row.combat.deaths),
@@ -212,7 +307,15 @@ function aggregateAccountSignals(steamId64: string, rows: AccountSignalsV2[]): A
       tradeKills: sum(rows, (row) => row.trade.tradeKills),
       tradedDeaths: sum(rows, (row) => row.trade.tradedDeaths),
       deaths: sum(rows, (row) => row.trade.deaths),
-      tradedOpeningDeaths: sumNullable(rows.map((row) => row.trade.tradedOpeningDeaths))
+      tradedOpeningDeaths: sumNullable(rows.map((row) => row.trade.tradedOpeningDeaths)),
+      strategicIsolationDeaths: sumNullable(rows.map((row) => row.trade.strategicIsolationDeaths))
+    },
+    mapControl: {
+      uniqueStrategicControlSeconds: sumNullable(rows.map((row) => row.mapControl.uniqueStrategicControlSeconds)),
+      contestedFrontierControlSeconds: sumNullable(rows.map((row) => row.mapControl.contestedFrontierControlSeconds)),
+      routeDenialSeconds: sumNullable(rows.map((row) => row.mapControl.routeDenialSeconds)),
+      teammateAdvanceUnits: sumNullable(rows.map((row) => row.mapControl.teammateAdvanceUnits)),
+      firstControlEvents: sumNullable(rows.map((row) => row.mapControl.firstControlEvents))
     },
     clutch: {
       vsOne: sumSplit(rows, (row) => row.clutch.vsOne),
@@ -228,8 +331,13 @@ function aggregateAccountSignals(steamId64: string, rows: AccountSignalsV2[]): A
     },
     utility: {
       flashAssists: sum(rows, (row) => row.utility.flashAssists),
-      enemyFlashDurationSeconds: sum(rows, (row) => row.utility.enemyFlashDurationSeconds),
-      teamFlashDurationSeconds: sumNullable(rows.map((row) => row.utility.teamFlashDurationSeconds)),
+      effectiveEnemyFlashSeconds: sumNullable(rows.map((row) => row.utility.effectiveEnemyFlashSeconds)),
+      teamFlashSuppressionSeconds: sumNullable(rows.map((row) => row.utility.teamFlashSuppressionSeconds)),
+      smokeProtectedCrossings: sumNullable(rows.map((row) => row.utility.smokeProtectedCrossings)),
+      smokeSightlineDenialSeconds: sumNullable(rows.map((row) => row.utility.smokeSightlineDenialSeconds)),
+      smokeIsolationSeconds: sumNullable(rows.map((row) => row.utility.smokeIsolationSeconds)),
+      incendiaryPathDelayUnits: sumNullable(rows.map((row) => row.utility.incendiaryPathDelayUnits)),
+      incendiaryDisplacementEvents: sumNullable(rows.map((row) => row.utility.incendiaryDisplacementEvents)),
       utilityDamage: sum(rows, (row) => row.utility.utilityDamage)
     }
   };
@@ -333,15 +441,48 @@ function aggregateRRIndicators(steamId64: string, rows: RRIndicators[]): RRIndic
   };
 }
 
-// 账户平衡的数学（标准化 + 残差化）已迁入 rival-rating 的 computeCohortAccountsRR（公式归属）。
-// 本层只负责把 std(rrV1) 作为 targetStd 传进去，对齐 v2 与 HLTV 逆向的量纲。
-function stdev(xs: number[]): number {
-  if (xs.length === 0) return 0;
-  const m = sum(xs, (x) => x) / xs.length;
-  return Math.sqrt(sum(xs, (x) => (x - m) ** 2) / xs.length);
+function aggregateWeaponHighlights(
+  steamId64: string,
+  rows: PlayerWeaponHighlightFacts[]
+): PlayerWeaponHighlightFacts {
+  const weapons = new Map<string, PlayerWeaponHighlightFacts["weapons"][number]>();
+  for (const row of rows) {
+    for (const weapon of row.weapons) {
+      const current = weapons.get(weapon.weapon) ?? {
+        weapon: weapon.weapon,
+        kills: 0,
+        headshotKills: 0,
+        tradeKills: 0,
+        noScopeKills: 0,
+        throughSmokeKills: 0,
+        wallbangKills: 0,
+        penetratedObjects: 0
+      };
+      current.kills += weapon.kills;
+      current.headshotKills += weapon.headshotKills;
+      current.tradeKills += weapon.tradeKills;
+      current.noScopeKills += weapon.noScopeKills;
+      current.throughSmokeKills += weapon.throughSmokeKills;
+      current.wallbangKills += weapon.wallbangKills;
+      current.penetratedObjects += weapon.penetratedObjects;
+      weapons.set(weapon.weapon, current);
+    }
+  }
+  return {
+    steamId64,
+    totalKills: sum(rows, (row) => row.totalKills),
+    weapons: [...weapons.values()]
+      .sort((a, b) => b.kills - a.kills || a.weapon.localeCompare(b.weapon)),
+    highlights: {
+      wallbangKills: sumNullable(rows.map((row) => row.highlights.wallbangKills)),
+      noScopeKills: sumNullable(rows.map((row) => row.highlights.noScopeKills)),
+      throughSmokeKills: sumNullable(rows.map((row) => row.highlights.throughSmokeKills)),
+      collateralKills: sumNullable(rows.map((row) => row.highlights.collateralKills))
+    }
+  };
 }
 
-function accountContextStatus(rows: AccountSignalsV2[]): { buyDelta: AccountContextAvailability; manState: AccountContextAvailability } {
+function accountContextStatus(rows: RRSignals[]): { buyDelta: AccountContextAvailability; manState: AccountContextAvailability } {
   return {
     buyDelta: availability(rows.map((row) => row.combat.killsByBuyDelta != null)),
     manState: availability(rows.map((row) => row.combat.killsByManState != null))
@@ -367,7 +508,7 @@ function availabilityScore(value: AccountContextAvailability): number {
   return 0;
 }
 
-function sumBuyDelta(values: AccountSignalsV2["combat"]["killsByBuyDelta"][]): AccountSignalsV2["combat"]["killsByBuyDelta"] {
+function sumBuyDelta(values: RRSignals["combat"]["killsByBuyDelta"][]): RRSignals["combat"]["killsByBuyDelta"] {
   const present = values.filter((value): value is NonNullable<typeof value> => value != null);
   if (present.length === 0) return null;
   return {
@@ -377,7 +518,7 @@ function sumBuyDelta(values: AccountSignalsV2["combat"]["killsByBuyDelta"][]): A
   };
 }
 
-function sumManState(values: AccountSignalsV2["combat"]["killsByManState"][]): AccountSignalsV2["combat"]["killsByManState"] {
+function sumManState(values: RRSignals["combat"]["killsByManState"][]): RRSignals["combat"]["killsByManState"] {
   const present = values.filter((value): value is NonNullable<typeof value> => value != null);
   if (present.length === 0) return null;
   return {