@cs2dak/core 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Starfie1d
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @cs2dak/core
+
+English | 简体中文
+
+Pure demo analysis engine. It accepts a parsed `DemoPackage`, produces an `AnalysisBundle`, and derives a `DemoViewModel`.
+
+纯分析引擎。输入标准化后的 `DemoPackage`，输出 `AnalysisBundle` 和 `DemoViewModel`。这里不允许依赖 React、数据库、Next.js、FastAPI 或 RivalHub 业务代码。

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@cs2dak/core",
+  "version": "0.2.0",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@rivalhub/rival-rating": "^0.1.0",
+    "jszip": "^3.10.1",
+    "@cs2dak/contract": "0.2.0"
+  },
+  "files": [
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/economy.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import type { EconomyPoint } from "@cs2dak/contract";
+import { buildEconomyConversion, economyLabelCn } 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: {} });
+  });
+});
+
+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

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

package/src/index.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, it } from "vitest";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import {
+  analyzeDemoPackage,
+  buildMatchWorkspaceModel,
+  buildDemoViewModel,
+  computeAccountRatingsV2,
+  deriveAccountSignalsV2,
+  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.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.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 () => {
+    const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
+    const pkg = await loadDemoPackageFromZip(zip);
+    const signals = deriveAccountSignalsV2(pkg);
+    const ratings = computeAccountRatingsV2(pkg);
+
+    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(ratings[0]?.rr.model).toBe("value-accounts-v2-lite");
+    expect(ratings[0]?.rr.rr).toBeGreaterThan(0);
+  });
+
+  it("anchors accountRR so the per-match league mean is ~1.0", 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 accountRRs = bundle.scoreboard.map((row) => row.accountRR);
+    const mean = accountRRs.reduce((sum, v) => sum + v, 0) / accountRRs.length;
+    expect(mean).toBeCloseTo(1.0, 2);
+    // 锚定后必然有人高于、有人低于 1.0
+    expect(accountRRs.some((v) => v > 1.0)).toBe(true);
+    expect(accountRRs.some((v) => v < 1.0)).toBe(true);
+  });
+
+  it("exposes RRIndicators without rebuilding them in cohort callers", async () => {
+    const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
+    const pkg = await loadDemoPackageFromZip(zip);
+    const indicators = deriveRRIndicators(pkg);
+    const bundle = analyzeDemoPackage(pkg);
+
+    expect(indicators).toHaveLength(10);
+    expect(indicators[0]).toEqual(bundle.playerIndicators[0]?.indicators);
+  });
+
+  it("wires player-stats truth into RRIndicators instead of legacy approximations", async () => {
+    const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
+    const pkg = await loadDemoPackageFromZip(zip);
+    const statsTruth = pkg.playerStats[0]!;
+    const patchedStats = {
+      ...statsTruth,
+      deaths: statsTruth.deaths + 2,
+      combatDeathCount: statsTruth.deaths,
+      bombDeathCount: 2
+    };
+    const patchedPkg = {
+      ...pkg,
+      playerStats: pkg.playerStats.map((row) => row.steamId64 === statsTruth.steamId64 ? patchedStats : row)
+    };
+    const indicators = deriveRRIndicators(patchedPkg);
+    const bombDeathStats = patchedStats;
+    const wallbangStats = pkg.playerStats.find((row) => row.wallbangKillCount > 0)!;
+
+    const bombDeathIndicators = indicators.find((row) => row.steamId64 === bombDeathStats.steamId64)!;
+    const wallbangIndicators = indicators.find((row) => row.steamId64 === wallbangStats.steamId64)!;
+
+    expect(bombDeathStats.deaths).not.toBe(bombDeathStats.combatDeathCount);
+    expect(bombDeathIndicators.combatDeathCount).toBe(bombDeathStats.combatDeathCount);
+    expect(bombDeathIndicators.bombDeathCount).toBe(bombDeathStats.bombDeathCount);
+    expect(wallbangIndicators.wallbangKillCount).toBe(wallbangStats.wallbangKillCount);
+  });
+
+  it("surfaces account breakdown and context status on the scoreboard", 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 row = bundle.scoreboard[0]!;
+
+    expect(row.accountBreakdown.combat).toBeGreaterThan(0);
+    // 该 fixture 含经济与回合数据 → 两个 context 维度都 available
+    expect(row.accountContextStatus.buyDelta).toBe("available");
+    expect(row.accountContextStatus.manState).toBe("available");
+  });
+
+  it("surfaces rich v2 fields and confidence on the scoreboard", 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 row = bundle.scoreboard[0]!;
+
+    expect(row.combatDeathCount).toBe(11);
+    expect(row.bombDeathCount).toBe(0);
+    expect(row.bombPlantCount).toBe(4);
+    expect(row.noScopeKillCount).toBe(0);
+    expect(row.throughSmokeKillCount).toBe(2);
+    expect(row.fieldAvailability).toEqual({
+      playerStats: "available",
+      economy: "available",
+      rounds: "available",
+      richKills: "partial",
+      damages: "available",
+      bombs: "available"
+    });
+    expect(row.confidence).toBeCloseTo(0.917, 3);
+  });
+
+  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);
+
+    // 剥离经济源 → buyDelta 降级为 null（而非零桶）；manState 仍可用
+    const noEconomy = deriveAccountSignalsV2({ ...pkg, playerEconomies: [] });
+    expect(noEconomy[0]?.combat.killsByBuyDelta).toBeNull();
+    expect(noEconomy[0]?.combat.killsByManState).not.toBeNull();
+
+    // 剥离回合源 → manState 降级为 null
+    const noRounds = deriveAccountSignalsV2({ ...pkg, rounds: [] });
+    expect(noRounds[0]?.combat.killsByManState).toBeNull();
+  });
+});

