@cs2dak/presentation 1.0.0 → 2.0.0

package/src/season-validation.test.ts

@@ -6,6 +6,7 @@
 import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import JSZip from "jszip";
 import { describe, expect, it } from "vitest";
 import { loadDemoPackageFromZip } from "@cs2dak/core";
 import { buildSeasonCohort } from "@cs2dak/cohort";
@@ -13,8 +14,12 @@ import { buildSeasonLeaderboardModel, buildAllPlayerSeasonProfiles } from "./ind
 
 const ZIP_DIR = fileURLToPath(new URL("../../../fixtures/output/nju-rivals-2026", import.meta.url));
 const REPORT_FILE = fileURLToPath(new URL("../../../fixtures/output/_c-phase-report.txt", import.meta.url));
-const integrationTimeoutMs = 120_000;
+const integrationTimeoutMs = 180_000;
 const reportLines: string[] = [];
+type SeasonDemoInput = {
+  matchId: string;
+  pkg: Awaited<ReturnType<typeof loadDemoPackageFromZip>>;
+};
 
 function report(msg: string) {
   reportLines.push(msg);
@@ -32,13 +37,24 @@ async function dirExists(path: string): Promise<boolean> {
 
 async function njuCohort() {
   const names = (await readdir(ZIP_DIR)).filter((n) => n.endsWith(".zip")).sort();
-  const demos = await Promise.all(
-    names.map(async (name) => ({
-      matchId: name.replace(/\.zip$/, ""),
-      pkg: await loadDemoPackageFromZip(await readFile(join(ZIP_DIR, name)))
-    }))
-  );
-  return { bundle: buildSeasonCohort(demos), matchCount: names.length };
+  const demos: SeasonDemoInput[] = (
+    await Promise.all(
+      names.map(async (name) => {
+        const buf = await readFile(join(ZIP_DIR, name));
+        // 跳过旧版 ZIP（需要 cs2df 重导为 v3 后方可加载）
+        try {
+          const zip = await JSZip.loadAsync(buf);
+          const manifest = JSON.parse(await zip.file("manifest.json")!.async("string"));
+          if (!manifest?.schemaVersion?.startsWith("cs2-demo-format/3.")) return null;
+        } catch { return null; }
+        return {
+          matchId: name.replace(/\.zip$/, ""),
+          pkg: await loadDemoPackageFromZip(buf),
+        };
+      })
+    )
+  ).filter((demo): demo is SeasonDemoInput => demo !== null);
+  return { bundle: buildSeasonCohort(demos), matchCount: demos.length };
 }
 
 describe("55-ZIP season verification", () => {
@@ -50,6 +66,10 @@ describe("55-ZIP season verification", () => {
         return;
       }
       const { bundle, matchCount } = await njuCohort();
+      if (matchCount < 50) {
+        report(`v3 ZIP 数量不足（${matchCount}/50），跳过 55 场验证（需用 cs2df 重导所有 demo）`);
+        return;
+      }
       expect(matchCount).toBeGreaterThanOrEqual(50);
       expect(bundle.players.length).toBeGreaterThan(30);
 

package/src/series.test.ts

@@ -2,33 +2,17 @@ import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { describe, expect, it } from "vitest";
 import { loadDemoPackageFromZip } from "@cs2dak/core";
-import { mvpRecommendationSchema, seriesSummarySchema } from "@cs2dak/contract";
-import { buildMatchWorkspaceModel, buildSeriesSummary, recommendMatchMvp } from "./index";
+import { seriesSummarySchema } from "@cs2dak/contract";
+import { buildMatchWorkspaceModel, buildSeriesSummary } from "./index";
 
-async function buildWorkspace() {
-  const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
+const workspaceFixture = (async () => {
+  const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/sample-2026-05-17_de_ancient_Team_Spirit_13-10_Team_Falcons.zip", import.meta.url)));
   return buildMatchWorkspaceModel(await loadDemoPackageFromZip(zip));
-}
-
-describe("recommendMatchMvp", () => {
-  it("ranks candidates from accountRR, HLTV Rating 2.0 and confidence", async () => {
-    const model = await buildWorkspace();
-    const recommendation = recommendMatchMvp(model);
-
-    expect(() => mvpRecommendationSchema.parse(recommendation)).not.toThrow();
-    expect(recommendation.candidates.length).toBeGreaterThan(0);
-    expect(recommendation.recommended.playerKey).toBe(recommendation.candidates[0]?.playerKey);
-    expect(recommendation.candidates.map((row) => row.recommendationScore)).toEqual(
-      [...recommendation.candidates.map((row) => row.recommendationScore)].sort((a, b) => b - a)
-    );
-    expect(recommendation.recommended.explanation).toHaveLength(3);
-    expect(recommendation).not.toHaveProperty("winnerUserId");
-  });
-});
+})();
 
 describe("buildSeriesSummary", () => {
   it("aggregates counts and round-weighted rates across maps", async () => {
-    const model = await buildWorkspace();
+    const model = await workspaceFixture;
     const summary = buildSeriesSummary([
       { matchId: "map-1", model },
       { matchId: "map-2", model }
@@ -55,7 +39,7 @@ describe("buildSeriesSummary", () => {
   });
 
   it("accepts an external team map instead of owning team identity", async () => {
-    const model = await buildWorkspace();
+    const model = await workspaceFixture;
     const renamed = {
       ...model,
       teams: {

package/src/series.ts

@@ -1,9 +1,7 @@
 import {
-  mvpRecommendationSchema,
   seriesSummarySchema,
   type MatchWorkspaceModel,
   type MvpCandidate,
-  type MvpRecommendation,
   type SeriesMatchInput,
   type SeriesPlayerRow,
   type SeriesSummary
@@ -48,23 +46,6 @@ function rankMvpCandidates(sources: MvpSource[]): MvpCandidate[] {
     .slice(0, MVP_CANDIDATE_LIMIT);
 }
 
-export function recommendMatchMvp(model: MatchWorkspaceModel): MvpRecommendation {
-  const candidates = rankMvpCandidates(model.scoreboard.map((row) => ({
-    playerKey: row.steamId64,
-    name: row.name,
-    teamName: model.teams[row.teamKey].name,
-    rivalhubRR: row.accountRR,
-    hltvRating: row.rr,
-    confidence: row.confidence
-  })));
-  if (candidates.length === 0) throw new Error("match MVP recommendation requires at least one player");
-  return mvpRecommendationSchema.parse({
-    version: "cs2-demo-analysis-kit/mvp-recommendation-0.1",
-    recommended: candidates[0],
-    candidates
-  });
-}
-
 interface SeriesAccumulator {
   playerKey: string;
   name: string;

package/src/tactical-labels.ts

@@ -0,0 +1,80 @@
+import { calloutCn, entryRouteCn, SITE_ENTRY_SEMANTICS, DEFAULT_POSITION_GROUPS } from "@cs2dak/maps";
+
+export type EconomyEntry = "pistol" | "gun" | "anti_eco" | "force" | "semi" | "eco";
+
+export interface TacticalClusterLabelInput {
+  mapName: string;
+  side: "t" | "ct";
+  economyEntry: EconomyEntry;
+  openingIntent: {
+    regionCounts: { a: number; b: number; mid: number; unknown: number };
+    spread: string;
+  };
+  positionGroupCounts: Readonly<Record<string, number>>;
+}
+
+export const ECONOMY_ENTRY_CN: Record<EconomyEntry, string> = {
+  pistol: "手枪局",
+  gun: "长枪局",
+  anti_eco: "Anti-eco",
+  force: "强起",
+  semi: "半起",
+  eco: "Eco",
+};
+
+export function sideLabel(side: string): string {
+  return side === "t" ? "进攻方" : "防守方";
+}
+
+function chokeCn(mapName: string, chokeId: string): string {
+  const def = SITE_ENTRY_SEMANTICS[mapName]?.entries.find((entry) => entry.id === chokeId);
+  for (const callout of def?.entryCallouts ?? []) {
+    const cn = calloutCn(mapName, callout);
+    if (cn) return cn;
+  }
+  return chokeId;
+}
+
+function structuralEntryName(mapName: string, combo: string): string {
+  const ids = combo.split("+");
+  const names = ids.map((id) => chokeCn(mapName, id));
+  if (ids.length === 1) return names[0]!;
+  return names.join(" + ");
+}
+
+/** 进点路线只用于 evidence 文案；词典不会参与主簇命名。 */
+export function formatEntryEvidenceLabel(mapName: string, site: "a" | "b", combo: string): string {
+  return entryRouteCn(mapName, site, combo) || structuralEntryName(mapName, combo);
+}
+
+/** 兼容旧展示调用；不得将此函数用于主簇名称。 */
+export function formatEntryTacticName(mapName: string, site: "a" | "b", combo: string | null): string {
+  return combo ? formatEntryEvidenceLabel(mapName, site, combo) : `${site.toUpperCase()} 点进点`;
+}
+
+function formationLabel(input: TacticalClusterLabelInput): string {
+  const { a, mid, b } = input.openingIntent.regionCounts;
+  return `${a}A-${mid}中-${b}B`;
+}
+
+function positionGroupLabels(input: TacticalClusterLabelInput): string[] {
+  const groups = DEFAULT_POSITION_GROUPS[input.mapName]?.[input.side].groups ?? {};
+  return Object.entries(input.positionGroupCounts)
+    .filter(([, count]) => count > 0)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([id, count]) => `${groups[id]?.name ?? id}×${count}`);
+}
+
+/** 左栏短名显式保留 formation，禁止用字符串 regex 截断完整名称。 */
+export function formatTacticalClusterShortName(cluster: TacticalClusterLabelInput): string {
+  const groups = positionGroupLabels(cluster);
+  const structure = groups.length > 0 ? groups.join(" / ") : formationLabel(cluster);
+  return `${formationLabel(cluster)} · ${structure}`;
+}
+
+/** 主簇名只描述已审核的默认位资产与真实开局人数结构。 */
+export function formatTacticalClusterName(cluster: TacticalClusterLabelInput): string {
+  const econ = ECONOMY_ENTRY_CN[cluster.economyEntry];
+  const side = cluster.side === "ct" ? "CT " : "";
+  return `${side}${econ} · ${formatTacticalClusterShortName(cluster)}`;
+}

package/src/team.test.ts

@@ -1,77 +1,29 @@
-import { readFile, readdir } from "node:fs/promises";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { describe, expect, it } from "vitest";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
 import { loadDemoPackageFromZip } from "@cs2dak/core";
-import { buildSeasonCohort } from "@cs2dak/cohort";
-import { teamCohortSummarySchema } from "@cs2dak/contract";
-import { buildTeamCohortSummary } from "./index";
-
-const fixtureDir = fileURLToPath(new URL("../../../fixtures/input/cohort", import.meta.url));
-const integrationTimeoutMs = 20_000;
-let cohortFixtures: ReturnType<typeof buildCohort> | null = null;
+import { buildTeamComparison, buildTeamComparisonFromFacts, buildTeamOverviewFromFacts, extractTeamComparisonFacts } from "./index";
 
-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)))
-    }))
+async function loadFixture() {
+  const zip = await readFile(
+    fileURLToPath(new URL("../../../fixtures/input/sample-2026-05-17_de_ancient_Team_Spirit_13-10_Team_Falcons.zip", import.meta.url))
   );
-  return buildSeasonCohort(demos);
+  return loadDemoPackageFromZip(zip);
 }
 
-function getCohort() {
-  cohortFixtures ??= buildCohort();
-  return cohortFixtures;
-}
+describe("buildTeamComparison", () => {
+  it("builds the same model from persisted comparison facts", async () => {
+    const pkg = await loadFixture();
+    const inputs = [{ matchId: "m1", pkg }];
 
-describe("buildTeamCohortSummary", () => {
-  it(
-    "builds a product-neutral team summary from an externally supplied roster",
-    async () => {
-      const bundle = await getCohort();
-      const roster = bundle.players.slice(0, 5);
-      const summary = buildTeamCohortSummary(bundle, {
-        teamKey: "rivals-alpha",
-        name: "Rivals Alpha",
-        playerKeys: roster.map((player) => player.playerKey)
-      });
+    expect(buildTeamComparisonFromFacts(inputs.map(extractTeamComparisonFacts))).toEqual(buildTeamComparison(inputs));
+  });
 
-      expect(() => teamCohortSummarySchema.parse(summary)).not.toThrow();
-      expect(summary.teamKey).toBe("rivals-alpha");
-      expect(summary.name).toBe("Rivals Alpha");
-      expect(summary.members).toHaveLength(5);
-      expect(summary.coreMembers).toHaveLength(5);
-      expect(summary.averages.rivalhubRR).toBeCloseTo(
-        roster.reduce((sum, player) => sum + player.accountRR, 0) / roster.length,
-        2
-      );
-      expect(summary.leaders.map((leader) => leader.metric)).toEqual([
-        "rivalhubRR",
-        "adr",
-        "kast",
-        "firstKillPer100"
-      ]);
-      expect(summary.performance.firstKills).toBeGreaterThanOrEqual(0);
-      expect(summary.performance.firstDeaths).toBeGreaterThanOrEqual(0);
-      expect(summary.performance.openingDuelWinRate).toBeGreaterThanOrEqual(0);
-      expect(summary.performance.clutchAttempts).toBeGreaterThanOrEqual(summary.performance.clutchWins);
-      expect(summary.roleComplementarity.coverageScore).toBeGreaterThanOrEqual(0);
-      expect(summary.roleComplementarity.coverageScore).toBeLessThanOrEqual(100);
-      expect(summary).not.toHaveProperty("userId");
-    },
-    integrationTimeoutMs
-  );
+  it("builds a descriptive overview for one team from persisted facts", async () => {
+    const pkg = await loadFixture();
+    const overview = buildTeamOverviewFromFacts([extractTeamComparisonFacts({ matchId: "m1", pkg })], "Team Spirit");
 
-  it("rejects an empty or unknown roster", async () => {
-    const bundle = await getCohort();
-    expect(() =>
-      buildTeamCohortSummary(bundle, { teamKey: "empty", name: "Empty", playerKeys: [] })
-    ).toThrow(/at least one/);
-    expect(() =>
-      buildTeamCohortSummary(bundle, { teamKey: "unknown", name: "Unknown", playerKeys: ["missing"] })
-    ).toThrow(/not found/);
-  }, integrationTimeoutMs);
+    expect(overview).toMatchObject({ teamName: "Team Spirit", matchCount: 1, maps: [{ mapName: "de_ancient", matches: 1 }] });
+    expect(overview?.roster.length).toBeGreaterThan(0);
+  });
 });