@cs2dak/core 1.0.0 → 2.0.0

package/src/scoreboard.ts

@@ -1,7 +1,7 @@
 import {
   computeRR,
   computePrism,
-  rrWeightsV1,
+  hltv2BaselineWeightsV1,
   prismWeightsV1,
   rrToPercentile,
   type RRResult,
@@ -10,17 +10,19 @@ import {
   type PrismComputeInput
 } from "@rivalhub/rival-rating";
 import type {
-  AccountSignalsV2,
   DemoPackage,
   PlayerIndicatorRow,
   PlayerRoundFact,
   PlayerScoreboardRow,
   RRIndicators
 } from "@cs2dak/contract";
-import type { RRResultV2 } from "@rivalhub/rival-rating";
+import type { RRSignals } from "@rivalhub/rival-rating";
+import type { AccountRatingResult } from "./signals.js";
 import { normalizeDemoPackage } from "./normalize.js";
-import { round, firstKillMap, clutchSplit, isUtilityWeapon, killWeaponName } from "./utils.js";
+import { activeDamages, round, firstKillMap, clutchSplit, killWeaponName } from "./utils.js";
+import { createResolverFromPackage } from "./resolve.js";
 import { fieldAvailability, fieldConfidence } from "./qa.js";
+import { buildPlayerRoundUtilityFacts } from "./utility-facts.js";
 
 export function deriveRRIndicators(input: unknown): RRIndicators[] {
   const pkg = normalizeDemoPackage(input);
@@ -28,22 +30,32 @@ export function deriveRRIndicators(input: unknown): RRIndicators[] {
 }
 
 export function buildPlayerRoundFacts(pkg: DemoPackage): PlayerRoundFact[] {
+  const resolver = createResolverFromPackage(pkg);
   const firstKillByRound = firstKillMap(pkg);
+  const damageRows = activeDamages(pkg);
+  const utilityFacts = new Map(buildPlayerRoundUtilityFacts(pkg).map((fact) => [`${fact.roundNumber}:${fact.steamId64}`, fact]));
 
   return pkg.rounds.flatMap((roundRow) =>
-    pkg.players.map((player) => {
-      const kills = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.killerSteamId64 === player.steamId64);
-      const deaths = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.victimSteamId64 === player.steamId64);
-      const assists = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.assisterSteamId64 === player.steamId64);
-      const flashAssists = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.flashAssisterSteamId64 === player.steamId64);
-      const damageRows = pkg.damages.filter((row) => row.roundNumber === roundRow.roundNumber && row.attackerSteamId64 === player.steamId64 && row.victimTeamKey !== player.teamKey);
-      const economy = pkg.playerEconomies.find((row) => row.roundNumber === roundRow.roundNumber && row.steamId64 === player.steamId64);
+    pkg.players.map((player, playerIdx) => {
+      const kills = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.killerIndex === playerIdx);
+      const deaths = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.victimIndex === playerIdx);
+      const assists = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.assisterIndex === playerIdx);
+      // Keep the existing PlayerRoundFact assist/KAST semantics (the
+      // flashAssists field itself is supplied by the shared utility helper).
+      const flashAssistRows = pkg.kills.filter((kill) => kill.roundNumber === roundRow.roundNumber && kill.flashAssisterIndex === playerIdx);
+      const utility = utilityFacts.get(`${roundRow.roundNumber}:${player.steamId64}`)!;
+      const playerDamageRows = damageRows.filter((row) =>
+        row.roundNumber === roundRow.roundNumber &&
+        row.attackerIndex === playerIdx &&
+        resolver.byIndexOrNull(row.victimIndex)?.teamKey !== player.teamKey
+      );
+      const economy = pkg.playerEconomies.find((row) => row.roundNumber === roundRow.roundNumber && row.playerIndex === playerIdx);
       const side = player.teamKey === "teamA" ? roundRow.teamASide : roundRow.teamBSide;
       const firstKill = firstKillByRound.get(roundRow.roundNumber);
       const kastTags = new Set<PlayerRoundFact["kastTags"][number]>();
 
       if (kills.length > 0) kastTags.add("kill");
-      if (assists.length > 0 || flashAssists.length > 0) kastTags.add("assist");
+      if (assists.length > 0 || flashAssistRows.length > 0) kastTags.add("assist");
       if (deaths.length === 0) kastTags.add("survive");
       if (deaths.some((death) => death.tradeDeath)) kastTags.add("trade");
 
@@ -56,13 +68,13 @@ export function buildPlayerRoundFacts(pkg: DemoPackage): PlayerRoundFact[] {
         survived: deaths.length === 0,
         kills: kills.length,
         deaths: deaths.length,
-        assists: assists.length + flashAssists.length,
-        damage: damageRows.reduce((sum, row) => sum + row.healthDamage, 0),
-        utilityDamage: damageRows.filter((row) => isUtilityWeapon(row.weapon)).reduce((sum, row) => sum + row.healthDamage, 0),
-        flashAssists: flashAssists.length + kills.filter((kill) => kill.flashAssist).length,
+        assists: assists.length + flashAssistRows.length,
+        damage: playerDamageRows.reduce((sum, row) => sum + row.healthDamage, 0),
+        utilityDamage: utility.utilityDamage,
+        flashAssists: utility.flashAssists,
         tradeKills: kills.filter((kill) => kill.tradeKill).length,
         tradedDeaths: deaths.filter((death) => death.tradeDeath).length,
-        openingDuel: firstKill?.killerSteamId64 === player.steamId64 ? "won" : firstKill?.victimSteamId64 === player.steamId64 ? "lost" : "none",
+        openingDuel: firstKill?.killerIndex === playerIdx ? "won" : firstKill?.victimIndex === playerIdx ? "lost" : "none",
         kastTags: [...kastTags],
         equipmentValue: economy?.equipmentValue ?? null,
         economyType: economy?.type ?? null
@@ -72,14 +84,30 @@ export function buildPlayerRoundFacts(pkg: DemoPackage): PlayerRoundFact[] {
 }
 
 export function buildPlayerIndicators(pkg: DemoPackage, facts: PlayerRoundFact[]): PlayerIndicatorRow[] {
-  const indicators = pkg.players.map((player) => {
-    const stats = pkg.playerStats.find((row) => row.steamId64 === player.steamId64);
+  const statsMap = new Map(pkg.playerStats.map((row) => [row.playerIndex, row]));
+  const utilityTotals = new Map<string, {
+    utilityDamage: number;
+    flashAssists: number;
+    enemyBlindSeconds: number;
+    teamBlindSeconds: number;
+  }>();
+  for (const fact of buildPlayerRoundUtilityFacts(pkg)) {
+    const total = utilityTotals.get(fact.steamId64) ?? { utilityDamage: 0, flashAssists: 0, enemyBlindSeconds: 0, teamBlindSeconds: 0 };
+    total.utilityDamage += fact.utilityDamage;
+    total.flashAssists += fact.flashAssists;
+    total.enemyBlindSeconds += fact.enemyBlindSeconds;
+    total.teamBlindSeconds += fact.teamBlindSeconds;
+    utilityTotals.set(fact.steamId64, total);
+  }
+
+  const indicators = pkg.players.map((player, playerIdx) => {
+    const stats = statsMap.get(playerIdx);
     const playerFacts = facts.filter((fact) => fact.steamId64 === player.steamId64);
-    const playerKills = pkg.kills.filter((kill) => kill.killerSteamId64 === player.steamId64);
-    const playerDeaths = pkg.kills.filter((kill) => kill.victimSteamId64 === player.steamId64);
-    const playerEconomies = pkg.playerEconomies.filter((row) => row.steamId64 === player.steamId64);
-    const playerClutches = pkg.clutches.filter((row) => row.clutcherSteamId64 === player.steamId64);
-    const playerBlinds = pkg.blinds.filter((row) => row.flasherSteamId64 === player.steamId64);
+    const playerKills = pkg.kills.filter((kill) => kill.killerIndex === playerIdx);
+    const playerDeaths = pkg.kills.filter((kill) => kill.victimIndex === playerIdx);
+    const playerEconomies = pkg.playerEconomies.filter((row) => row.playerIndex === playerIdx);
+    const playerClutches = pkg.clutches.filter((row) => row.clutcherIndex === playerIdx);
+    const utility = utilityTotals.get(player.steamId64) ?? { utilityDamage: 0, flashAssists: 0, enemyBlindSeconds: 0, teamBlindSeconds: 0 };
     const totalRounds = Math.max(playerFacts.length, 1);
     const killsByRound = new Map<number, number>();
     for (const kill of playerKills) {
@@ -91,15 +119,11 @@ export function buildPlayerIndicators(pkg: DemoPackage, facts: PlayerRoundFact[]
     const openingDuels = firstKillCount + firstDeathCount;
     const awpKills = playerKills.filter((kill) => killWeaponName(kill) === "awp").length;
     const sniperKills = playerKills.filter((kill) => ["awp", "ssg08", "scout"].includes(killWeaponName(kill))).length;
-    const utilityDamage = stats?.utilityDamage ?? playerFacts.reduce((sum, fact) => sum + fact.utilityDamage, 0);
-    const flashAssistCount = stats?.flashAssistCount ?? playerFacts.reduce((sum, fact) => sum + fact.flashAssists, 0);
-    const enemyFlashDurationSeconds = stats?.enemyFlashDurationSeconds ?? playerBlinds
-      .filter((blind) => blind.flashedTeamKey && blind.flashedTeamKey !== player.teamKey)
-      .reduce((sum, blind) => sum + blind.durationSeconds, 0);
-    const teamFlashDurationSeconds = stats?.teamFlashDurationSeconds ?? playerBlinds
-      .filter((blind) => blind.flashedTeamKey === player.teamKey && blind.flashedSteamId64 !== player.steamId64)
-      .reduce((sum, blind) => sum + blind.durationSeconds, 0);
-    const grenadeCount = pkg.grenades.filter((grenade) => grenade.throwerSteamId64 === player.steamId64).length;
+    const utilityDamage = stats?.utilityDamage ?? utility.utilityDamage;
+    const flashAssistCount = stats?.flashAssistCount ?? utility.flashAssists;
+    const enemyFlashDurationSeconds = stats?.enemyFlashDurationSeconds ?? utility.enemyBlindSeconds;
+    const teamFlashDurationSeconds = stats?.teamFlashDurationSeconds ?? utility.teamBlindSeconds;
+    const grenadeCount = pkg.grenades.filter((grenade) => grenade.throwerIndex === playerIdx).length;
     const deaths = stats?.deaths ?? playerDeaths.length;
     const kills = stats?.kills ?? playerKills.length;
     const assists = stats?.assists ?? playerFacts.reduce((sum, fact) => sum + fact.assists, 0);
@@ -185,7 +209,7 @@ export function buildPlayerIndicators(pkg: DemoPackage, facts: PlayerRoundFact[]
     } satisfies RRIndicators;
   });
 
-  const rrWeights = rrWeightsV1 as unknown as RRWeights;
+  const rrWeights = hltv2BaselineWeightsV1 as unknown as RRWeights;
   const prismWeights = prismWeightsV1 as unknown as PrismWeights;
   const rrResults = indicators.map((indicator) => computeRR(indicator, rrWeights));
   const rrScores = rrResults.map((result) => result.rr);
@@ -213,22 +237,27 @@ export function buildPlayerIndicators(pkg: DemoPackage, facts: PlayerRoundFact[]
 export function buildScoreboard(
   pkg: DemoPackage,
   rows: PlayerIndicatorRow[],
-  accountRatings: Array<{ signals: AccountSignalsV2; rr: RRResultV2 }>
+  accountRatings: Array<{ signals: RRSignals; rr: AccountRatingResult }>
 ): PlayerScoreboardRow[] {
+  const resolver = createResolverFromPackage(pkg);
   const accountBySteamId = new Map(accountRatings.map((row) => [row.signals.steamId64, row]));
-  const statsBySteamId = new Map(pkg.playerStats.map((row) => [row.steamId64, row]));
+  const statsMap = new Map(pkg.playerStats.map((row) => [row.playerIndex, row]));
   const availability = fieldAvailability(pkg);
   const confidence = fieldConfidence(availability);
   return rows.map((row) => {
     const account = accountBySteamId.get(row.steamId64);
     const accountRr = account?.rr;
     const combatSignals = account?.signals.combat;
-    const stats = statsBySteamId.get(row.steamId64);
-    const playerKills = pkg.kills.filter((kill) => kill.killerSteamId64 === row.steamId64);
+    const playerIdx = resolver.indexOfSteamId(row.steamId64);
+    const stats = playerIdx != null ? statsMap.get(playerIdx) : undefined;
+    const playerKills = playerIdx != null
+      ? pkg.kills.filter((kill) => kill.killerIndex === playerIdx)
+      : [];
     return {
       steamId64: row.steamId64,
       name: row.name,
       teamKey: row.teamKey,
+      indicators: row.indicators,
       kills: row.indicators.kills,
       deaths: row.indicators.deaths,
       assists: row.indicators.assists,
@@ -258,6 +287,7 @@ export function buildScoreboard(
       accountBreakdown: {
         combat: round(accountRr?.accounts.combat ?? 0, 4),
         trade: round(accountRr?.accounts.trade ?? 0, 4),
+        mapControl: round(accountRr?.accounts.mapControl ?? 0, 4),
         clutch: round(accountRr?.accounts.clutch ?? 0, 4),
         objective: round(accountRr?.accounts.objective ?? 0, 4),
         utility: round(accountRr?.accounts.utility ?? 0, 4)

package/src/signals.ts

@@ -1,11 +1,16 @@
 import {
-  computeLeagueMeanV2,
-  computeValueAccountsRR,
-  rrValueAccountsV2Lite
+  computeFrozenProBaselineRR,
+  computeRRSixAccounts,
+  rrSixAccountProBaselineV0,
+  rrSixAccountWeightsV1
 } from "@rivalhub/rival-rating";
-import type { AccountSignalsV2, DemoPackage, ValueAccountsWeights } from "@cs2dak/contract";
-import type { RRResultV2 } from "@rivalhub/rival-rating";
+import type { DemoPackage, RRSignals, RRSixAccountWeights } from "@cs2dak/contract";
+import type { CohortAccountResult, ProBaselineConfig, RRSixAccountResult } from "@rivalhub/rival-rating";
 import { normalizeDemoPackage } from "./normalize.js";
+import { loadSpatialAssets } from "./spatial/annotate.js";
+import { buildOfficialMapControl } from "./spatial/mapcontrol.js";
+import { createResolverFromPackage, type PlayerResolver } from "./resolve.js";
+import { buildPlayerRoundUtilityFacts } from "./utility-facts.js";
 import {
   type BuyDeltaBuckets,
   type ManStateBuckets,
@@ -15,7 +20,7 @@ import {
   getOrInit,
   zeroBuyDelta,
   zeroManState,
-  clutchSplitV2,
+  clutchSplit,
   sumDamageForPlayer,
   openingKillsForPlayer,
   openingDeathsForPlayer,
@@ -24,25 +29,31 @@ import {
   firstKillMap
 } from "./utils.js";
 
-export function deriveAccountSignalsV2(input: unknown): AccountSignalsV2[] {
+export type AccountRatingResult = CohortAccountResult & Pick<RRSixAccountResult, "combatContextFactor" | "weightsVersion" | "model">;
+
+export function deriveRRSignals(input: unknown): RRSignals[] {
   const pkg = normalizeDemoPackage(input);
-  const statsBySteamId = new Map(pkg.playerStats.map((row) => [row.steamId64, row]));
-  const killsByBuyDelta = buildKillsByBuyDelta(pkg);
-  const killsByManState = buildKillsByManState(pkg);
-  const tradedOpeningDeaths = buildTradedOpeningDeaths(pkg);
-  const objective = buildObjectiveSignals(pkg);
-  const utility = buildUtilitySignals(pkg);
-
-  // context 分桶的"数据源是否存在"。源缺失 → 发 null（模型降级为乘子 1.0），
-  // 而非零桶——零桶语义是"源在、但该选手无相关样本"。区分二者是 v2 可信展示的前提。
+  const resolver = createResolverFromPackage(pkg);
+  const statsMap = new Map(pkg.playerStats.map((row) => [row.playerIndex, row]));
+  const killsByBuyDelta = buildKillsByBuyDelta(pkg, resolver);
+  const killsByManState = buildKillsByManState(pkg, resolver);
+  const tradedOpeningDeaths = buildTradedOpeningDeaths(pkg, resolver);
+  const objective = buildObjectiveSignals(pkg, resolver);
+  const utility = buildUtilitySignals(pkg, statsMap);
+
   const buyDeltaAvailable = pkg.playerEconomies.length > 0;
   const manStateAvailable = pkg.rounds.length > 0;
 
-  return pkg.players.map((player) => {
-    const stats = statsBySteamId.get(player.steamId64);
-    const playerKills = pkg.kills.filter((kill) => kill.killerSteamId64 === player.steamId64);
-    const playerDeaths = pkg.kills.filter((kill) => kill.victimSteamId64 === player.steamId64);
-    const playerClutches = pkg.clutches.filter((row) => row.clutcherSteamId64 === player.steamId64);
+  const spatialAssets = loadSpatialAssets(pkg.match?.mapName ?? pkg.manifest?.mapName ?? "");
+  const officialMapControl = buildOfficialMapControl(pkg, spatialAssets);
+  // replay-based spatial re-impl (step 3)
+  const spatialObservable = spatialAssets.routes != null && (pkg.replay?.rounds?.length ?? 0) > 0;
+
+  return pkg.players.map((player, playerIdx) => {
+    const stats = statsMap.get(playerIdx);
+    const playerKills = pkg.kills.filter((kill) => kill.killerIndex === playerIdx);
+    const playerDeaths = pkg.kills.filter((kill) => kill.victimIndex === playerIdx);
+    const playerClutches = pkg.clutches.filter((row) => row.clutcherIndex === playerIdx);
     const rounds = Math.max(stats?.rounds ?? pkg.rounds.length, 0);
 
     return {
@@ -53,9 +64,9 @@ export function deriveAccountSignalsV2(input: unknown): AccountSignalsV2[] {
         kills: stats?.kills ?? playerKills.length,
         deaths: stats?.deaths ?? playerDeaths.length,
         assists: stats?.assists ?? 0,
-        effectiveDamage: stats?.damageHealth ?? sumDamageForPlayer(pkg, player.steamId64),
-        openingKills: stats?.firstKillCount ?? openingKillsForPlayer(pkg, player.steamId64),
-        openingDeaths: stats?.firstDeathCount ?? openingDeathsForPlayer(pkg, player.steamId64),
+        effectiveDamage: stats?.damageHealth ?? sumDamageForPlayer(pkg, playerIdx),
+        openingKills: stats?.firstKillCount ?? openingKillsForPlayer(pkg, playerIdx),
+        openingDeaths: stats?.firstDeathCount ?? openingDeathsForPlayer(pkg, playerIdx),
         multiKills: {
           two: stats?.twoKillCount ?? multiKillRounds(playerKills, 2),
           three: stats?.threeKillCount ?? multiKillRounds(playerKills, 3),
@@ -71,55 +82,78 @@ export function deriveAccountSignalsV2(input: unknown): AccountSignalsV2[] {
         tradeKills: stats?.tradeKillCount ?? playerKills.filter((kill) => kill.tradeKill).length,
         tradedDeaths: stats?.tradeDeathCount ?? playerDeaths.filter((kill) => kill.tradeDeath).length,
         deaths: stats?.deaths ?? playerDeaths.length,
-        tradedOpeningDeaths: tradedOpeningDeaths.get(player.steamId64) ?? 0
+        tradedOpeningDeaths: tradedOpeningDeaths.get(player.steamId64) ?? 0,
+        strategicIsolationDeaths: spatialObservable
+          ? (officialMapControl.get(player.steamId64)?.strategicIsolationDeaths ?? 0)
+          : null
+      },
+      mapControl: {
+        uniqueStrategicControlSeconds: null,
+        contestedFrontierControlSeconds: null,
+        routeDenialSeconds: null,
+        teammateAdvanceUnits: null,
+        firstControlEvents: null
       },
       clutch: {
-        vsOne: clutchSplitV2(stats?.vsOneCount, stats?.vsOneWonCount, playerClutches, 1),
-        vsTwo: clutchSplitV2(stats?.vsTwoCount, stats?.vsTwoWonCount, playerClutches, 2),
-        vsThree: clutchSplitV2(stats?.vsThreeCount, stats?.vsThreeWonCount, playerClutches, 3),
-        vsFour: clutchSplitV2(stats?.vsFourCount, stats?.vsFourWonCount, playerClutches, 4),
-        vsFive: clutchSplitV2(stats?.vsFiveCount, stats?.vsFiveWonCount, playerClutches, 5)
+        vsOne: clutchSplit(stats?.vsOneCount, stats?.vsOneWonCount, playerClutches, 1),
+        vsTwo: clutchSplit(stats?.vsTwoCount, stats?.vsTwoWonCount, playerClutches, 2),
+        vsThree: clutchSplit(stats?.vsThreeCount, stats?.vsThreeWonCount, playerClutches, 3),
+        vsFour: clutchSplit(stats?.vsFourCount, stats?.vsFourWonCount, playerClutches, 4),
+        vsFive: clutchSplit(stats?.vsFiveCount, stats?.vsFiveWonCount, playerClutches, 5)
       },
       objective: objective.get(player.steamId64) ?? { plants: 0, defuses: 0, plantsConverted: 0 },
-      utility: utility.get(player.steamId64) ?? {
-        flashAssists: stats?.flashAssistCount ?? 0,
-        enemyFlashDurationSeconds: stats?.enemyFlashDurationSeconds ?? 0,
-        teamFlashDurationSeconds: stats?.teamFlashDurationSeconds ?? 0,
-        utilityDamage: stats?.utilityDamage ?? 0
+      utility: {
+        ...(utility.get(player.steamId64) ?? {
+          flashAssists: stats?.flashAssistCount ?? 0,
+          effectiveEnemyFlashSeconds: stats?.enemyFlashDurationSeconds ?? 0,
+          teamFlashSuppressionSeconds: stats?.teamFlashDurationSeconds ?? 0,
+          smokeProtectedCrossings: null,
+          smokeSightlineDenialSeconds: null,
+          smokeIsolationSeconds: null,
+          incendiaryPathDelayUnits: null,
+          incendiaryDisplacementEvents: null,
+          utilityDamage: stats?.utilityDamage ?? 0
+        })
       }
-    } satisfies AccountSignalsV2;
+    } satisfies RRSignals;
   });
 }
 
-export function computeAccountRatingsV2(input: unknown): Array<{ signals: AccountSignalsV2; rr: RRResultV2 }> {
-  const weights = rrValueAccountsV2Lite as unknown as ValueAccountsWeights;
-  const rated = deriveAccountSignalsV2(input).map((signals) => ({
-    signals,
-    rr: computeValueAccountsRR(signals, weights)
-  }));
+export function computeAccountRatingsV2(input: unknown): Array<{ signals: RRSignals; rr: AccountRatingResult }> {
+  const weights = rrSixAccountWeightsV1 as unknown as RRSixAccountWeights;
+  const baseline = rrSixAccountProBaselineV0 as unknown as ProBaselineConfig;
+  const signals = deriveRRSignals(input);
+  const rawBySteamId = new Map(signals.map((row) => [row.steamId64, computeRRSixAccounts(row, weights)]));
+  const balanced = signals.map((signal) => computeFrozenProBaselineRR(signal, weights, baseline));
 
-  // 联赛锚定（weights.anchor.mode === "league_mean"）：整体乘 (1.0 / mean)，
-  // 使 1.00 = 本场均值。本层一次只处理单场，故"联赛均值"= 本场均值（per-match）；
-  // 真正的赛季级锚定属于上游跨场聚合层，详见 docs/design/rr-v2-lite.md。
-  const mean = computeLeagueMeanV2(rated.map((row) => row.rr));
-  const factor = mean > 0 ? 1.0 / mean : 1.0;
-  return rated.map((row) => ({
-    signals: row.signals,
-    rr: { ...row.rr, rr: row.rr.rr * factor }
-  }));
+  return balanced.map((rr, index) => {
+    const signal = signals[index]!;
+    const raw = rawBySteamId.get(signal.steamId64);
+    return {
+      signals: signal,
+      rr: {
+        ...rr,
+        combatContextFactor: raw?.combatContextFactor ?? 1,
+        weightsVersion: raw?.weightsVersion ?? weights.version,
+        model: raw?.model ?? "rr-six-accounts"
+      }
+    };
+  });
 }
 
-function buildKillsByBuyDelta(pkg: DemoPackage): Map<string, BuyDeltaBuckets> {
+function buildKillsByBuyDelta(pkg: DemoPackage, resolver: PlayerResolver): Map<string, BuyDeltaBuckets> {
   const out = new Map<string, BuyDeltaBuckets>();
-  const economyByPlayerRound = new Map(pkg.playerEconomies.map((row) => [`${row.roundNumber}:${row.steamId64}`, row]));
+  const economyByPlayerRound = new Map(pkg.playerEconomies.map((row) => [`${row.roundNumber}:${row.playerIndex}`, row]));
 
   for (const kill of pkg.kills) {
-    if (!kill.killerSteamId64) continue;
-    const killerEconomy = economyByPlayerRound.get(`${kill.roundNumber}:${kill.killerSteamId64}`);
-    const victimEconomy = economyByPlayerRound.get(`${kill.roundNumber}:${kill.victimSteamId64}`);
+    if (kill.killerIndex === null) continue;
+    const killerEconomy = economyByPlayerRound.get(`${kill.roundNumber}:${kill.killerIndex}`);
+    const victimEconomy = economyByPlayerRound.get(`${kill.roundNumber}:${kill.victimIndex}`);
     if (!killerEconomy || !victimEconomy) continue;
 
-    const buckets = getOrInit(out, kill.killerSteamId64, zeroBuyDelta);
+    const killerSteamId = resolver.steamIdOf(kill.killerIndex);
+    if (!killerSteamId) continue;
+    const buckets = getOrInit(out, killerSteamId, zeroBuyDelta);
     const delta = killerEconomy.equipmentValue - victimEconomy.equipmentValue;
     if (delta <= -BUY_DELTA_EVEN_THRESHOLD) {
       buckets.disadvantage += 1;
@@ -133,63 +167,68 @@ function buildKillsByBuyDelta(pkg: DemoPackage): Map<string, BuyDeltaBuckets> {
   return out;
 }
 
-function buildKillsByManState(pkg: DemoPackage): Map<string, ManStateBuckets> {
+function buildKillsByManState(pkg: DemoPackage, resolver: PlayerResolver): Map<string, ManStateBuckets> {
   const out = new Map<string, ManStateBuckets>();
-  const playersByTeam = {
-    teamA: pkg.players.filter((player) => player.teamKey === "teamA").map((player) => player.steamId64),
-    teamB: pkg.players.filter((player) => player.teamKey === "teamB").map((player) => player.steamId64)
-  };
+  const teamAIndices = new Set(pkg.players.flatMap((p, i) => p.teamKey === "teamA" ? [i] : []));
+  const teamBIndices = new Set(pkg.players.flatMap((p, i) => p.teamKey === "teamB" ? [i] : []));
 
   for (const roundRow of pkg.rounds) {
-    const alive = {
-      teamA: new Set(playersByTeam.teamA),
-      teamB: new Set(playersByTeam.teamB)
-    };
+    const aliveA = new Set(teamAIndices);
+    const aliveB = new Set(teamBIndices);
     const roundKills = pkg.kills
       .filter((kill) => kill.roundNumber === roundRow.roundNumber)
       .sort((a, b) => a.tick - b.tick);
 
     for (const kill of roundKills) {
-      if (kill.killerSteamId64 && kill.killerTeamKey && kill.killerTeamKey !== kill.victimTeamKey) {
-        const buckets = getOrInit(out, kill.killerSteamId64, zeroManState);
-        const killerAlive = alive[kill.killerTeamKey].size;
-        const victimAlive = alive[kill.victimTeamKey].size;
-        const diff = killerAlive - victimAlive;
-        if (diff < 0) {
-          buckets.manDown += 1;
-        } else if (diff > 0) {
-          buckets.manUp += 1;
-        } else {
-          buckets.even += 1;
-        }
+      if (kill.killerIndex === null) continue;
+      const killerPlayer = resolver.byIndexOrNull(kill.killerIndex);
+      const victimPlayer = resolver.byIndexOrNull(kill.victimIndex);
+      if (!killerPlayer || !victimPlayer || killerPlayer.teamKey === victimPlayer.teamKey) continue;
+
+      const killerSteamId = killerPlayer.steamId64;
+      const buckets = getOrInit(out, killerSteamId, zeroManState);
+      const killerAlive = killerPlayer.teamKey === "teamA" ? aliveA.size : aliveB.size;
+      const victimAlive = victimPlayer.teamKey === "teamA" ? aliveA.size : aliveB.size;
+      const diff = killerAlive - victimAlive;
+      if (diff < 0) {
+        buckets.manDown += 1;
+      } else if (diff > 0) {
+        buckets.manUp += 1;
+      } else {
+        buckets.even += 1;
       }
-      alive[kill.victimTeamKey].delete(kill.victimSteamId64);
+
+      if (victimPlayer.teamKey === "teamA") aliveA.delete(kill.victimIndex);
+      else aliveB.delete(kill.victimIndex);
     }
   }
 
   return out;
 }
 
-function buildTradedOpeningDeaths(pkg: DemoPackage): Map<string, number> {
+function buildTradedOpeningDeaths(pkg: DemoPackage, resolver: PlayerResolver): Map<string, number> {
   const out = new Map<string, number>();
   for (const kill of firstKillMap(pkg).values()) {
     if (kill.tradeDeath) {
-      out.set(kill.victimSteamId64, (out.get(kill.victimSteamId64) ?? 0) + 1);
+      const victimSteamId = resolver.steamIdOf(kill.victimIndex);
+      if (victimSteamId) out.set(victimSteamId, (out.get(victimSteamId) ?? 0) + 1);
     }
   }
   return out;
 }
 
-function buildObjectiveSignals(pkg: DemoPackage): Map<string, ObjectiveBuckets> {
+function buildObjectiveSignals(pkg: DemoPackage, resolver: PlayerResolver): Map<string, ObjectiveBuckets> {
   const out = new Map<string, ObjectiveBuckets>();
   const roundWinner = new Map(pkg.rounds.map((round) => [round.roundNumber, round.winnerTeamKey]));
 
   for (const bomb of pkg.bombs) {
-    if (!bomb.actorSteamId64) continue;
-    const buckets = getOrInit(out, bomb.actorSteamId64, () => ({ plants: 0, defuses: 0, plantsConverted: 0 }));
+    if (bomb.actorIndex === null) continue;
+    const actorPlayer = resolver.byIndexOrNull(bomb.actorIndex);
+    if (!actorPlayer) continue;
+    const buckets = getOrInit(out, actorPlayer.steamId64, () => ({ plants: 0, defuses: 0, plantsConverted: 0 }));
     if (bomb.type === "planted") {
       buckets.plants += 1;
-      if (bomb.actorTeamKey && roundWinner.get(bomb.roundNumber) === bomb.actorTeamKey) {
+      if (roundWinner.get(bomb.roundNumber) === actorPlayer.teamKey) {
         buckets.plantsConverted = (buckets.plantsConverted ?? 0) + 1;
       }
     } else if (bomb.type === "defused") {
@@ -200,33 +239,31 @@ function buildObjectiveSignals(pkg: DemoPackage): Map<string, ObjectiveBuckets>
   return out;
 }
 
-function buildUtilitySignals(pkg: DemoPackage): Map<string, UtilityBuckets> {
-  const out = new Map<string, UtilityBuckets>();
-  const statsBySteamId = new Map(pkg.playerStats.map((row) => [row.steamId64, row]));
-
-  for (const player of pkg.players) {
-    const stats = statsBySteamId.get(player.steamId64);
-    out.set(player.steamId64, {
-      flashAssists: stats?.flashAssistCount ?? pkg.kills.filter((kill) => kill.flashAssisterSteamId64 === player.steamId64).length,
-      enemyFlashDurationSeconds: stats?.enemyFlashDurationSeconds ?? 0,
-      teamFlashDurationSeconds: stats?.teamFlashDurationSeconds ?? 0,
-      utilityDamage: stats?.utilityDamage ?? 0
-    });
+function buildUtilitySignals(pkg: DemoPackage, statsMap: Map<number, DemoPackage["playerStats"][number]>): Map<string, UtilityBuckets> {
+  const utilityFacts = buildPlayerRoundUtilityFacts(pkg);
+  const totals = new Map<string, { flashAssists: number; enemyBlindSeconds: number; teamBlindSeconds: number; utilityDamage: number }>();
+  for (const fact of utilityFacts) {
+    const total = totals.get(fact.steamId64) ?? { flashAssists: 0, enemyBlindSeconds: 0, teamBlindSeconds: 0, utilityDamage: 0 };
+    total.flashAssists += fact.flashAssists;
+    total.enemyBlindSeconds += fact.enemyBlindSeconds;
+    total.teamBlindSeconds += fact.teamBlindSeconds;
+    total.utilityDamage += fact.utilityDamage;
+    totals.set(fact.steamId64, total);
   }
 
-  for (const blind of pkg.blinds) {
-    const buckets = getOrInit(out, blind.flasherSteamId64, () => ({
-      flashAssists: 0,
-      enemyFlashDurationSeconds: 0,
-      teamFlashDurationSeconds: 0,
-      utilityDamage: 0
-    }));
-    if (blind.flasherTeamKey !== blind.flashedTeamKey) {
-      buckets.enemyFlashDurationSeconds = round(buckets.enemyFlashDurationSeconds + blind.durationSeconds, 3);
-    } else if (blind.flashedSteamId64 !== blind.flasherSteamId64) {
-      buckets.teamFlashDurationSeconds = round((buckets.teamFlashDurationSeconds ?? 0) + blind.durationSeconds, 3);
-    }
-  }
-
-  return out;
+  return new Map(pkg.players.map((player, playerIdx) => {
+    const stats = statsMap.get(playerIdx);
+    const fact = totals.get(player.steamId64) ?? { flashAssists: 0, enemyBlindSeconds: 0, teamBlindSeconds: 0, utilityDamage: 0 };
+    return [player.steamId64, {
+      flashAssists: stats?.flashAssistCount ?? fact.flashAssists,
+      effectiveEnemyFlashSeconds: stats?.enemyFlashDurationSeconds ?? round(fact.enemyBlindSeconds, 3),
+      teamFlashSuppressionSeconds: stats?.teamFlashDurationSeconds ?? round(fact.teamBlindSeconds, 3),
+      smokeProtectedCrossings: null,
+      smokeSightlineDenialSeconds: null,
+      smokeIsolationSeconds: null,
+      incendiaryPathDelayUnits: null,
+      incendiaryDisplacementEvents: null,
+      utilityDamage: stats?.utilityDamage ?? fact.utilityDamage
+    } satisfies UtilityBuckets];
+  }));
 }