@cs2dak/presentation 1.0.0 → 2.0.0

package/src/insights.ts

@@ -0,0 +1,1151 @@
+import type { DemoPackage, EvidenceRef, MatchWorkspaceModel, TeamKey } from "@cs2dak/contract";
+import { buildPlayerRoundUtilityFacts, derivePlayerMechanics, type PlayerMechanicsFact } from "@cs2dak/core";
+import type { TriangleBvh } from "@cs2dak/maps";
+import { round } from "./season-metrics.js";
+import { displayWeaponName } from "./weapons.js";
+import { normalizeWeapon } from "./workspace-utils.js";
+
+/**
+ * v0.3 洞察派生：个人趋势 / Flash Value / Mistake Review / Buy Quality /
+ * 赛事总览。输入是 Studio 已经加载的 {matchId, pkg} 列表（与 cohort 同源），
+ * 全部为纯函数派生，不算评分公式、不查数据库。
+ *
+ * 结论必须可证据化：每条 Mistake / 高光都带 matchId + roundNumber，
+ * UI 端可借 onOpenMatch 跳回具体比赛复盘（query-first 原则）。
+ */
+
+export interface SeasonInsightsDemo {
+  matchId: string;
+  pkg: DemoPackage;
+}
+
+// ── 个人趋势 ────────────────────────────────────────────────────────────────
+
+export interface PlayerTrendPoint {
+  matchId: string;
+  mapName: string;
+  adr: number;
+  kast: number;
+  /** 首杀数 - 首死数。 */
+  fkMinusFd: number;
+  utilityDamagePerRound: number;
+  clutchAttempts: number;
+  clutchWins: number;
+  kills: number;
+  deaths: number;
+}
+
+// ── Flash Value ─────────────────────────────────────────────────────────────
+
+export interface TeamFlashIncident extends EvidenceRef {
+  victimCount: number;
+  totalSeconds: number;
+}
+
+/** 单颗（按 flashId 归并）致盲敌方的闪光事件，含同颗队闪秒数与净收益。 */
+export interface EnemyFlashIncident extends EvidenceRef {
+  /** 被这颗闪致盲的敌方人数。 */
+  victimCount: number;
+  /** 这颗闪致盲敌方总秒数。 */
+  enemySeconds: number;
+  /** 同一颗闪误盲队友的总秒数（无误盲为 0）。 */
+  teamSeconds: number;
+  /** enemySeconds − teamSeconds，单颗净收益。 */
+  netSeconds: number;
+}
+
+export interface FlashValueSummary {
+  flashesThrown: number;
+  enemyBlindSeconds: number;
+  teamBlindSeconds: number;
+  /** 致盲敌方人次（被白的敌人数量累计，不是秒数）。 */
+  enemyBlindVictims: number;
+  /** 敌方致盲秒数 / 投掷数；没投过闪为 null。 */
+  enemySecondsPerFlash: number | null;
+  /** (敌方 - 友方) 致盲秒数 / 投掷数；没投过闪为 null。 */
+  netSecondsPerFlash: number | null;
+  flashAssists: number;
+  /** 最严重的队闪事件（按致盲总秒数降序，最多 10 条）。 */
+  worstTeamFlashes: TeamFlashIncident[];
+  /** 效果最好的闪光事件（按致盲敌方秒数降序的候选集，UI 可再按净收益排序）。 */
+  bestEnemyFlashes: EnemyFlashIncident[];
+}
+
+// ── Mistake Review ──────────────────────────────────────────────────────────
+
+export interface MistakeEvidence extends EvidenceRef {
+  detail: string;
+}
+
+export interface FirstDeathStat {
+  count: number;
+  attempts: number;
+  evidence: MistakeEvidence[];
+}
+
+export interface MistakeReview {
+  /** 劣势经济局（eco/semi/force）中首死的回合（参考权重低）。 */
+  lowBuyFirstDeaths: FirstDeathStat;
+  /** 全枪全弹局（full）首死——最有分析价值的失误信号。 */
+  fullBuyFirstDeaths: FirstDeathStat;
+  /** Anti-eco 首死：对手 eco/semi 时我方首死。 */
+  antiEcoFirstDeaths: FirstDeathStat;
+  /** 死亡时间分布（相对 freeze end 的秒数）：开局 25s / 25-55s / 55s 后。 */
+  deathTiming: { early: number; mid: number; late: number; total: number };
+  /** 残局失利（1vN 没打赢）。 */
+  clutchLosses: { count: number; evidence: MistakeEvidence[] };
+}
+
+export interface PlayerSeasonInsights {
+  trend: PlayerTrendPoint[];
+  flash: FlashValueSummary;
+  mistakes: MistakeReview;
+}
+
+export interface PlayerWeaponStat {
+  weapon: string;
+  label: string;
+  kills: number;
+  headshotPercent: number | null;
+  killsPerMatch: number;
+}
+
+export interface PlayerMechanicsWeaponProfile {
+  weapon: string;
+  label: string;
+  kills: number;
+  firstShotAccuracyPercent: number | null;
+  sprayAccuracyPercent: number | null;
+  medianTtkMs: number | null;
+  counterStrafeSuccessPercent: number | null;
+  oneTapRatePercent: number | null;
+  visualReactionMs: number | null;
+  preaimErrorDegrees: number | null;
+  headshotPercent: number | null;
+  killsPerMatch: number | null;
+  percentile: Record<string, string | null>;
+}
+
+export interface PlayerMechanicsProfile {
+  overall: PlayerMechanicsWeaponProfile;
+  weapons: PlayerMechanicsWeaponProfile[];
+}
+
+export interface PlayerFlashSummaryInput {
+  playerKey: string;
+  name: string;
+  steamIds: string[];
+}
+
+export interface PlayerFlashSummary {
+  playerKey: string;
+  name: string;
+  flashesThrown: number;
+  enemyBlindSeconds: number;
+  teamBlindSeconds: number;
+  enemyBlindVictims: number;
+  enemySecondsPerFlash: number | null;
+  netSecondsPerFlash: number | null;
+  flashAssists: number;
+  worstTeamFlashes: TeamFlashIncident[];
+  bestEnemyFlashes: EnemyFlashIncident[];
+}
+
+export type UtilityDamageKind = "he" | "fire";
+
+export interface UtilityValueRow {
+  id: string;
+  name: string;
+  rounds: number;
+  flashesThrown: number;
+  enemyBlindSeconds: number;
+  enemyBlindSecondsRaw?: number;
+  enemyBlindSecondsPerFlash: number | null;
+  enemyBlindSecondsPerRound: number | null;
+  flashAssists: number;
+  flashAssistsPerRound: number | null;
+  heThrows: number;
+  heDamage: number;
+  heDamagePerThrow: number | null;
+  heDamagePerRound: number | null;
+  fireThrows: number;
+  fireDamage: number;
+  fireDamagePerThrow: number | null;
+  fireDamagePerRound: number | null;
+  smokesThrown: number;
+  smokesPerRound: number | null;
+}
+
+export interface UtilityDamageEvidence extends EvidenceRef {
+  kind: UtilityDamageKind;
+  playerId?: string;
+  playerName: string;
+  victimCount: number;
+  damage: number;
+}
+
+export interface UtilityValueSummary {
+  players: UtilityValueRow[];
+  teams: UtilityValueRow[];
+  bestFlashes: Array<EnemyFlashIncident & { playerId?: string; playerName: string }>;
+  bestDamageRounds: UtilityDamageEvidence[];
+}
+
+const DEATH_EARLY_SECONDS = 25; // 1:55 -> 1:30
+const DEATH_LATE_SECONDS = 55; // 1:30 -> 1:00；之后为 1:00 后
+const LOW_BUY_TYPES = new Set(["eco", "semi", "force"]);
+const MAX_EVIDENCE = 10;
+/** 最佳闪光候选集容量：因 netSeconds ≤ enemySeconds，按敌方秒数取 Top-N 必含净收益 Top。 */
+const MAX_BEST_FLASH = 15;
+
+function tickrateOf(pkg: DemoPackage): number {
+  return pkg.match.tickrate ?? 64;
+}
+
+function isHeDamageWeapon(weapon: string): boolean {
+  return normalizeWeapon(weapon) === "hegrenade";
+}
+
+function isFireDamageWeapon(weapon: string): boolean {
+  return ["inferno", "molotov", "incgrenade", "incendiary"].includes(normalizeWeapon(weapon));
+}
+
+function utilityRow(id: string, name: string): UtilityValueRow {
+  return {
+    id,
+    name,
+    rounds: 0,
+    flashesThrown: 0,
+    enemyBlindSeconds: 0,
+    enemyBlindSecondsPerFlash: null,
+    enemyBlindSecondsPerRound: null,
+    flashAssists: 0,
+    flashAssistsPerRound: null,
+    heThrows: 0,
+    heDamage: 0,
+    heDamagePerThrow: null,
+    heDamagePerRound: null,
+    fireThrows: 0,
+    fireDamage: 0,
+    fireDamagePerThrow: null,
+    fireDamagePerRound: null,
+    smokesThrown: 0,
+    smokesPerRound: null,
+  };
+}
+
+function finalizeUtilityRow(row: UtilityValueRow): UtilityValueRow {
+  const enemyBlindSecondsRaw = row.enemyBlindSecondsRaw ?? row.enemyBlindSeconds;
+  return {
+    ...row,
+    enemyBlindSecondsRaw,
+    enemyBlindSeconds: round(enemyBlindSecondsRaw, 1),
+    enemyBlindSecondsPerFlash: row.flashesThrown > 0 ? round(enemyBlindSecondsRaw / row.flashesThrown, 2) : null,
+    enemyBlindSecondsPerRound: row.rounds > 0 ? round(enemyBlindSecondsRaw / row.rounds, 2) : null,
+    flashAssistsPerRound: row.rounds > 0 ? round(row.flashAssists / row.rounds, 3) : null,
+    heDamagePerThrow: row.heThrows > 0 ? round(row.heDamage / row.heThrows, 2) : null,
+    heDamagePerRound: row.rounds > 0 ? round(row.heDamage / row.rounds, 2) : null,
+    fireDamagePerThrow: row.fireThrows > 0 ? round(row.fireDamage / row.fireThrows, 2) : null,
+    fireDamagePerRound: row.rounds > 0 ? round(row.fireDamage / row.rounds, 2) : null,
+    smokesPerRound: row.rounds > 0 ? round(row.smokesThrown / row.rounds, 3) : null,
+  };
+}
+
+export function buildUtilityValueSummary(
+  demos: SeasonInsightsDemo[],
+  players: PlayerFlashSummaryInput[],
+  options: { teamRenames?: Record<string, string> } = {}
+): UtilityValueSummary {
+  const bySteamId = new Map<string, PlayerFlashSummaryInput>();
+  const playerRows = new Map<string, UtilityValueRow>();
+  const teamRows = new Map<string, UtilityValueRow>();
+  const bestFlashes: UtilityValueSummary["bestFlashes"] = [];
+  const damageEvidence = new Map<string, UtilityDamageEvidence & { victims: Set<string> }>();
+
+  for (const player of players) {
+    playerRows.set(player.playerKey, utilityRow(player.playerKey, player.name));
+    for (const steamId of player.steamIds) bySteamId.set(steamId, player);
+  }
+
+  const teamName = (pkg: DemoPackage, teamKey: TeamKey): string => {
+    const raw = teamKey === "teamA" ? (pkg.match.teamA.name ?? "Team A") : (pkg.match.teamB.name ?? "Team B");
+    return options.teamRenames?.[raw] ?? raw;
+  };
+  const ensureTeam = (pkg: DemoPackage, teamKey: TeamKey) => {
+    const name = teamName(pkg, teamKey);
+    const row = teamRows.get(name) ?? utilityRow(name, name);
+    teamRows.set(name, row);
+    return row;
+  };
+
+  for (const { matchId, pkg } of demos) {
+    for (const key of ["teamA", "teamB"] as const) {
+      ensureTeam(pkg, key).rounds += pkg.rounds.length;
+    }
+
+    for (const stat of pkg.playerStats) {
+      const player = bySteamId.get(pkg.players[stat.playerIndex]?.steamId64 ?? "");
+      if (!player) continue;
+      const row = playerRows.get(player.playerKey)!;
+      row.rounds += stat.rounds;
+    }
+
+    // Base utility totals are shared with every DAK consumer, including
+    // external product adapters. This view only adds presentation evidence.
+    for (const utility of buildPlayerRoundUtilityFacts(pkg)) {
+      const player = bySteamId.get(utility.steamId64);
+      const packagePlayer = pkg.players.find((candidate) => candidate.steamId64 === utility.steamId64);
+      if (!packagePlayer) continue;
+      const playerRow = player ? playerRows.get(player.playerKey) : null;
+      const teamRow = ensureTeam(pkg, packagePlayer.teamKey);
+      for (const row of [playerRow, teamRow]) {
+        if (!row) continue;
+        row.flashesThrown += utility.flashesThrown;
+        row.enemyBlindSeconds += utility.enemyBlindSeconds;
+        row.flashAssists += utility.flashAssists;
+        row.heThrows += utility.heThrows;
+        row.heDamage += utility.heDamage;
+        row.fireThrows += utility.fireThrows;
+        row.fireDamage += utility.fireDamage;
+        row.smokesThrown += utility.smokesThrown;
+      }
+    }
+
+    type FlashCell = { playerKey: string; playerName: string; roundNumber: number; tick: number; victims: Set<string>; enemySeconds: number; teamSeconds: number };
+    const flashCells = new Map<string, FlashCell>();
+    for (const blind of pkg.blinds) {
+      const flasher = pkg.players[blind.flasherIndex];
+      const flashed = pkg.players[blind.flashedIndex];
+      if (!flasher || !flashed) continue;
+      const player = bySteamId.get(flasher.steamId64);
+      const key = `${player?.playerKey ?? `team:${flasher.teamKey}`}:${blind.flashId ?? `${blind.roundNumber}-${Math.round(blind.tick / 16)}`}`;
+      const cell = flashCells.get(key) ?? {
+        playerKey: player?.playerKey ?? "",
+        playerName: player?.name ?? flasher.name,
+        roundNumber: blind.roundNumber,
+        tick: blind.tick,
+        victims: new Set<string>(),
+        enemySeconds: 0,
+        teamSeconds: 0,
+      };
+      cell.tick = Math.min(cell.tick, blind.tick);
+      if (flasher.teamKey !== flashed.teamKey) {
+        cell.enemySeconds += blind.durationSeconds;
+        cell.victims.add(flashed.steamId64);
+      } else if (flasher.steamId64 !== flashed.steamId64) {
+        cell.teamSeconds += blind.durationSeconds;
+      }
+      flashCells.set(key, cell);
+    }
+    for (const cell of flashCells.values()) {
+      if (cell.enemySeconds <= 0 || !cell.playerKey) continue;
+      bestFlashes.push({
+        playerName: cell.playerName,
+        playerId: cell.playerKey,
+        matchId,
+        roundNumber: cell.roundNumber,
+        tick: cell.tick,
+        reason: "该闪光造成的敌方致盲时间位于当前样本前列",
+        role: "example",
+        victimCount: cell.victims.size,
+        enemySeconds: round(cell.enemySeconds, 2),
+        teamSeconds: round(cell.teamSeconds, 2),
+        netSeconds: round(cell.enemySeconds - cell.teamSeconds, 2),
+      });
+    }
+
+    for (const damage of pkg.damages) {
+      if (damage.attackerIndex == null) continue;
+      const attacker = pkg.players[damage.attackerIndex];
+      const victim = pkg.players[damage.victimIndex];
+      if (!attacker || !victim || attacker.teamKey === victim.teamKey) continue;
+      const kind: UtilityDamageKind | null = isHeDamageWeapon(damage.weapon) ? "he" : isFireDamageWeapon(damage.weapon) ? "fire" : null;
+      if (!kind || damage.healthDamage <= 0) continue;
+      const player = bySteamId.get(attacker.steamId64);
+      if (player) {
+        const bucket = kind === "he" ? Math.round(damage.tick / 16) : damage.roundNumber;
+        const key = `${kind}:${matchId}:${damage.roundNumber}:${player.playerKey}:${bucket}`;
+        const cell = damageEvidence.get(key) ?? {
+          kind,
+          matchId,
+          roundNumber: damage.roundNumber,
+          tick: damage.tick,
+          reason: `${kind === "he" ? "HE 手雷" : "火焰"}伤害事件位于当前样本前列`,
+          role: "example",
+          playerId: player.playerKey,
+          playerName: player.name,
+          victimCount: 0,
+          victims: new Set<string>(),
+          damage: 0,
+        };
+        cell.tick = Math.min(cell.tick ?? damage.tick, damage.tick);
+        cell.damage += damage.healthDamage;
+        cell.victims.add(victim.steamId64);
+        cell.victimCount = cell.victims.size;
+        damageEvidence.set(key, cell);
+      }
+    }
+  }
+
+  return {
+    players: [...playerRows.values()]
+      .map(finalizeUtilityRow)
+      .sort((a, b) => (b.heDamagePerRound ?? 0) + (b.fireDamagePerRound ?? 0) - ((a.heDamagePerRound ?? 0) + (a.fireDamagePerRound ?? 0))),
+    teams: [...teamRows.values()]
+      .map(finalizeUtilityRow)
+      .sort((a, b) => (b.heDamagePerRound ?? 0) + (b.fireDamagePerRound ?? 0) - ((a.heDamagePerRound ?? 0) + (a.fireDamagePerRound ?? 0))),
+    bestFlashes: bestFlashes.sort((a, b) => b.enemySeconds - a.enemySeconds).slice(0, MAX_BEST_FLASH),
+    bestDamageRounds: [...damageEvidence.values()]
+      .sort((a, b) => b.damage - a.damage)
+      .slice(0, MAX_EVIDENCE)
+      .map(({ victims: _victims, ...row }) => row),
+  };
+}
+
+function addUtilityRow(target: UtilityValueRow, source: UtilityValueRow): void {
+  target.rounds += source.rounds;
+  target.flashesThrown += source.flashesThrown;
+  target.enemyBlindSeconds += source.enemyBlindSecondsRaw ?? source.enemyBlindSeconds;
+  target.flashAssists += source.flashAssists ?? 0;
+  target.heThrows += source.heThrows;
+  target.heDamage += source.heDamage;
+  target.fireThrows += source.fireThrows;
+  target.fireDamage += source.fireDamage;
+  target.smokesThrown += source.smokesThrown;
+}
+
+function sortUtilityRows(rows: UtilityValueRow[]): UtilityValueRow[] {
+  return rows
+    .map(finalizeUtilityRow)
+    .sort((a, b) => (b.heDamagePerRound ?? 0) + (b.fireDamagePerRound ?? 0) - ((a.heDamagePerRound ?? 0) + (a.fireDamagePerRound ?? 0)));
+}
+
+export function mergeUtilityValueSummaries(
+  summaries: UtilityValueSummary[],
+  options: { players?: PlayerFlashSummaryInput[]; teamRenames?: Record<string, string> } = {}
+): UtilityValueSummary {
+  const playerRows = new Map<string, UtilityValueRow>();
+  const playerTargetBySource = new Map<string, PlayerFlashSummaryInput>();
+  if (options.players) {
+    for (const player of options.players) {
+      playerRows.set(player.playerKey, utilityRow(player.playerKey, player.name));
+      playerTargetBySource.set(player.playerKey, player);
+      for (const steamId of player.steamIds) playerTargetBySource.set(`steam:${steamId}`, player);
+    }
+  }
+  const teamRows = new Map<string, UtilityValueRow>();
+
+  const ensurePlayer = (row: UtilityValueRow): UtilityValueRow | null => {
+    const target = options.players ? playerTargetBySource.get(row.id) : { playerKey: row.id, name: row.name, steamIds: [] };
+    if (!target) return null;
+    const existing = playerRows.get(target.playerKey) ?? utilityRow(target.playerKey, target.name);
+    playerRows.set(target.playerKey, existing);
+    return existing;
+  };
+  const ensureTeam = (row: UtilityValueRow): UtilityValueRow => {
+    const name = options.teamRenames?.[row.name] ?? row.name;
+    const existing = teamRows.get(name) ?? utilityRow(name, name);
+    teamRows.set(name, existing);
+    return existing;
+  };
+
+  const keepPlayerEvidence = <T extends { playerId?: string; playerName: string }>(row: T): T | null => {
+    if (!options.players) return row;
+    const target = row.playerId ? playerTargetBySource.get(row.playerId) : null;
+    return target ? { ...row, playerId: target.playerKey, playerName: target.name } : null;
+  };
+
+  const bestFlashes: UtilityValueSummary["bestFlashes"] = [];
+  const bestDamageRounds: UtilityDamageEvidence[] = [];
+
+  for (const summary of summaries) {
+    for (const row of summary.players) {
+      const target = ensurePlayer(row);
+      if (target) addUtilityRow(target, row);
+    }
+    for (const row of summary.teams) addUtilityRow(ensureTeam(row), row);
+    for (const flash of summary.bestFlashes) {
+      const kept = keepPlayerEvidence(flash);
+      if (kept) bestFlashes.push(kept);
+    }
+    for (const damage of summary.bestDamageRounds) {
+      const kept = keepPlayerEvidence(damage);
+      if (kept) bestDamageRounds.push(kept);
+    }
+  }
+
+  return {
+    players: sortUtilityRows([...playerRows.values()]),
+    teams: sortUtilityRows([...teamRows.values()]),
+    bestFlashes: bestFlashes.sort((a, b) => b.enemySeconds - a.enemySeconds).slice(0, MAX_BEST_FLASH),
+    bestDamageRounds: bestDamageRounds.sort((a, b) => b.damage - a.damage).slice(0, MAX_EVIDENCE),
+  };
+}
+
+/** 单选手跨场洞察。steamIds 来自 PlayerSeasonProfile（cohort 已做身份归并）。 */
+export function buildPlayerSeasonInsights(
+  demos: SeasonInsightsDemo[],
+  steamIds: string[]
+): PlayerSeasonInsights {
+  const ids = new Set(steamIds);
+  const trend: PlayerTrendPoint[] = [];
+  let flashesThrown = 0;
+  let enemyBlindSeconds = 0;
+  let teamBlindSeconds = 0;
+  let flashAssists = 0;
+  let enemyBlindVictims = 0;
+  const teamFlashes: TeamFlashIncident[] = [];
+  const enemyFlashes: EnemyFlashIncident[] = [];
+  const lowBuy: FirstDeathStat = { count: 0, attempts: 0, evidence: [] };
+  const fullBuy: FirstDeathStat = { count: 0, attempts: 0, evidence: [] };
+  const antiEco: FirstDeathStat = { count: 0, attempts: 0, evidence: [] };
+  const deathTiming = { early: 0, mid: 0, late: 0, total: 0 };
+  const clutchLossEvidence: MistakeEvidence[] = [];
+  let clutchLosses = 0;
+
+  for (const { matchId, pkg } of demos) {
+    const stats = pkg.playerStats.filter((row) => {
+      const player = pkg.players[row.playerIndex];
+      return player != null && ids.has(player.steamId64);
+    });
+    if (stats.length === 0) continue;
+    const sum = (f: (row: (typeof stats)[number]) => number) => stats.reduce((acc, row) => acc + f(row), 0);
+    const rounds = Math.max(1, ...stats.map((row) => row.rounds));
+    const utilityFacts = buildPlayerRoundUtilityFacts(pkg).filter((fact) => ids.has(fact.steamId64));
+    const utilitySum = (key: "utilityDamage" | "enemyBlindSeconds" | "teamBlindSeconds" | "flashAssists" | "flashesThrown" | "enemyBlindVictims") =>
+      utilityFacts.reduce((total, fact) => total + fact[key], 0);
+
+    const clutchAttempts = sum((r) => r.vsOneCount + r.vsTwoCount + r.vsThreeCount + r.vsFourCount + r.vsFiveCount);
+    const clutchWins = sum((r) => r.vsOneWonCount + r.vsTwoWonCount + r.vsThreeWonCount + r.vsFourWonCount + r.vsFiveWonCount);
+    trend.push({
+      matchId,
+      mapName: pkg.match.mapName,
+      adr: round(sum((r) => r.damageHealth) / rounds, 1),
+      kast: round(sum((r) => r.kastRounds) / rounds * 100, 1),
+      fkMinusFd: sum((r) => r.firstKillCount) - sum((r) => r.firstDeathCount),
+      utilityDamagePerRound: round(utilitySum("utilityDamage") / rounds, 2),
+      clutchAttempts,
+      clutchWins,
+      kills: sum((r) => r.kills),
+      deaths: sum((r) => r.deaths)
+    });
+
+    enemyBlindSeconds += utilitySum("enemyBlindSeconds");
+    teamBlindSeconds += utilitySum("teamBlindSeconds");
+    flashAssists += utilitySum("flashAssists");
+    flashesThrown += utilitySum("flashesThrown");
+    enemyBlindVictims += utilitySum("enemyBlindVictims");
+
+    // 队闪事件：同 (round, tick±8) 的同投掷者致盲友方行归并为一颗闪
+    const teamBlindRows = pkg.blinds.filter((b) => {
+      const flasher = pkg.players[b.flasherIndex];
+      const flashed = pkg.players[b.flashedIndex];
+      return flasher != null && flashed != null && ids.has(flasher.steamId64)
+        && flasher.teamKey === flashed.teamKey && flasher.steamId64 !== flashed.steamId64;
+    });
+    const grouped = new Map<string, { roundNumber: number; tick: number; victims: Set<string>; seconds: number }>();
+    for (const blind of teamBlindRows) {
+      const key = blind.flashId ?? `${blind.roundNumber}-${Math.round(blind.tick / 16)}`;
+      const cell = grouped.get(key) ?? { roundNumber: blind.roundNumber, tick: blind.tick, victims: new Set(), seconds: 0 };
+      cell.tick = Math.min(cell.tick, blind.tick);
+      cell.victims.add(pkg.players[blind.flashedIndex]?.steamId64 ?? "");
+      cell.seconds += blind.durationSeconds;
+      grouped.set(key, cell);
+    }
+    for (const cell of grouped.values()) {
+      teamFlashes.push({
+        matchId,
+        roundNumber: cell.roundNumber,
+        tick: cell.tick,
+        reason: "该闪光误盲队友的时长位于当前样本前列",
+        role: "example",
+        victimCount: cell.victims.size,
+        totalSeconds: round(cell.seconds, 2)
+      });
+    }
+
+    // 致盲敌方事件：同 flashId 的本人致盲敌方行归并为一颗闪，并扣除同颗误盲队友秒数算净收益
+    const enemyBlindRows = pkg.blinds.filter((b) => {
+      const flasher = pkg.players[b.flasherIndex];
+      const flashed = pkg.players[b.flashedIndex];
+      return flasher != null && flashed != null && ids.has(flasher.steamId64)
+        && flasher.teamKey !== flashed.teamKey;
+    });
+    const enemyGrouped = new Map<string, { roundNumber: number; tick: number; victims: Set<string>; seconds: number }>();
+    for (const blind of enemyBlindRows) {
+      const key = blind.flashId ?? `${blind.roundNumber}-${Math.round(blind.tick / 16)}`;
+      const cell = enemyGrouped.get(key) ?? { roundNumber: blind.roundNumber, tick: blind.tick, victims: new Set(), seconds: 0 };
+      cell.tick = Math.min(cell.tick, blind.tick);
+      cell.victims.add(pkg.players[blind.flashedIndex]?.steamId64 ?? "");
+      cell.seconds += blind.durationSeconds;
+      enemyGrouped.set(key, cell);
+    }
+    for (const [key, cell] of enemyGrouped) {
+      const teamSeconds = grouped.get(key)?.seconds ?? 0;
+      enemyFlashes.push({
+        matchId,
+        roundNumber: cell.roundNumber,
+        tick: cell.tick,
+        reason: "该闪光造成的敌方致盲时间位于当前样本前列",
+        role: "example",
+        victimCount: cell.victims.size,
+        enemySeconds: round(cell.seconds, 2),
+        teamSeconds: round(teamSeconds, 2),
+        netSeconds: round(cell.seconds - teamSeconds, 2)
+      });
+    }
+
+    // 劣势经济首死：按回合首杀的受害者判定
+    const economyByRound = new Map(
+      pkg.playerEconomies
+        .filter((row) => {
+          const player = pkg.players[row.playerIndex];
+          return player != null && ids.has(player.steamId64);
+        })
+        .map((row) => [row.roundNumber, row.type])
+    );
+    const killsByRound = new Map<number, typeof pkg.kills>();
+    for (const kill of pkg.kills) {
+      const list = killsByRound.get(kill.roundNumber) ?? [];
+      list.push(kill);
+      killsByRound.set(kill.roundNumber, list);
+    }
+    const freezeByRound = new Map(pkg.rounds.map((row) => [row.roundNumber, row.freezeEndTick]));
+    const roundEconomies = new Map(
+      pkg.rounds.map((row) => [row.roundNumber, { a: row.teamAEconomy, b: row.teamBEconomy }])
+    );
+    const tickrate = tickrateOf(pkg);
+
+    for (const [roundNumber, list] of killsByRound) {
+      const sorted = [...list].sort((a, b) => a.tick - b.tick);
+      const economy = economyByRound.get(roundNumber);
+      // 对手经济：回合行里非我方类型的一侧（两侧相同时无歧义）
+      const pair = roundEconomies.get(roundNumber);
+      const opponentEconomy =
+        economy != null && pair != null ? (economy === pair.a ? pair.b : pair.a) : null;
+      const firstDeath = sorted[0];
+      const firstDeadVictim = firstDeath != null ? pkg.players[firstDeath.victimIndex] : undefined;
+      const meFirstDead = firstDeath != null && firstDeadVictim != null && ids.has(firstDeadVictim.steamId64);
+      const isLowBuy = economy != null && LOW_BUY_TYPES.has(economy);
+      const isFullBuy = economy === "full";
+      const isAntiEco = opponentEconomy === "eco" || opponentEconomy === "semi";
+      if (isLowBuy) lowBuy.attempts += 1;
+      if (isFullBuy) fullBuy.attempts += 1;
+      if (isAntiEco) antiEco.attempts += 1;
+      if (meFirstDead && isLowBuy) {
+        lowBuy.count += 1;
+        lowBuy.evidence.push({ matchId, roundNumber, tick: firstDeath.tick, detail: `${economy} 局首死`, reason: `${economy} 局首死`, role: "example" });
+      }
+      if (meFirstDead && isFullBuy) {
+        fullBuy.count += 1;
+        fullBuy.evidence.push({ matchId, roundNumber, tick: firstDeath.tick, detail: "长枪局首死", reason: "长枪局首死", role: "example" });
+      }
+      if (meFirstDead && isAntiEco) {
+        antiEco.count += 1;
+        antiEco.evidence.push({ matchId, roundNumber, tick: firstDeath.tick, detail: `对手 ${opponentEconomy} 局首死`, reason: `对手 ${opponentEconomy} 局首死`, role: "example" });
+      }
+      // 死亡时间分布
+      for (const kill of sorted) {
+        const victim = pkg.players[kill.victimIndex];
+        if (!victim || !ids.has(victim.steamId64)) continue;
+        const freeze = freezeByRound.get(roundNumber);
+        if (freeze == null) continue;
+        const seconds = (kill.tick - freeze) / tickrate;
+        deathTiming.total += 1;
+        if (seconds < DEATH_EARLY_SECONDS) deathTiming.early += 1;
+        else if (seconds < DEATH_LATE_SECONDS) deathTiming.mid += 1;
+        else deathTiming.late += 1;
+      }
+    }
+
+    // 残局失利
+    for (const clutch of pkg.clutches) {
+      const clutcher = pkg.players[clutch.clutcherIndex];
+      if (!clutcher || !ids.has(clutcher.steamId64) || clutch.won) continue;
+      clutchLosses += 1;
+      clutchLossEvidence.push({
+        matchId,
+        roundNumber: clutch.roundNumber,
+        detail: `1v${clutch.opponentCount} 失利（${clutch.killCount} 杀）`,
+        reason: `1v${clutch.opponentCount} 残局失利`,
+        role: "example"
+      });
+    }
+  }
+
+  teamFlashes.sort((a, b) => b.totalSeconds - a.totalSeconds);
+  enemyFlashes.sort((a, b) => b.enemySeconds - a.enemySeconds);
+
+  return {
+    trend,
+    flash: {
+      flashesThrown,
+      enemyBlindSeconds: round(enemyBlindSeconds, 1),
+      teamBlindSeconds: round(teamBlindSeconds, 1),
+      enemyBlindVictims,
+      enemySecondsPerFlash: flashesThrown > 0 ? round(enemyBlindSeconds / flashesThrown, 2) : null,
+      netSecondsPerFlash: flashesThrown > 0
+        ? round((enemyBlindSeconds - teamBlindSeconds) / flashesThrown, 2)
+        : null,
+      flashAssists,
+      worstTeamFlashes: teamFlashes.slice(0, MAX_EVIDENCE),
+      bestEnemyFlashes: enemyFlashes.slice(0, MAX_BEST_FLASH)
+    },
+    mistakes: {
+      lowBuyFirstDeaths: { ...lowBuy, evidence: lowBuy.evidence.slice(0, MAX_EVIDENCE) },
+      fullBuyFirstDeaths: { ...fullBuy, evidence: fullBuy.evidence.slice(0, MAX_EVIDENCE) },
+      antiEcoFirstDeaths: { ...antiEco, evidence: antiEco.evidence.slice(0, MAX_EVIDENCE) },
+      deathTiming,
+      clutchLosses: { count: clutchLosses, evidence: clutchLossEvidence.slice(0, MAX_EVIDENCE) }
+    }
+  };
+}
+
+function avg(values: Array<number | null>): number | null {
+  const nums = values.filter((value): value is number => value != null);
+  return nums.length > 0 ? round(nums.reduce((sum, value) => sum + value, 0) / nums.length, 1) : null;
+}
+
+function medianNumber(values: Array<number | null>): number | null {
+  const nums = values.filter((value): value is number => value != null).sort((a, b) => a - b);
+  if (nums.length === 0) return null;
+  const mid = Math.floor(nums.length / 2);
+  return nums.length % 2 === 0 ? round((nums[mid - 1]! + nums[mid]!) / 2, 1) : round(nums[mid]!, 1);
+}
+
+function percentileLabel(value: number | null, values: Array<number | null>, lowerIsBetter = false): string | null {
+  if (value == null) return null;
+  const nums = values.filter((candidate): candidate is number => candidate != null);
+  if (nums.length === 0) return null;
+  const better = nums.filter((candidate) => lowerIsBetter ? candidate <= value : candidate >= value).length;
+  return `当前范围前 ${Math.max(1, Math.round(better / nums.length * 100))}%`;
+}
+
+// 武器卡按真实武器名统计（区分 m4a1_silencer / m4a4），展示层取击杀数前 6，其余并入「其他」
+const MECHANICS_TOP_WEAPONS = 6;
+
+function weaponBucket(weapon: string): string {
+  return weapon.toLowerCase();
+}
+
+function weaponBucketLabel(bucket: string): string {
+  if (bucket === "all") return "全部武器";
+  if (bucket === "other") return "其他";
+  return displayWeaponName(bucket);
+}
+
+export interface MechanicsProfileOptions {
+  /** 按地图名提供 .tri BVH；提供后枪法机制的可见性样本走静态 LOS 精确口径。 */
+  visibilityFor?: (mapName: string) => TriangleBvh | null;
+}
+
+export function buildPlayerMechanicsProfile(
+  demos: SeasonInsightsDemo[],
+  steamIds: string[],
+  options: MechanicsProfileOptions = {}
+): PlayerMechanicsProfile {
+  const perMatchRows = demos.map(({ pkg }) =>
+    derivePlayerMechanics(pkg, { visibility: options.visibilityFor?.(pkg.match.mapName) ?? null })
+  );
+  return buildPlayerMechanicsProfileFromRows(perMatchRows, steamIds, demos.length);
+}
+
+/**
+ * 跨场机制合并（投影层）：吃预派生的逐场 PlayerMechanicsFact[]，与
+ * buildPlayerMechanicsProfile 共用同一套分桶 / 百分位口径。facts 缓存命中后
+ * 无需重新解析 DemoPackage，是 SQLite/facts 方案下选手档案的聚合入口。
+ */
+export function buildPlayerMechanicsProfileFromRows(
+  perMatchRows: PlayerMechanicsFact[][],
+  steamIds: string[],
+  matchCount: number
+): PlayerMechanicsProfile {
+  const ids = new Set(steamIds);
+  const byBucket = new Map<string, {
+    kills: number;
+    first: Array<number | null>;
+    spray: Array<number | null>;
+    counter: Array<number | null>;
+    oneTap: Array<number | null>;
+    reaction: Array<number | null>;
+    preaim: Array<number | null>;
+    ttk: Array<number | null>;
+    headshot: number;
+    headshotTotal: number;
+  }>();
+  const allRows: Array<{ bucket: string; first: number | null; spray: number | null; counter: number | null; oneTap: number | null; reaction: number | null; preaim: number | null; ttk: number | null }> = [];
+
+  const get = (bucket: string) => {
+    const current = byBucket.get(bucket) ?? { kills: 0, first: [], spray: [], counter: [], oneTap: [], reaction: [], preaim: [], ttk: [], headshot: 0, headshotTotal: 0 };
+    byBucket.set(bucket, current);
+    return current;
+  };
+
+  for (const rows of perMatchRows) {
+    for (const row of rows.filter((item) => ids.has(item.steamId64))) {
+      const bucket = weaponBucket(row.weapon);
+      const cell = get(bucket);
+      const preaim = row.preaim.medianDegrees;
+      cell.kills += row.killCount;
+      cell.headshot += row.cleanHeadshotKills;
+      cell.headshotTotal += row.cleanKillCount;
+      cell.first.push(row.firstShotHit.value);
+      cell.spray.push(row.sprayHit?.value ?? null);
+      cell.counter.push(row.counterStrafe.value);
+      cell.oneTap.push(row.oneTap.value);
+      cell.reaction.push(row.reaction.value);
+      cell.preaim.push(preaim);
+      cell.ttk.push(...row.ttkSamplesMs);
+      allRows.push({
+        bucket,
+        first: row.firstShotHit.value,
+        spray: row.sprayHit?.value ?? null,
+        counter: row.counterStrafe.value,
+        oneTap: row.oneTap.value,
+        reaction: row.reaction.value,
+        preaim,
+        ttk: row.ttk.value
+      });
+    }
+  }
+
+  const toProfile = (bucket: string, cell: ReturnType<typeof get>): PlayerMechanicsWeaponProfile => {
+    const first = avg(cell.first);
+    const spray = avg(cell.spray);
+    const ttk = medianNumber(cell.ttk);
+    const counter = avg(cell.counter);
+    const oneTap = avg(cell.oneTap);
+    const reaction = medianNumber(cell.reaction);
+    const preaim = medianNumber(cell.preaim);
+    return {
+      weapon: bucket,
+      label: weaponBucketLabel(bucket),
+      kills: cell.kills,
+      firstShotAccuracyPercent: first,
+      sprayAccuracyPercent: spray,
+      medianTtkMs: ttk,
+      counterStrafeSuccessPercent: counter,
+      oneTapRatePercent: oneTap,
+      visualReactionMs: reaction,
+      preaimErrorDegrees: preaim,
+      headshotPercent: cell.headshotTotal > 0 ? Math.round((cell.headshot / cell.headshotTotal) * 1000) / 10 : null,
+      killsPerMatch: matchCount > 0 ? Math.round((cell.kills / matchCount) * 10) / 10 : null,
+      percentile: {
+        firstShotAccuracy: percentileLabel(first, allRows.map((row) => row.first)),
+        sprayAccuracy: percentileLabel(spray, allRows.map((row) => row.spray)),
+        medianTtk: percentileLabel(ttk, allRows.map((row) => row.ttk), true),
+        counterStrafe: percentileLabel(counter, allRows.map((row) => row.counter)),
+        oneTapRate: percentileLabel(oneTap, allRows.map((row) => row.oneTap)),
+        visualReaction: percentileLabel(reaction, allRows.map((row) => row.reaction), true),
+        preaimError: percentileLabel(preaim, allRows.map((row) => row.preaim), true)
+      }
+    };
+  };
+
+  const overall = toProfile("all", {
+    kills: [...byBucket.values()].reduce((sum, row) => sum + row.kills, 0),
+    first: [...byBucket.values()].flatMap((row) => row.first),
+    spray: [...byBucket.values()].flatMap((row) => row.spray),
+    counter: [...byBucket.values()].flatMap((row) => row.counter),
+    oneTap: [...byBucket.values()].flatMap((row) => row.oneTap),
+    reaction: [...byBucket.values()].flatMap((row) => row.reaction),
+    preaim: [...byBucket.values()].flatMap((row) => row.preaim),
+    ttk: [...byBucket.values()].flatMap((row) => row.ttk),
+    headshot: [...byBucket.values()].reduce((sum, row) => sum + row.headshot, 0),
+    headshotTotal: [...byBucket.values()].reduce((sum, row) => sum + row.headshotTotal, 0)
+  });
+  // 击杀数前 6 把武器单列，其余合并为「其他」（样本数组直接拼接，口径与单桶一致）
+  const ranked = [...byBucket.entries()].sort((a, b) => b[1].kills - a[1].kills || a[0].localeCompare(b[0]));
+  const top = ranked.slice(0, MECHANICS_TOP_WEAPONS);
+  const rest = ranked.slice(MECHANICS_TOP_WEAPONS);
+  const weapons = top.map(([bucket, cell]) => toProfile(bucket, cell));
+  if (rest.length > 0) {
+    weapons.push(toProfile("other", {
+      kills: rest.reduce((sum, [, cell]) => sum + cell.kills, 0),
+      first: rest.flatMap(([, cell]) => cell.first),
+      spray: rest.flatMap(([, cell]) => cell.spray),
+      counter: rest.flatMap(([, cell]) => cell.counter),
+      oneTap: rest.flatMap(([, cell]) => cell.oneTap),
+      reaction: rest.flatMap(([, cell]) => cell.reaction),
+      preaim: rest.flatMap(([, cell]) => cell.preaim),
+      ttk: rest.flatMap(([, cell]) => cell.ttk),
+      headshot: rest.reduce((sum, [, cell]) => sum + cell.headshot, 0),
+      headshotTotal: rest.reduce((sum, [, cell]) => sum + cell.headshotTotal, 0)
+    }));
+  }
+  return { overall, weapons };
+}
+
+export function buildPlayerWeaponStats(
+  demos: SeasonInsightsDemo[],
+  steamIds: string[]
+): PlayerWeaponStat[] {
+  const ids = new Set(steamIds);
+  const rows = new Map<string, { weapon: string; kills: number; headshots: number }>();
+  let matchCount = 0;
+  for (const { pkg } of demos) {
+    let appeared = false;
+    for (const kill of pkg.kills) {
+      if (kill.killerIndex == null) continue;
+      const killer = pkg.players[kill.killerIndex];
+      if (!killer || !ids.has(killer.steamId64)) continue;
+      appeared = true;
+      const weapon = kill.weapon || "unknown";
+      const row = rows.get(weapon) ?? { weapon, kills: 0, headshots: 0 };
+      row.kills += 1;
+      if (kill.headshot) row.headshots += 1;
+      rows.set(weapon, row);
+    }
+    if (appeared) matchCount += 1;
+  }
+  const denominator = Math.max(1, matchCount);
+  return [...rows.values()]
+    .map((row) => ({
+      weapon: row.weapon,
+      label: displayWeaponName(row.weapon),
+      kills: row.kills,
+      headshotPercent: row.kills > 0 ? round((row.headshots / row.kills) * 100, 1) : null,
+      killsPerMatch: round(row.kills / denominator, 2)
+    }))
+    .sort((a, b) => b.kills - a.kills || a.label.localeCompare(b.label));
+}
+
+export function buildPlayerFlashSummaries(
+  demos: SeasonInsightsDemo[],
+  players: PlayerFlashSummaryInput[]
+): PlayerFlashSummary[] {
+  const bySteamId = new Map<string, PlayerFlashSummaryInput>();
+  const rows = new Map<string, {
+    playerKey: string;
+    name: string;
+    flashesThrown: number;
+    enemyBlindSeconds: number;
+    teamBlindSeconds: number;
+    enemyBlindVictims: number;
+    flashAssists: number;
+    teamFlashes: TeamFlashIncident[];
+    enemyFlashes: EnemyFlashIncident[];
+  }>();
+
+  for (const player of players) {
+    rows.set(player.playerKey, {
+      playerKey: player.playerKey,
+      name: player.name,
+      flashesThrown: 0,
+      enemyBlindSeconds: 0,
+      teamBlindSeconds: 0,
+      enemyBlindVictims: 0,
+      flashAssists: 0,
+      teamFlashes: [],
+      enemyFlashes: []
+    });
+    for (const steamId of player.steamIds) bySteamId.set(steamId, player);
+  }
+
+  for (const { matchId, pkg } of demos) {
+    for (const utility of buildPlayerRoundUtilityFacts(pkg)) {
+      const player = bySteamId.get(utility.steamId64);
+      if (!player) continue;
+      const row = rows.get(player.playerKey)!;
+      row.flashesThrown += utility.flashesThrown;
+      row.enemyBlindSeconds += utility.enemyBlindSeconds;
+      row.teamBlindSeconds += utility.teamBlindSeconds;
+      row.enemyBlindVictims += utility.enemyBlindVictims;
+      row.flashAssists += utility.flashAssists;
+    }
+
+    type FlashCell = { playerKey: string; roundNumber: number; tick: number; victims: Set<string>; seconds: number };
+    const grouped = new Map<string, FlashCell>();
+    const enemyGrouped = new Map<string, FlashCell>();
+    for (const blind of pkg.blinds) {
+      const flasher = pkg.players[blind.flasherIndex];
+      const flashed = pkg.players[blind.flashedIndex];
+      if (!flasher || !flashed) continue;
+      const player = bySteamId.get(flasher.steamId64);
+      if (!player) continue;
+      const key = `${player.playerKey}:${blind.flashId ?? `${blind.roundNumber}-${Math.round(blind.tick / 16)}`}`;
+      const accumulate = (map: Map<string, FlashCell>) => {
+        const cell = map.get(key) ?? {
+          playerKey: player.playerKey,
+          roundNumber: blind.roundNumber,
+          tick: blind.tick,
+          victims: new Set<string>(),
+          seconds: 0
+        };
+        cell.tick = Math.min(cell.tick, blind.tick);
+        cell.victims.add(pkg.players[blind.flashedIndex]?.steamId64 ?? "");
+        cell.seconds += blind.durationSeconds;
+        map.set(key, cell);
+      };
+      if (flasher.teamKey !== flashed.teamKey) {
+        accumulate(enemyGrouped);
+        continue;
+      }
+      if (flasher.steamId64 === flashed.steamId64) continue;
+      accumulate(grouped);
+    }
+    for (const cell of grouped.values()) {
+      rows.get(cell.playerKey)!.teamFlashes.push({
+        matchId,
+        roundNumber: cell.roundNumber,
+        tick: cell.tick,
+        reason: "该闪光误盲队友的时长位于当前样本前列",
+        role: "example",
+        victimCount: cell.victims.size,
+        totalSeconds: round(cell.seconds, 2)
+      });
+    }
+    for (const [key, cell] of enemyGrouped) {
+      const teamSeconds = grouped.get(key)?.seconds ?? 0;
+      rows.get(cell.playerKey)!.enemyFlashes.push({
+        matchId,
+        roundNumber: cell.roundNumber,
+        tick: cell.tick,
+        reason: "该闪光造成的敌方致盲时间位于当前样本前列",
+        role: "example",
+        victimCount: cell.victims.size,
+        enemySeconds: round(cell.seconds, 2),
+        teamSeconds: round(teamSeconds, 2),
+        netSeconds: round(cell.seconds - teamSeconds, 2)
+      });
+    }
+  }
+
+  return [...rows.values()].map((row) => {
+    row.teamFlashes.sort((a, b) => b.totalSeconds - a.totalSeconds);
+    row.enemyFlashes.sort((a, b) => b.enemySeconds - a.enemySeconds);
+    return {
+      playerKey: row.playerKey,
+      name: row.name,
+      flashesThrown: row.flashesThrown,
+      enemyBlindSeconds: round(row.enemyBlindSeconds, 1),
+      teamBlindSeconds: round(row.teamBlindSeconds, 1),
+      enemyBlindVictims: row.enemyBlindVictims,
+      enemySecondsPerFlash: row.flashesThrown > 0 ? round(row.enemyBlindSeconds / row.flashesThrown, 2) : null,
+      netSecondsPerFlash: row.flashesThrown > 0
+        ? round((row.enemyBlindSeconds - row.teamBlindSeconds) / row.flashesThrown, 2)
+        : null,
+      flashAssists: row.flashAssists,
+      worstTeamFlashes: row.teamFlashes.slice(0, MAX_EVIDENCE),
+      bestEnemyFlashes: row.enemyFlashes.slice(0, MAX_BEST_FLASH)
+    };
+  });
+}
+
+// ── Buy Quality（单场，比赛工作台经济页用）──────────────────────────────────
+
+export interface BuyQualityRow {
+  economy: string;
+  label: string;
+  rounds: number;
+  wins: number;
+  winRatePercent: number | null;
+}
+
+export interface MatchBuyQuality {
+  teamA: BuyQualityRow[];
+  teamB: BuyQualityRow[];
+  /** 手枪局之后一回合（conversion）的胜率。 */
+  conversion: { teamA: { rounds: number; wins: number }; teamB: { rounds: number; wins: number } };
+}
+
+const ECONOMY_ORDER = ["pistol", "eco", "semi", "force", "full"] as const;
+const ECONOMY_LABEL: Record<string, string> = {
+  pistol: "手枪局",
+  eco: "Eco",
+  semi: "半起",
+  force: "强起",
+  full: "长枪局"
+};
+
+export function buildMatchBuyQuality(economy: MatchWorkspaceModel["economy"]): MatchBuyQuality {
+  const rowsFor = (teamKey: "teamA" | "teamB"): BuyQualityRow[] =>
+    ECONOMY_ORDER.map((type) => {
+      const rounds = economy.filter((p) => (teamKey === "teamA" ? p.teamAEconomy : p.teamBEconomy) === type);
+      const wins = rounds.filter((p) => p.winnerTeamKey === teamKey).length;
+      return {
+        economy: type,
+        label: ECONOMY_LABEL[type],
+        rounds: rounds.length,
+        wins,
+        winRatePercent: rounds.length > 0 ? round((wins / rounds.length) * 100, 1) : null
+      };
+    }).filter((row) => row.rounds > 0);
+
+  const conversionFor = (teamKey: "teamA" | "teamB") => {
+    const ordered = [...economy].sort((a, b) => a.roundNumber - b.roundNumber);
+    let rounds = 0;
+    let wins = 0;
+    for (let i = 0; i < ordered.length - 1; i += 1) {
+      const cur = ordered[i]!;
+      const isPistol = (teamKey === "teamA" ? cur.teamAEconomy : cur.teamBEconomy) === "pistol";
+      if (!isPistol || cur.winnerTeamKey !== teamKey) continue;
+      rounds += 1;
+      if (ordered[i + 1]!.winnerTeamKey === teamKey) wins += 1;
+    }
+    return { rounds, wins };
+  };
+
+  return {
+    teamA: rowsFor("teamA"),
+    teamB: rowsFor("teamB"),
+    conversion: { teamA: conversionFor("teamA"), teamB: conversionFor("teamB") }
+  };
+}
+
+// ── 赛事报表（Markdown）─────────────────────────────────────────────────────
+
+/** 单场比赛报告：half-by-half、关键回合、记分板。给主办方发布用。 */
+export function buildMatchReportMarkdown(model: MatchWorkspaceModel): string {
+  const lines: string[] = [];
+  lines.push(`# ${model.title}`);
+  lines.push("");
+  lines.push(`**${model.mapName}** · 比分 **${model.scoreline}**`);
+  lines.push("");
+  for (const beat of model.overview.story) {
+    lines.push(`> ${beat}`);
+  }
+  lines.push("");
+  lines.push("## 记分板");
+  lines.push("");
+  lines.push("| 选手 | 队伍 | K/D/A | ADR | KAST | RR |");
+  lines.push("|---|---|---|---|---|---|");
+  for (const row of model.scoreboard) {
+    const teamName = row.teamKey === "teamA" ? model.teams.teamA.name : model.teams.teamB.name;
+    lines.push(
+      `| ${row.name} | ${teamName} | ${row.kills}/${row.deaths}/${row.assists} | ${row.adr.toFixed(1)} | ${row.kast.toFixed(1)}% | ${row.accountRR.toFixed(2)} |`
+    );
+  }
+  lines.push("");
+  lines.push("## 关键回合");
+  lines.push("");
+  const keyRounds = model.rounds.filter(
+    (row) => row.facets && (row.facets.clutch || row.facets.maxKillsByOnePlayer >= 3)
+  );
+  if (keyRounds.length === 0) {
+    lines.push("（本场无 3+ 多杀或残局回合）");
+  }
+  for (const row of keyRounds) {
+    const tags: string[] = [];
+    if (row.facets?.clutch) {
+      tags.push(`1v${row.facets.clutch.opponentCount} 残局${row.facets.clutch.won ? "成功" : "失败"}`);
+    }
+    if ((row.facets?.maxKillsByOnePlayer ?? 0) >= 3) {
+      tags.push(`${row.facets!.maxKillsByOnePlayer} 杀回合`);
+    }
+    lines.push(`- **R${row.roundNumber}**（${row.scoreBefore}，${row.winnerSide.toUpperCase()} 胜）：${tags.join("、")}`);
+  }
+  lines.push("");
+  lines.push("## 经济与回合");
+  lines.push("");
+  lines.push("| 回合 | 比分 | 胜方 | A 队经济 | B 队经济 | 结束方式 |");
+  lines.push("|---|---|---|---|---|---|");
+  for (const row of model.rounds) {
+    lines.push(
+      `| R${row.roundNumber} | ${row.scoreBefore} | ${row.winnerSide.toUpperCase()} | ${row.teamAEconomy} | ${row.teamBEconomy} | ${row.endReason} |`
+    );
+  }
+  lines.push("");
+  lines.push(`---\n由 DAK Studio 生成 · cs2-demo-analysis-kit`);
+  return lines.join("\n");
+}