@cs2dak/core 1.0.0 → 2.0.0

package/src/timeline.ts

@@ -1,39 +1,52 @@
 import type { DemoPackage, EconomyPoint, HeatmapPoint, TimelineEvent } from "@cs2dak/contract";
-import { round, clamp, formatClock, nameForSteamId, normalizeWeapon } from "./utils.js";
+import { round, clamp, formatClock, normalizeWeapon } from "./utils.js";
+import { createResolverFromPackage } from "./resolve.js";
 
 export function buildTimeline(pkg: DemoPackage): TimelineEvent[] {
-  const killEvents = pkg.kills.map<TimelineEvent>((kill, index) => ({
-    id: `kill-${index}`,
-    roundNumber: kill.roundNumber,
-    tick: kill.tick,
-    timeSeconds: tickToRoundSeconds(pkg, kill.roundNumber, kill.tick),
-    ...clockForTick(pkg, kill.roundNumber, kill.tick),
-    type: "kill",
-    label: `${nameForSteamId(pkg, kill.killerSteamId64) ?? "环境"} 击杀 ${nameForSteamId(pkg, kill.victimSteamId64)}`,
-    teamKey: kill.killerTeamKey
-  }));
+  const resolver = createResolverFromPackage(pkg);
 
-  const bombEvents = pkg.bombs.map<TimelineEvent>((bomb, index) => ({
-    id: `bomb-${index}`,
-    roundNumber: bomb.roundNumber,
-    tick: bomb.tick,
-    timeSeconds: tickToRoundSeconds(pkg, bomb.roundNumber, bomb.tick),
-    ...clockForTick(pkg, bomb.roundNumber, bomb.tick),
-    type: "bomb",
-    label: bombLabel(pkg, bomb),
-    teamKey: bomb.actorTeamKey
-  }));
+  const killEvents = pkg.kills.map<TimelineEvent>((kill, index) => {
+    const killer = resolver.byIndexOrNull(kill.killerIndex);
+    const victim = resolver.byIndex(kill.victimIndex);
+    return {
+      id: `kill-${index}`,
+      roundNumber: kill.roundNumber,
+      tick: kill.tick,
+      timeSeconds: tickToRoundSeconds(pkg, kill.roundNumber, kill.tick),
+      ...clockForTick(pkg, kill.roundNumber, kill.tick),
+      type: "kill",
+      label: `${killer?.name ?? "环境"} 击杀 ${victim.name}`,
+      teamKey: killer?.teamKey ?? null
+    };
+  });
 
-  const grenadeEvents = pkg.grenades.map<TimelineEvent>((grenade, index) => ({
-    id: `grenade-${index}`,
-    roundNumber: grenade.roundNumber,
-    tick: grenade.effectTick,
-    timeSeconds: tickToRoundSeconds(pkg, grenade.roundNumber, grenade.effectTick),
-    ...clockForTick(pkg, grenade.roundNumber, grenade.effectTick),
-    type: "grenade",
-    label: `${nameForSteamId(pkg, grenade.throwerSteamId64) ?? "未知选手"} 投掷${grenadeLabel(grenade.grenade)}`,
-    teamKey: grenade.throwerTeamKey
-  }));
+  const bombEvents = pkg.bombs.map<TimelineEvent>((bomb, index) => {
+    const actor = resolver.byIndexOrNull(bomb.actorIndex);
+    return {
+      id: `bomb-${index}`,
+      roundNumber: bomb.roundNumber,
+      tick: bomb.tick,
+      timeSeconds: tickToRoundSeconds(pkg, bomb.roundNumber, bomb.tick),
+      ...clockForTick(pkg, bomb.roundNumber, bomb.tick),
+      type: "bomb",
+      label: bombLabel(actor?.name, bomb),
+      teamKey: actor?.teamKey ?? null
+    };
+  });
+
+  const grenadeEvents = pkg.grenades.map<TimelineEvent>((grenade, index) => {
+    const thrower = resolver.byIndex(grenade.throwerIndex);
+    return {
+      id: `grenade-${index}`,
+      roundNumber: grenade.roundNumber,
+      tick: grenade.effectTick,
+      timeSeconds: tickToRoundSeconds(pkg, grenade.roundNumber, grenade.effectTick),
+      ...clockForTick(pkg, grenade.roundNumber, grenade.effectTick),
+      type: "grenade",
+      label: `${thrower.name} 投掷${grenadeLabel(grenade.grenade)}`,
+      teamKey: thrower.teamKey
+    };
+  });
 
   const roundEvents = pkg.rounds.map<TimelineEvent>((roundRow) => ({
     id: `round-end-${roundRow.roundNumber}`,
@@ -53,11 +66,12 @@ export function buildTimeline(pkg: DemoPackage): TimelineEvent[] {
 }
 
 export function buildEconomy(pkg: DemoPackage): EconomyPoint[] {
+  const resolver = createResolverFromPackage(pkg);
   return pkg.rounds.map((roundRow) => {
     const rows = pkg.playerEconomies.filter((row) => row.roundNumber === roundRow.roundNumber);
     const sumForTeam = (teamKey: "teamA" | "teamB") =>
       rows
-        .filter((row) => row.teamKey === teamKey)
+        .filter((row) => resolver.byIndexOrNull(row.playerIndex)?.teamKey === teamKey)
         .reduce((sum, row) => sum + row.equipmentValue, 0);
     const teamA = sumForTeam("teamA");
     const teamB = sumForTeam("teamB");
@@ -75,7 +89,7 @@ export function buildEconomy(pkg: DemoPackage): EconomyPoint[] {
 }
 
 export function buildHeatmap(pkg: DemoPackage): HeatmapPoint[] {
-  // Pre-index sides per round to derive CT/T for any teamKey lookup.
+  const resolver = createResolverFromPackage(pkg);
   const roundSides = new Map(
     pkg.rounds.map((r) => [r.roundNumber, { teamA: r.teamASide, teamB: r.teamBSide }])
   );
@@ -87,15 +101,19 @@ export function buildHeatmap(pkg: DemoPackage): HeatmapPoint[] {
   };
 
   const kills = pkg.kills.flatMap<HeatmapPoint>((kill) => {
+    const victimPlayer = resolver.byIndexOrNull(kill.victimIndex);
+    const killerPlayer = resolver.byIndexOrNull(kill.killerIndex);
+    const victimTeamKey = victimPlayer?.teamKey ?? null;
+    const killerTeamKey = killerPlayer?.teamKey ?? null;
     const out: HeatmapPoint[] = [
       {
         x: kill.victimPosition.x,
         y: kill.victimPosition.y,
         z: kill.victimPosition.z,
         roundNumber: kill.roundNumber,
-        teamKey: kill.victimTeamKey,
-        steamId64: kill.victimSteamId64,
-        side: sideFor(kill.victimTeamKey, kill.roundNumber),
+        teamKey: victimTeamKey,
+        steamId64: victimPlayer?.steamId64 ?? null,
+        side: sideFor(victimTeamKey, kill.roundNumber),
         kind: "death",
         grenadeType: null
       }
@@ -106,9 +124,9 @@ export function buildHeatmap(pkg: DemoPackage): HeatmapPoint[] {
         y: kill.killerPosition.y,
         z: kill.killerPosition.z,
         roundNumber: kill.roundNumber,
-        teamKey: kill.killerTeamKey,
-        steamId64: kill.killerSteamId64,
-        side: sideFor(kill.killerTeamKey, kill.roundNumber),
+        teamKey: killerTeamKey,
+        steamId64: killerPlayer?.steamId64 ?? null,
+        side: sideFor(killerTeamKey, kill.roundNumber),
         kind: "kill",
         grenadeType: null
       });
@@ -117,17 +135,20 @@ export function buildHeatmap(pkg: DemoPackage): HeatmapPoint[] {
   });
 
   const grenades = pkg.grenades
-    .map<HeatmapPoint>((grenade) => ({
-      x: grenade.effectPosition.x,
-      y: grenade.effectPosition.y,
-      z: grenade.effectPosition.z,
-      roundNumber: grenade.roundNumber,
-      teamKey: grenade.throwerTeamKey,
-      steamId64: grenade.throwerSteamId64,
-      side: sideFor(grenade.throwerTeamKey, grenade.roundNumber),
-      kind: "grenade",
-      grenadeType: grenade.grenade
-    }));
+    .map<HeatmapPoint>((grenade) => {
+      const thrower = resolver.byIndexOrNull(grenade.throwerIndex);
+      return {
+        x: grenade.effectPosition.x,
+        y: grenade.effectPosition.y,
+        z: grenade.effectPosition.z,
+        roundNumber: grenade.roundNumber,
+        teamKey: thrower?.teamKey ?? null,
+        steamId64: thrower?.steamId64 ?? null,
+        side: sideFor(thrower?.teamKey ?? null, grenade.roundNumber),
+        kind: "grenade",
+        grenadeType: grenade.grenade
+      };
+    });
 
   return [...kills, ...grenades].filter((point) => point.x !== 0 || point.y !== 0);
 }
@@ -166,8 +187,8 @@ function eventSortWeight(type: TimelineEvent["type"]): number {
   return 3;
 }
 
-function bombLabel(pkg: DemoPackage, bomb: DemoPackage["bombs"][number]): string {
-  const actor = nameForSteamId(pkg, bomb.actorSteamId64) ?? "未知选手";
+function bombLabel(actorName: string | undefined, bomb: DemoPackage["bombs"][number]): string {
+  const actor = actorName ?? "未知选手";
   const labels: Record<string, string> = {
     planted: "下包",
     defused: "拆包",

package/src/utility-facts.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { loadDemoPackageFromZip } from "./loader.js";
+import { buildPlayerRoundFacts } from "./scoreboard.js";
+import { buildPlayerRoundUtilityFacts } from "./utility-facts.js";
+
+const fixture = async () => loadDemoPackageFromZip(await readFile(fileURLToPath(
+  new URL("../../../fixtures/input/sample-2026-05-17_de_ancient_Team_Spirit_13-10_Team_Falcons.zip", import.meta.url)
+)));
+
+describe("buildPlayerRoundUtilityFacts", () => {
+  it("owns the per-round utility values consumed by PlayerRoundFact", async () => {
+    const pkg = await fixture();
+    const utilityFacts = buildPlayerRoundUtilityFacts(pkg);
+    const playerRounds = buildPlayerRoundFacts(pkg);
+
+    expect(utilityFacts).toHaveLength(pkg.rounds.length * pkg.players.length);
+    const byKey = new Map(utilityFacts.map((fact) => [`${fact.roundNumber}:${fact.steamId64}`, fact]));
+    for (const playerRound of playerRounds) {
+      const utility = byKey.get(`${playerRound.roundNumber}:${playerRound.steamId64}`);
+      expect(utility).toBeDefined();
+      expect(playerRound.utilityDamage).toBe(utility?.utilityDamage);
+      expect(playerRound.flashAssists).toBe(utility?.flashAssists);
+    }
+
+    for (const stats of pkg.playerStats) {
+      const steamId64 = pkg.players[stats.playerIndex]!.steamId64;
+      const totals = utilityFacts
+        .filter((fact) => fact.steamId64 === steamId64)
+        .reduce((sum, fact) => ({
+          enemyBlindSeconds: sum.enemyBlindSeconds + fact.enemyBlindSeconds,
+          teamBlindSeconds: sum.teamBlindSeconds + fact.teamBlindSeconds,
+          flashAssists: sum.flashAssists + fact.flashAssists,
+        }), { enemyBlindSeconds: 0, teamBlindSeconds: 0, flashAssists: 0 });
+      expect(totals.enemyBlindSeconds).toBeCloseTo(stats.enemyFlashDurationSeconds, 3);
+      expect(totals.teamBlindSeconds).toBeCloseTo(stats.teamFlashDurationSeconds, 3);
+      expect(totals.flashAssists).toBe(stats.flashAssistCount);
+    }
+  });
+
+  it("uses the same active round window as core damage facts", async () => {
+    const pkg = await fixture();
+    const firstRound = pkg.rounds[0]!;
+    const sourceDamage = pkg.damages[0]!;
+    const withFreezeDamage = {
+      ...pkg,
+      damages: [...pkg.damages, { ...sourceDamage, roundNumber: firstRound.roundNumber, tick: firstRound.freezeEndTick - 1 }],
+    };
+    const baseline = buildPlayerRoundUtilityFacts(pkg);
+    const actual = buildPlayerRoundUtilityFacts(withFreezeDamage);
+
+    expect(actual).toEqual(baseline);
+  });
+});

package/src/utility-facts.ts

@@ -0,0 +1,137 @@
+import type { DemoPackage } from "@cs2dak/contract";
+import { activeDamages, isUtilityWeapon, normalizeWeapon } from "./utils.js";
+
+/**
+ * 每位选手、每回合的低维道具 sufficient facts。
+ *
+ * 这是所有 DAK consumer（包括 Studio 与产品 adapter）对 flash / HE / fire /
+ * smoke / utility kill 的唯一事件归因口径；只读取已验证的 v3 DemoPackage，
+ * 不包含空间或逐事件流。
+ */
+export type PlayerRoundUtilityFact = {
+  roundNumber: number;
+  steamId64: string;
+  flashesThrown: number;
+  enemyBlindSeconds: number;
+  teamBlindSeconds: number;
+  /** Enemy blind person-events, matching playerStats/presentation semantics. */
+  enemyBlindVictims: number;
+  /** Flash-assist credits assigned to the flash assister, not the killer. */
+  flashAssists: number;
+  heThrows: number;
+  heDamage: number;
+  fireThrows: number;
+  fireDamage: number;
+  smokesThrown: number;
+  utilityKills: number;
+  utilityDamage: number;
+};
+
+type MutableUtilityFact = Omit<PlayerRoundUtilityFact, "roundNumber" | "steamId64">;
+
+function isFireWeapon(weapon: string): boolean {
+  return ["inferno", "molotov", "incgrenade", "incendiary"].includes(normalizeWeapon(weapon));
+}
+
+function emptyFact(): MutableUtilityFact {
+  return {
+    flashesThrown: 0,
+    enemyBlindSeconds: 0,
+    teamBlindSeconds: 0,
+    enemyBlindVictims: 0,
+    flashAssists: 0,
+    heThrows: 0,
+    heDamage: 0,
+    fireThrows: 0,
+    fireDamage: 0,
+    smokesThrown: 0,
+    utilityKills: 0,
+    utilityDamage: 0,
+  };
+}
+
+/** Returns one row for every known player and round, including real zeroes. */
+export function buildPlayerRoundUtilityFacts(pkg: DemoPackage): PlayerRoundUtilityFact[] {
+  const rows = new Map<string, MutableUtilityFact>();
+  const damages = activeDamages(pkg);
+  const keyFor = (roundNumber: number, playerIndex: number) => `${roundNumber}:${playerIndex}`;
+  const factFor = (roundNumber: number, playerIndex: number): MutableUtilityFact | null => {
+    if (!pkg.players[playerIndex]) return null;
+    const key = keyFor(roundNumber, playerIndex);
+    const existing = rows.get(key);
+    if (existing) return existing;
+    const created = emptyFact();
+    rows.set(key, created);
+    return created;
+  };
+
+  for (const round of pkg.rounds) {
+    for (let playerIndex = 0; playerIndex < pkg.players.length; playerIndex += 1) factFor(round.roundNumber, playerIndex);
+  }
+
+  for (const grenade of pkg.grenades) {
+    const fact = factFor(grenade.roundNumber, grenade.throwerIndex);
+    if (!fact) continue;
+    if (grenade.grenade === "flashbang") fact.flashesThrown += 1;
+    else if (grenade.grenade === "hegrenade") fact.heThrows += 1;
+    else if (grenade.grenade === "molotov" || grenade.grenade === "incendiary") fact.fireThrows += 1;
+    else if (grenade.grenade === "smoke") fact.smokesThrown += 1;
+  }
+
+  for (const blind of pkg.blinds) {
+    const flasher = pkg.players[blind.flasherIndex];
+    const flashed = pkg.players[blind.flashedIndex];
+    const fact = factFor(blind.roundNumber, blind.flasherIndex);
+    if (!flasher || !flashed || !fact) continue;
+    if (flasher.teamKey !== flashed.teamKey) {
+      fact.enemyBlindSeconds += blind.durationSeconds;
+      // This is the existing DAK presentation meaning: blinded enemy
+      // person-events, not a de-duplicated flash/victim identity.
+      fact.enemyBlindVictims += 1;
+    } else {
+      fact.teamBlindSeconds += blind.durationSeconds;
+    }
+  }
+
+  for (const damage of damages) {
+    if (damage.attackerIndex === null) continue;
+    const attacker = pkg.players[damage.attackerIndex];
+    const victim = pkg.players[damage.victimIndex];
+    const fact = factFor(damage.roundNumber, damage.attackerIndex);
+    if (!attacker || !victim || !fact || attacker.teamKey === victim.teamKey) continue;
+    if (normalizeWeapon(damage.weapon) === "hegrenade") fact.heDamage += damage.healthDamage;
+    if (isFireWeapon(damage.weapon)) fact.fireDamage += damage.healthDamage;
+    if (isUtilityWeapon(damage.weapon)) fact.utilityDamage += damage.healthDamage;
+  }
+
+  for (const kill of pkg.kills) {
+    if (kill.killerIndex !== null) {
+      const killerFact = factFor(kill.roundNumber, kill.killerIndex);
+      if (killerFact && isUtilityWeapon(kill.weapon)) killerFact.utilityKills += 1;
+    }
+    if (kill.flashAssist && kill.flashAssisterIndex !== null) {
+      const assisterFact = factFor(kill.roundNumber, kill.flashAssisterIndex);
+      if (assisterFact) assisterFact.flashAssists += 1;
+    }
+  }
+
+  return pkg.rounds.flatMap((round) => pkg.players.map((player, playerIndex) => {
+    const fact = rows.get(keyFor(round.roundNumber, playerIndex)) ?? emptyFact();
+    return {
+      roundNumber: round.roundNumber,
+      steamId64: player.steamId64,
+      flashesThrown: fact.flashesThrown,
+      enemyBlindSeconds: fact.enemyBlindSeconds,
+      teamBlindSeconds: fact.teamBlindSeconds,
+      enemyBlindVictims: fact.enemyBlindVictims,
+      flashAssists: fact.flashAssists,
+      heThrows: fact.heThrows,
+      heDamage: fact.heDamage,
+      fireThrows: fact.fireThrows,
+      fireDamage: fact.fireDamage,
+      smokesThrown: fact.smokesThrown,
+      utilityKills: fact.utilityKills,
+      utilityDamage: fact.utilityDamage,
+    };
+  }));
+}

package/src/utils.ts

@@ -1,9 +1,10 @@
-import type { AccountSignalsV2, DemoPackage } from "@cs2dak/contract";
+import type { DemoPackage, RRSignals } from "@cs2dak/contract";
+import { createResolverFromPackage } from "./resolve.js";
 
-export type BuyDeltaBuckets = NonNullable<AccountSignalsV2["combat"]["killsByBuyDelta"]>;
-export type ManStateBuckets = NonNullable<AccountSignalsV2["combat"]["killsByManState"]>;
-export type ObjectiveBuckets = AccountSignalsV2["objective"];
-export type UtilityBuckets = AccountSignalsV2["utility"];
+export type BuyDeltaBuckets = NonNullable<RRSignals["combat"]["killsByBuyDelta"]>;
+export type ManStateBuckets = NonNullable<RRSignals["combat"]["killsByManState"]>;
+export type ObjectiveBuckets = RRSignals["objective"];
+export type UtilityBuckets = RRSignals["utility"];
 
 export const BUY_DELTA_EVEN_THRESHOLD = 1000;
 
@@ -60,18 +61,32 @@ export function firstKillMap(pkg: DemoPackage): Map<number, DemoPackage["kills"]
   return firstKillByRound;
 }
 
-export function sumDamageForPlayer(pkg: DemoPackage, steamId64: string): number {
-  return pkg.damages
-    .filter((damage) => damage.attackerSteamId64 === steamId64 && damage.attackerTeamKey !== damage.victimTeamKey)
+export function activeDamages(pkg: DemoPackage): DemoPackage["damages"] {
+  if (pkg.rounds.length === 0) return pkg.damages;
+  const roundsByNumber = new Map(pkg.rounds.map((r) => [r.roundNumber, r]));
+  return pkg.damages.filter((damage) => {
+    const roundRow = roundsByNumber.get(damage.roundNumber);
+    return Boolean(roundRow && damage.tick >= roundRow.freezeEndTick && damage.tick <= roundRow.endTick);
+  });
+}
+
+export function sumDamageForPlayer(pkg: DemoPackage, playerIndex: number): number {
+  const resolver = createResolverFromPackage(pkg);
+  const playerTeam = resolver.byIndex(playerIndex).teamKey;
+  return activeDamages(pkg)
+    .filter((damage) =>
+      damage.attackerIndex === playerIndex &&
+      resolver.byIndexOrNull(damage.victimIndex)?.teamKey !== playerTeam
+    )
     .reduce((sum, damage) => sum + damage.healthDamage, 0);
 }
 
-export function openingKillsForPlayer(pkg: DemoPackage, steamId64: string): number {
-  return [...firstKillMap(pkg).values()].filter((kill) => kill.killerSteamId64 === steamId64).length;
+export function openingKillsForPlayer(pkg: DemoPackage, playerIndex: number): number {
+  return [...firstKillMap(pkg).values()].filter((kill) => kill.killerIndex === playerIndex).length;
 }
 
-export function openingDeathsForPlayer(pkg: DemoPackage, steamId64: string): number {
-  return [...firstKillMap(pkg).values()].filter((kill) => kill.victimSteamId64 === steamId64).length;
+export function openingDeathsForPlayer(pkg: DemoPackage, playerIndex: number): number {
+  return [...firstKillMap(pkg).values()].filter((kill) => kill.victimIndex === playerIndex).length;
 }
 
 export function multiKillRounds(kills: DemoPackage["kills"], target: number): number {
@@ -83,19 +98,6 @@ export function multiKillRounds(kills: DemoPackage["kills"], target: number): nu
 }
 
 export function clutchSplit(
-  statsCount: number | undefined,
-  statsWon: number | undefined,
-  clutches: DemoPackage["clutches"],
-  opponentCount: number
-) {
-  const rows = clutches.filter((row) => row.opponentCount === opponentCount);
-  return {
-    count: statsCount ?? rows.length,
-    won: statsWon ?? rows.filter((row) => row.won).length
-  };
-}
-
-export function clutchSplitV2(
   count: number | undefined,
   won: number | undefined,
   rows: DemoPackage["clutches"],

package/src/weapon-highlights.ts

@@ -11,11 +11,11 @@ export function derivePlayerWeaponHighlights(input: unknown): PlayerWeaponHighli
 }
 
 export function buildPlayerWeaponHighlights(pkg: DemoPackage): PlayerWeaponHighlightFacts[] {
-  const statsBySteamId = new Map(pkg.playerStats.map((row) => [row.steamId64, row]));
+  const statsMap = new Map(pkg.playerStats.map((row) => [row.playerIndex, row]));
 
-  return pkg.players.map((player) => {
-    const stats = statsBySteamId.get(player.steamId64);
-    const kills = pkg.kills.filter((kill) => kill.killerSteamId64 === player.steamId64);
+  return pkg.players.map((player, playerIdx) => {
+    const stats = statsMap.get(playerIdx);
+    const kills = pkg.kills.filter((kill) => kill.killerIndex === playerIdx);
     const weaponCounts = new Map<string, PlayerWeaponHighlightFacts["weapons"][number]>();
     for (const kill of kills) {
       const weapon = killWeaponName(kill);

package/src/economy.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { EconomyPoint } from "@cs2dak/contract";
-import { buildEconomyConversion } from "./economy";
-
-function pt(p: Partial<EconomyPoint> & Pick<EconomyPoint, "teamAEconomy" | "teamBEconomy" | "winnerTeamKey">): EconomyPoint {
-  return {
-    roundNumber: 1,
-    teamA: 0,
-    teamB: 0,
-    advantage: 0,
-    ...p,
-  };
-}
-
-describe("buildEconomyConversion", () => {
-  it("aggregates per-team win rate by economy type", () => {
-    const points: EconomyPoint[] = [
-      pt({ teamAEconomy: "full", teamBEconomy: "eco", winnerTeamKey: "teamA" }),
-      pt({ teamAEconomy: "full", teamBEconomy: "full", winnerTeamKey: "teamB" }),
-      pt({ teamAEconomy: "eco", teamBEconomy: "full", winnerTeamKey: "teamA" }),
-    ];
-    const { teamA, teamB } = buildEconomyConversion(points);
-
-    // teamA played full twice, won once.
-    expect(teamA.full).toEqual({ played: 2, won: 1, winRate: 0.5 });
-    // teamA played eco once, won it (an eco upset).
-    expect(teamA.eco).toEqual({ played: 1, won: 1, winRate: 1 });
-    // teamB played full twice, won once.
-    expect(teamB.full).toEqual({ played: 2, won: 1, winRate: 0.5 });
-    // teamB played eco once, lost it.
-    expect(teamB.eco).toEqual({ played: 1, won: 0, winRate: 0 });
-  });
-
-  it("returns empty conversions for no rounds", () => {
-    expect(buildEconomyConversion([])).toEqual({ teamA: {}, teamB: {} });
-  });
-});

package/src/economy.ts

@@ -1,57 +0,0 @@
-import type { EconomyPoint, TeamEconomyType } from "@cs2dak/contract";
-
-/** 单一经济类型下的回合胜负统计。 */
-export interface EconomyTypeStats {
-  played: number;
-  won: number;
-  winRate: number;
-}
-
-/** 某队按经济类型分组的转化率，键为经济类型。 */
-export type EconomyConversion = Partial<Record<TeamEconomyType, EconomyTypeStats>>;
-
-/** 一场比赛两队的经济转化率。 */
-export interface MatchEconomyConversion {
-  teamA: EconomyConversion;
-  teamB: EconomyConversion;
-}
-
-function tally(
-  acc: Map<string, { played: number; won: number }>,
-  type: TeamEconomyType,
-  won: boolean,
-): void {
-  const g = acc.get(type) ?? { played: 0, won: 0 };
-  g.played += 1;
-  if (won) g.won += 1;
-  acc.set(type, g);
-}
-
-function finalize(acc: Map<string, { played: number; won: number }>): EconomyConversion {
-  const out: EconomyConversion = {};
-  for (const [type, s] of acc) {
-    out[type as TeamEconomyType] = {
-      played: s.played,
-      won: s.won,
-      winRate: s.played > 0 ? s.won / s.played : 0,
-    };
-  }
-  return out;
-}
-
-/**
- * 经济转化率：按经济类型统计每队的回合胜率。
- *
- * 直接从 kit 的 `EconomyPoint[]` 派生——每个点已含两队经济类型 + 胜方，
- * 无需另一套松散输入。统一并取代 RivalHub `economy-conversion.ts` 的等价逻辑
- * （那边按队拆开传入，这里一次产出两队）。纯函数，无副作用。
- */
-export function buildEconomyConversion(points: EconomyPoint[]): MatchEconomyConversion {
-  const teamA = new Map<string, { played: number; won: number }>();
-  const teamB = new Map<string, { played: number; won: number }>();
-  for (const p of points) {
-    tally(teamA, p.teamAEconomy, p.winnerTeamKey === "teamA");
-    tally(teamB, p.teamBEconomy, p.winnerTeamKey === "teamB");
-  }
-  return { teamA: finalize(teamA), teamB: finalize(teamB) };
-}