package/src/index.ts

@@ -0,0 +1,49 @@
+import { analysisBundleSchema, type AnalysisBundle } from "@cs2dak/contract";
+import { normalizeDemoPackage } from "./normalize.js";
+import { buildQaReport } from "./qa.js";
+import { buildPlayerRoundFacts, buildPlayerIndicators, buildScoreboard } from "./scoreboard.js";
+import { computeAccountRatingsV2 } from "./signals.js";
+import { buildTimeline, buildEconomy, buildHeatmap } from "./timeline.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 type {
+  EconomyTypeStats,
+  EconomyConversion,
+  MatchEconomyConversion,
+} from "./economy.js";
+
+export function analyzeDemoPackage(input: unknown): AnalysisBundle {
+  const pkg = normalizeDemoPackage(input);
+  const qa = buildQaReport(pkg);
+  const playerRoundFacts = buildPlayerRoundFacts(pkg);
+  const playerIndicators = buildPlayerIndicators(pkg, playerRoundFacts);
+  const accountRatings = computeAccountRatingsV2(pkg);
+  const scoreboard = buildScoreboard(pkg, playerIndicators, accountRatings);
+  const timeline = buildTimeline(pkg);
+  const economy = buildEconomy(pkg);
+  const heatmap = buildHeatmap(pkg);
+
+  return analysisBundleSchema.parse({
+    version: "cs2-demo-analysis-kit/0.2",
+    sourceSchemaVersion: pkg.manifest.schemaVersion,
+    mapName: pkg.match.mapName,
+    tickrate: pkg.match.tickrate,
+    teams: {
+      teamA: { name: pkg.match.teamA.name ?? "Team A", score: pkg.match.teamA.score },
+      teamB: { name: pkg.match.teamB.name ?? "Team B", score: pkg.match.teamB.score }
+    },
+    scoreboard,
+    playerIndicators,
+    playerRoundFacts,
+    timeline,
+    economy,
+    heatmap,
+    qa
+  });
+}

package/src/loader.ts

@@ -0,0 +1,48 @@
+import JSZip from "jszip";
+import type { DemoPackage } from "@cs2dak/contract";
+import { normalizeDemoPackage, parsePackageJson } from "./normalize.js";
+
+export async function loadDemoPackageFromZip(bytes: ArrayBuffer | Uint8Array): Promise<DemoPackage> {
+  const zip = await JSZip.loadAsync(bytes);
+  const readJson = async <T>(name: string): Promise<T> => {
+    const file = zip.file(name);
+    if (!file) {
+      throw new Error(`Missing ${name} in demo package`);
+    }
+    return parsePackageJson(await file.async("string")) as T;
+  };
+
+  const manifest = await readJson<unknown>("manifest.json");
+  const match = await readJson<unknown>("match.json");
+  const players = await readJson<unknown>("players.json");
+  const rounds = await readJson<unknown>("rounds.json");
+  const playerEconomies = await readJson<unknown>("player-economies.json").catch(() => []);
+  const playerStats = await readJson<unknown>("player-stats.json").catch(() => []);
+  const kills = await readJson<unknown>("kills.json").catch(() => []);
+  const damages = await readJson<unknown>("damages.json").catch(() => []);
+  const blinds = await readJson<unknown>("blinds.json").catch(() => []);
+  const bombs = await readJson<unknown>("bombs.json").catch(() => []);
+  const grenades = await readJson<unknown>("grenades.json").catch(() => []);
+  const clutches = await readJson<unknown>("clutches.json").catch(() => []);
+  const shots = await readJson<unknown>("shots.json").catch(() => undefined);
+  const positions1s = await readJson<unknown>("positions-1s.json").catch(() => undefined);
+  const replay = await readJson<unknown>("replay.json").catch(() => undefined);
+
+  return normalizeDemoPackage({
+    manifest,
+    match,
+    players,
+    rounds,
+    playerEconomies,
+    playerStats,
+    kills,
+    damages,
+    blinds,
+    bombs,
+    grenades,
+    clutches,
+    shots,
+    positions1s,
+    replay
+  });
+}

package/src/normalize.ts

@@ -0,0 +1,158 @@
+import { demoPackageSchema, type DemoPackage, type TeamKey } 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 };
+}