@cs2dak/presentation 1.0.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,4 @@
+# @cs2dak/presentation
+
+Product-neutral view models and display semantics derived from core and cohort results.
+It does not parse demos, compute ratings, query databases, or render React.

package/package.json

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

package/src/economy.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { economyLabelCn } from "./economy";
+
+describe("economyLabelCn", () => {
+  it("maps known economy types to presentation labels", () => {
+    expect(economyLabelCn("full")).toBe("全枪全弹");
+    expect(economyLabelCn("ECO")).toBe("纯ECO");
+    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,28 @@
+const ECONOMY_LABELS_CN: Record<string, string> = {
+  pistol: "手枪局",
+  eco: "纯ECO",
+  semi: "半起",
+  force: "强起",
+  full: "全枪全弹",
+  // conversion = 长枪局，与 full 同义，不单独区分。
+  conversion: "全枪全弹",
+};
+
+/** 紧凑版经济标签（图表图例 / SVG 内联用）。 */
+export const ECONOMY_LABEL_SHORT: Record<string, string> = {
+  pistol: "手枪",
+  eco: "Eco",
+  semi: "半起",
+  force: "强起",
+  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;
+}

package/src/index.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { analyzeDemoPackage, loadDemoPackageFromZip } from "@cs2dak/core";
+import { buildDemoViewModel, buildMatchWorkspaceModel } from "./index";
+
+describe("@cs2dak/presentation", () => {
+  it("builds view and workspace models from canonical core analysis", async () => {
+    const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
+    const pkg = await loadDemoPackageFromZip(zip);
+    const view = buildDemoViewModel(analyzeDemoPackage(pkg));
+    const workspace = buildMatchWorkspaceModel(pkg);
+
+    expect(view.scoreline).toBe("3:13");
+    expect(workspace.title).toBe("她还爱我对不 队 vs 車一进一宝贝队");
+    expect(workspace.rounds).toHaveLength(16);
+    expect(workspace.replay.available).toBe(true);
+  });
+});

package/src/index.ts

@@ -0,0 +1,10 @@
+export { buildDemoViewModel, buildMatchWorkspaceModel } from "./workspace.js";
+export { buildSeasonLeaderboardModel } from "./leaderboard.js";
+export { buildPlayerSeasonProfile, buildAllPlayerSeasonProfiles } from "./player.js";
+export { buildTeamCohortSummary } from "./team.js";
+export { buildSeriesSummary, recommendMatchMvp } from "./series.js";
+export { SEASON_STAT_VIEWS } from "./season-metrics.js";
+export { displayWeaponName } from "./weapons.js";
+export { economyLabelCn, ECONOMY_LABEL_SHORT } from "./economy.js";
+export { sideLabel } from "./labels.js";
+export type { EconomyConversion, EconomyTypeStats, MatchEconomyConversion } from "@cs2dak/core";

package/src/labels.ts

@@ -0,0 +1,3 @@
+export function sideLabel(side: string): string {
+  return side === "t" ? "进攻方" : "防守方";
+}

package/src/leaderboard.test.ts

@@ -0,0 +1,84 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { loadDemoPackageFromZip } from "@cs2dak/core";
+import { buildSeasonCohort } from "@cs2dak/cohort";
+import { leaderboardMetricKeySchema, seasonLeaderboardModelSchema } from "@cs2dak/contract";
+import { buildSeasonLeaderboardModel } from "./index";
+
+const fixtureDir = fileURLToPath(new URL("../../../fixtures/input/cohort", import.meta.url));
+const integrationTimeoutMs = 20_000;
+
+const ALL_METRIC_KEYS = leaderboardMetricKeySchema.options;
+
+async function buildCohort() {
+  const names = (await readdir(fixtureDir)).filter((name) => name.endsWith(".zip")).sort();
+  const demos = await Promise.all(
+    names.map(async (name) => ({
+      matchId: name.replace(/\.zip$/, ""),
+      pkg: await loadDemoPackageFromZip(await readFile(join(fixtureDir, name)))
+    }))
+  );
+  return buildSeasonCohort(demos);
+}
+
+describe("buildSeasonLeaderboardModel", () => {
+  it(
+    "derives a product-neutral leaderboard model from a season cohort bundle",
+    async () => {
+      const bundle = await buildCohort();
+      const model = buildSeasonLeaderboardModel(bundle);
+
+      // schema 自校验 + 元信息透传
+      expect(() => seasonLeaderboardModelSchema.parse(model)).not.toThrow();
+      expect(model.version).toBe("cs2-demo-analysis-kit/leaderboard-0.1");
+      expect(model.matchCount).toBe(bundle.matchCount);
+      expect(model.weightsVersion).toBe(bundle.weightsVersion);
+      expect(model.provenance).toEqual(bundle.provenance);
+
+      // 视图：core/impact/advanced，无独立 Demo tab
+      expect(model.views.map((v) => v.key)).toEqual(["core", "impact", "advanced"]);
+      for (const view of model.views) {
+        // 默认排序列必须真实存在于该视图
+        expect(view.columns.some((c) => c.key === view.defaultSort)).toBe(true);
+      }
+
+      // 每行覆盖全部玩家，且每个指标 key 都有条目（可为 null，但不缺）
+      expect(model.rows).toHaveLength(bundle.players.length);
+      for (const row of model.rows) {
+        for (const key of ALL_METRIC_KEYS) {
+          expect(row.metrics).toHaveProperty(key);
+        }
+        // 中立性：不暴露数据库/路由字段，只有中立 key
+        expect(row).not.toHaveProperty("userId");
+      }
+    },
+    integrationTimeoutMs
+  );
+
+  it(
+    "preserves null instead of coercing to 0, and matches cohort source values",
+    async () => {
+      const bundle = await buildCohort();
+      const model = buildSeasonLeaderboardModel(bundle);
+
+      const byKey = new Map(model.rows.map((row) => [row.playerKey, row]));
+      for (const player of bundle.players) {
+        const row = byKey.get(player.playerKey)!;
+        // 不重算：rate 字段直接透传 cohort 已重算的值
+        expect(row.metrics.rivalhubRR).toBe(player.accountRR);
+        expect(row.metrics.hltvRating).toBe(player.rrV1);
+        expect(row.metrics.adr).toBe(player.indicators.adr);
+        expect(row.metrics.kast).toBe(player.indicators.kast);
+        // K/D：deaths=0 必须为 null 而非 0/Infinity
+        if (player.indicators.deaths === 0) {
+          expect(row.metrics.kd).toBeNull();
+        } else {
+          expect(row.metrics.kd).toBeCloseTo(player.indicators.kills / player.indicators.deaths, 1);
+        }
+      }
+    },
+    integrationTimeoutMs
+  );
+});

package/src/leaderboard.ts

@@ -0,0 +1,33 @@
+import {
+  seasonLeaderboardModelSchema,
+  type SeasonCohortBundle,
+  type SeasonLeaderboardModel
+} from "@cs2dak/contract";
+import { SEASON_STAT_VIEWS, computeSeasonMetrics } from "./season-metrics.js";
+
+/**
+ * 把赛季 cohort 结果转换为产品中立的排行榜展示模型。
+ * 纯转换：不重算聚合（cohort 已做 sum counts → recompute rates），不算评分公式。
+ */
+export function buildSeasonLeaderboardModel(bundle: SeasonCohortBundle): SeasonLeaderboardModel {
+  const rows = bundle.players.map((player) => ({
+    playerKey: player.playerKey,
+    name: player.name,
+    steamIds: player.steamIds,
+    externalUserId: player.externalUserId,
+    teamKeys: player.teamKeys,
+    mapCount: player.mapCount,
+    confidence: player.confidence,
+    metrics: computeSeasonMetrics(player),
+    prism: player.prism
+  }));
+
+  return seasonLeaderboardModelSchema.parse({
+    version: "cs2-demo-analysis-kit/leaderboard-0.1",
+    weightsVersion: bundle.weightsVersion,
+    matchCount: bundle.matchCount,
+    provenance: bundle.provenance,
+    views: SEASON_STAT_VIEWS,
+    rows
+  });
+}

package/src/player.test.ts

@@ -0,0 +1,116 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { loadDemoPackageFromZip } from "@cs2dak/core";
+import { buildSeasonCohort } from "@cs2dak/cohort";
+import { playerSeasonProfileSchema } from "@cs2dak/contract";
+import { buildAllPlayerSeasonProfiles, buildPlayerSeasonProfile } from "./index";
+
+const fixtureDir = fileURLToPath(new URL("../../../fixtures/input/cohort", import.meta.url));
+const integrationTimeoutMs = 20_000;
+let cohortFixtures: ReturnType<typeof buildCohort> | null = null;
+
+async function buildCohort() {
+  const names = (await readdir(fixtureDir)).filter((name) => name.endsWith(".zip")).sort();
+  const demos = await Promise.all(
+    names.map(async (name) => ({
+      matchId: name.replace(/\.zip$/, ""),
+      pkg: await loadDemoPackageFromZip(await readFile(join(fixtureDir, name)))
+    }))
+  );
+  return buildSeasonCohort(demos);
+}
+
+function getCohort() {
+  cohortFixtures ??= buildCohort();
+  return cohortFixtures;
+}
+
+describe("buildPlayerSeasonProfile", () => {
+  it(
+    "derives a per-player profile covering rating, metrics, style and trend",
+    async () => {
+      const bundle = await getCohort();
+      const profiles = buildAllPlayerSeasonProfiles(bundle);
+
+      expect(profiles).toHaveLength(bundle.players.length);
+      for (const profile of profiles) {
+        expect(() => playerSeasonProfileSchema.parse(profile)).not.toThrow();
+      }
+
+      const source = bundle.players[0];
+      const profile = buildPlayerSeasonProfile(bundle, source.playerKey);
+
+      // 元信息与评分透传（不重算）
+      expect(profile.version).toBe("cs2-demo-analysis-kit/player-profile-0.1");
+      expect(profile.rating.rivalhubRR).toBe(source.accountRR);
+      expect(profile.rating.hltvRating).toBe(source.rrV1);
+      expect(profile.rating.hltvPercentile).toBe(source.rrV1Percentile);
+      expect(profile.rating.breakdown.map((b) => b.key)).toEqual([
+        "combat",
+        "trade",
+        "clutch",
+        "objective",
+        "utility"
+      ]);
+      expect(profile.weapons.reduce((sum, weapon) => sum + weapon.kills, 0)).toBe(source.weaponHighlights.totalKills);
+      expect(profile.weapons.map((weapon) => weapon.kills)).toEqual(
+        [...profile.weapons.map((weapon) => weapon.kills)].sort((a, b) => b - a)
+      );
+      expect(profile.weapons.every((weapon) =>
+        weapon.headshotPercent == null || (weapon.headshotPercent >= 0 && weapon.headshotPercent <= 100)
+      )).toBe(true);
+      expect(profile.highlights.noScopeKills).toBe(source.weaponHighlights.highlights.noScopeKills);
+      expect(profile.highlights.wallbangKills).toBe(source.weaponHighlights.highlights.wallbangKills);
+
+      // 每场趋势条数 == 该选手参与场次，且按 matchId 升序
+      expect(profile.perMatch).toHaveLength(source.perMatch.length);
+      const ids = profile.perMatch.map((m) => m.matchId);
+      expect(ids).toEqual([...ids].sort((a, b) => a.localeCompare(b)));
+
+      // 中立性：不暴露数据库/路由字段
+      expect(profile).not.toHaveProperty("userId");
+    },
+    integrationTimeoutMs
+  );
+
+  it(
+    "exposes PRISM style as 8 ordered axes, or null when PRISM is missing",
+    async () => {
+      const bundle = await getCohort();
+      const profiles = buildAllPlayerSeasonProfiles(bundle);
+
+      for (const profile of profiles) {
+        const source = bundle.players.find((p) => p.playerKey === profile.playerKey)!;
+        if (source.prism == null) {
+          expect(profile.style).toBeNull();
+        } else {
+          expect(profile.style).not.toBeNull();
+          expect(profile.style!.axes).toHaveLength(8);
+          // 风格轴顺序固定（PRISM_AXIS_ORDER）
+          expect(profile.style!.axes.map((a) => a.key)).toEqual([
+            "firepower",
+            "opening",
+            "clutch",
+            "sniping",
+            "survival",
+            "utility",
+            "trading",
+            "entry"
+          ]);
+          for (const axis of profile.style!.axes) {
+            expect(axis.percentile).toBeGreaterThanOrEqual(0);
+            expect(axis.percentile).toBeLessThanOrEqual(100);
+          }
+        }
+      }
+    },
+    integrationTimeoutMs
+  );
+
+  it("throws for an unknown playerKey", async () => {
+    const bundle = await getCohort();
+    expect(() => buildPlayerSeasonProfile(bundle, "steam:does-not-exist")).toThrow(/not found/);
+  }, integrationTimeoutMs);
+});

package/src/player.ts

@@ -0,0 +1,181 @@
+import { PRISM_AXIS_ORDER, type PrismAxisKey } from "@rivalhub/rival-rating";
+import {
+  playerSeasonProfileSchema,
+  type LeaderboardMetricKey,
+  type PlayerSeasonProfile,
+  type RRBreakdownEntry,
+  type SeasonCohortBundle,
+  type SeasonPlayerRow
+} from "@cs2dak/contract";
+import { computeSeasonMetrics, round } from "./season-metrics.js";
+import { displayWeaponName } from "./weapons.js";
+
+/** RR 账户分解标签（与 Match Workspace 的 rrBreakdown 一致）。 */
+const RR_BREAKDOWN_LABEL: Record<RRBreakdownEntry["key"], string> = {
+  combat: "Combat",
+  trade: "Trade",
+  clutch: "Clutch",
+  objective: "Objective",
+  utility: "Utility"
+};
+
+/** PRISM 八维中文标签。 */
+const PRISM_AXIS_LABEL: Record<PrismAxisKey, string> = {
+  firepower: "火力",
+  opening: "首杀",
+  clutch: "残局",
+  sniping: "狙击",
+  survival: "生存",
+  utility: "道具",
+  trading: "补枪",
+  entry: "突破"
+};
+
+/** 用于强项/弱项判定的技能类指标（高 = 好）。不含纯风格标签（如 AWP）。 */
+const SKILL_METRICS: { key: LeaderboardMetricKey; label: string }[] = [
+  { key: "adr", label: "输出 (ADR)" },
+  { key: "kast", label: "回合参与 (KAST)" },
+  { key: "kd", label: "对枪交换 (K/D)" },
+  { key: "hsPercent", label: "爆头率" },
+  { key: "openingDuelWinRate", label: "首杀对枪 (Entry)" },
+  { key: "multiKillPer100", label: "多杀产量" }
+];
+
+const STRENGTH_PERCENTILE = 70;
+const WEAKNESS_PERCENTILE = 30;
+const MIN_COHORT_FOR_NARRATIVE = 5;
+const MAX_NARRATIVE_ITEMS = 3;
+
+/** value 在分布中的百分位（≤ 计数 / 总数 × 100）。 */
+function percentileOf(value: number, distribution: number[]): number {
+  if (distribution.length === 0) return 0;
+  const atOrBelow = distribution.filter((v) => v <= value).length;
+  return round((atOrBelow / distribution.length) * 100, 1);
+}
+
+function buildStyle(player: SeasonPlayerRow): PlayerSeasonProfile["style"] {
+  const prism = player.prism;
+  if (!prism) return null;
+  return {
+    weightsVersion: prism.weightsVersion,
+    rrPercentile: prism.rrPercentile,
+    axes: PRISM_AXIS_ORDER.map((key) => ({
+      key,
+      label: PRISM_AXIS_LABEL[key],
+      percentile: prism.axes[key].percentile
+    }))
+  };
+}
+
+function profileFromRow(
+  player: SeasonPlayerRow,
+  metrics: Record<LeaderboardMetricKey, number | null>,
+  weightsVersion: string,
+  strengths: string[],
+  weaknesses: string[]
+): PlayerSeasonProfile {
+  const percent = (count: number, total: number): number | null =>
+    total > 0 ? round((count / total) * 100, 1) : null;
+
+  return playerSeasonProfileSchema.parse({
+    version: "cs2-demo-analysis-kit/player-profile-0.1",
+    weightsVersion,
+    playerKey: player.playerKey,
+    name: player.name,
+    steamIds: player.steamIds,
+    externalUserId: player.externalUserId,
+    teamKeys: player.teamKeys,
+    mapCount: player.mapCount,
+    confidence: player.confidence,
+    accountContextStatus: player.accountContextStatus,
+    rating: {
+      rivalhubRR: player.accountRR,
+      rivalhubRRRaw: player.accountRRRaw,
+      hltvRating: player.rrV1,
+      hltvPercentile: player.rrV1Percentile,
+      breakdown: (Object.keys(RR_BREAKDOWN_LABEL) as RRBreakdownEntry["key"][]).map((key) => ({
+        key,
+        label: RR_BREAKDOWN_LABEL[key],
+        value: player.accountBreakdown[key]
+      }))
+    },
+    metrics,
+    weapons: player.weaponHighlights.weapons.map((weapon) => ({
+      weapon: weapon.weapon,
+      label: displayWeaponName(weapon.weapon),
+      kills: weapon.kills,
+      killSharePercent: player.weaponHighlights.totalKills > 0
+        ? round((weapon.kills / player.weaponHighlights.totalKills) * 100, 1)
+        : 0,
+      headshotPercent: percent(weapon.headshotKills, weapon.kills),
+      tradeKillPercent: percent(weapon.tradeKills, weapon.kills),
+      noScopePercent: percent(weapon.noScopeKills, weapon.kills),
+      throughSmokePercent: percent(weapon.throughSmokeKills, weapon.kills),
+      wallbangPercent: percent(weapon.wallbangKills, weapon.kills),
+      averagePenetratedObjects: weapon.kills > 0
+        ? round(weapon.penetratedObjects / weapon.kills, 2)
+        : null
+    })),
+    highlights: player.weaponHighlights.highlights,
+    style: buildStyle(player),
+    perMatch: [...player.perMatch]
+      .sort((a, b) => a.matchId.localeCompare(b.matchId))
+      .map((m) => ({ matchId: m.matchId, rivalhubRR: m.accountRR, hltvRating: m.rrV1 })),
+    strengths,
+    weaknesses
+  });
+}
+
+/**
+ * 为赛季 cohort 中每个选手派生档案。强项/弱项相对该 cohort 计算（技能类指标百分位）。
+ * 纯转换 + cohort 内部排名总结，不算评分公式。
+ */
+export function buildAllPlayerSeasonProfiles(bundle: SeasonCohortBundle): PlayerSeasonProfile[] {
+  const metricsByKey = new Map(bundle.players.map((p) => [p.playerKey, computeSeasonMetrics(p)]));
+
+  // 每个技能指标在 cohort 内的取值分布（剔除 null）。
+  const distribution = new Map<LeaderboardMetricKey, number[]>(
+    SKILL_METRICS.map(({ key }) => [
+      key,
+      bundle.players
+        .map((p) => metricsByKey.get(p.playerKey)![key])
+        .filter((v): v is number => v != null)
+    ])
+  );
+
+  const cohortLargeEnough = bundle.players.length >= MIN_COHORT_FOR_NARRATIVE;
+
+  return bundle.players.map((player) => {
+    const metrics = metricsByKey.get(player.playerKey)!;
+
+    const ranked = cohortLargeEnough
+      ? SKILL_METRICS.map(({ key, label }) => {
+          const value = metrics[key];
+          if (value == null) return null;
+          return { label, percentile: percentileOf(value, distribution.get(key)!) };
+        }).filter((x): x is { label: string; percentile: number } => x != null)
+      : [];
+
+    const strengths = ranked
+      .filter((r) => r.percentile >= STRENGTH_PERCENTILE)
+      .sort((a, b) => b.percentile - a.percentile)
+      .slice(0, MAX_NARRATIVE_ITEMS)
+      .map((r) => r.label);
+    const weaknesses = ranked
+      .filter((r) => r.percentile <= WEAKNESS_PERCENTILE)
+      .sort((a, b) => a.percentile - b.percentile)
+      .slice(0, MAX_NARRATIVE_ITEMS)
+      .map((r) => r.label);
+
+    return profileFromRow(player, metrics, bundle.weightsVersion, strengths, weaknesses);
+  });
+}
+
+/** 取单个选手档案；playerKey 不存在时抛错。 */
+export function buildPlayerSeasonProfile(bundle: SeasonCohortBundle, playerKey: string): PlayerSeasonProfile {
+  const profile = buildAllPlayerSeasonProfiles(bundle).find((p) => p.playerKey === playerKey);
+  if (!profile) {
+    throw new Error(`playerKey not found in cohort: ${playerKey}`);
+  }
+  return profile;
+}

package/src/season-metrics.ts

@@ -0,0 +1,93 @@
+import type { LeaderboardMetricKey, LeaderboardView, SeasonPlayerRow } from "@cs2dak/contract";
+
+/**
+ * 赛季统计的共享展示层：指标计算 + 视图（列）定义。
+ * 排行榜（SeasonLeaderboardModel）和选手页（PlayerSeasonProfile）共用同一套，
+ * 保证两处的口径、标签、格式一致。标签归 presentation（React 不重复定义）。
+ *
+ * 约定：builder 把所有指标归一化到“展示刻度”，format 只负责精度与单位后缀：
+ * - 百分比统一为 0–100；产量家族（FK/MK/C）统一为每 100 回合。
+ * - 缺失保持 null，不伪造 0。
+ */
+
+export function round(value: number, digits = 2): number {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+
+/** 视图列定义（信息架构来自 RivalHub StatsLeaderboard，去掉 OCR 副指标与独立 Demo tab）。 */
+export const SEASON_STAT_VIEWS: LeaderboardView[] = [
+  {
+    key: "core",
+    label: "Core",
+    defaultSort: "rivalhubRR",
+    columns: [
+      { key: "maps", label: "Maps", format: "integer", description: null },
+      { key: "rivalhubRR", label: "RR", format: "rating", description: "RivalHub RR（绝对刻度评分）" },
+      { key: "hltvRating", label: "Rating 2.0", format: "rating", description: "HLTV Rating 2.0 量纲" },
+      { key: "adr", label: "ADR", format: "adr", description: "每回合平均伤害" },
+      { key: "kd", label: "K/D", format: "ratio", description: "击杀死亡比" },
+      { key: "kpr", label: "KPR", format: "ratio", description: "每回合击杀" },
+      { key: "hsPercent", label: "HS%", format: "percent", description: "爆头率" }
+    ]
+  },
+  {
+    key: "impact",
+    label: "Impact",
+    defaultSort: "firstKillPer100",
+    columns: [
+      { key: "maps", label: "Maps", format: "integer", description: null },
+      { key: "rivalhubRR", label: "RR", format: "rating", description: "RivalHub RR（绝对刻度评分）" },
+      { key: "hltvRating", label: "Rating 2.0", format: "rating", description: "HLTV Rating 2.0 量纲" },
+      { key: "firstKillPer100", label: "FK/100r", format: "ratio", description: "每 100 回合首杀" },
+      { key: "multiKillPer100", label: "MK/100r", format: "ratio", description: "每 100 回合多杀回合" },
+      { key: "clutchPer100", label: "C/100r", format: "ratio", description: "每 100 回合残局胜利" },
+      { key: "openingDuelWinRate", label: "Entry%", format: "percent", description: "首杀对枪胜率" }
+    ]
+  },
+  {
+    key: "advanced",
+    label: "Advanced",
+    defaultSort: "kast",
+    columns: [
+      { key: "maps", label: "Maps", format: "integer", description: null },
+      { key: "rivalhubRR", label: "RR", format: "rating", description: "RivalHub RR（绝对刻度评分）" },
+      { key: "hltvRating", label: "Rating 2.0", format: "rating", description: "HLTV Rating 2.0 量纲" },
+      { key: "kast", label: "KAST%", format: "percent", description: "有效回合参与率" },
+      { key: "utilityDamagePerRound", label: "Util/R", format: "ratio", description: "每回合道具伤害" },
+      { key: "awpKillsPerRound", label: "AWP/R", format: "ratio", description: "每回合 AWP 击杀" },
+      { key: "awpKillRate", label: "AWP%", format: "percent", description: "AWP 击杀占比" },
+      { key: "tradeKillRate", label: "Trade/R", format: "ratio", description: "每回合补枪击杀" },
+      { key: "flashAssistPerRound", label: "FA/R", format: "ratio", description: "每回合闪光助攻" }
+    ]
+  }
+];
+
+/**
+ * 把一行赛季 cohort 结果转换为展示指标。纯转换：不重算聚合（cohort 已 sum→recompute），
+ * 不算评分公式。缺失保持 null。
+ */
+export function computeSeasonMetrics(player: SeasonPlayerRow): Record<LeaderboardMetricKey, number | null> {
+  const ind = player.indicators;
+  return {
+    maps: player.mapCount,
+    rivalhubRR: player.accountRR,
+    hltvRating: player.rrV1,
+    adr: ind.adr,
+    kd: ind.deaths > 0 ? round(ind.kills / ind.deaths, 2) : null,
+    kpr: ind.kpr,
+    hsPercent: ind.hsPercent, // 已是 0–100
+    // 产量家族：每 100 回合 X 次
+    firstKillPer100: round(ind.firstKillRate * 100, 2),
+    multiKillPer100: round(ind.multiKillRate * 100, 2),
+    clutchPer100: round((ind.clutchWins / ind.totalRounds) * 100, 2),
+    // 百分比统一为 0–100（cohort 中以 0–1 存储的需 ×100）
+    openingDuelWinRate: round(ind.openingDuelWinRate * 100, 2),
+    kast: ind.kast, // 已是 0–100
+    utilityDamagePerRound: ind.utilityDamagePerRound,
+    awpKillsPerRound: ind.awpKillsPerRound,
+    awpKillRate: round(ind.awpKillRate * 100, 2),
+    flashAssistPerRound: ind.flashAssistPerRound,
+    tradeKillRate: ind.tradeKillRate
+  };
+}