@cs2dak/core 1.0.0 → 2.0.0

package/src/index.test.ts

@@ -1,70 +1,71 @@
-import { describe, expect, it } from "vitest";
+import { beforeAll, describe, expect, it } from "vitest";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
+import type { DemoPackage } from "@cs2dak/contract";
 import {
   analyzeDemoPackage,
   computeAccountRatingsV2,
-  deriveAccountSignalsV2,
+  deriveRRSignals,
   derivePlayerWeaponHighlights,
   deriveRRIndicators,
   loadDemoPackageFromZip
 } from "./index";
 
+let pkg: DemoPackage;
+
+beforeAll(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)));
+  pkg = await loadDemoPackageFromZip(zip);
+}, 30_000);
+
 describe("analyzeDemoPackage", () => {
-  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);
+  it("builds reusable analysis and view-model artifacts from a v3 export", () => {
     const bundle = analyzeDemoPackage(pkg);
-    expect(bundle.sourceSchemaVersion).toBe("cs2-demo-format/2.0");
+    expect(bundle.sourceSchemaVersion).toBe("cs2-demo-format/3.0");
     expect(bundle.version).toBe("cs2-demo-analysis-kit/1.0");
-    expect(bundle.provenance.sourceSchemaVersion).toBe("cs2-demo-format/2.0");
+    expect(bundle.provenance.analysisVersion).toBe("cs2-demo-analysis-kit/1.0.1");
+    expect(bundle.provenance.sourceSchemaVersion).toBe("cs2-demo-format/3.0");
     expect(bundle.provenance.ratingVersions.rr).toBeTruthy();
     expect(bundle.scoreboard).toHaveLength(10);
     expect(bundle.scoreboard[0]?.rr).toBeGreaterThan(0);
-    expect(bundle.playerIndicators[0]?.indicators.totalRounds).toBe(16);
-    expect(bundle.playerRoundFacts).toHaveLength(160);
-    expect(bundle.economy).toHaveLength(16);
-    expect(bundle.timeline.filter((event) => event.type === "kill")).toHaveLength(119);
-    expect(bundle.timeline.filter((event) => event.type === "bomb")).toHaveLength(51);
-    expect(bundle.heatmap.filter((point) => point.kind === "death")).toHaveLength(119);
+    expect(bundle.playerIndicators[0]?.indicators.totalRounds).toBe(23);
+    expect(bundle.playerRoundFacts).toHaveLength(230);
+    expect(bundle.economy).toHaveLength(23);
+    expect(bundle.timeline.filter((event) => event.type === "kill")).toHaveLength(153);
+    expect(bundle.timeline.filter((event) => event.type === "bomb")).toHaveLength(89);
+    expect(bundle.heatmap.filter((point) => point.kind === "death")).toHaveLength(153);
     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}$/);
   });
 
-  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);
+  it("derives RR six-account signals and computes six-account RR from the v3 fixture", () => {
+    const signals = deriveRRSignals(pkg);
     const ratings = computeAccountRatingsV2(pkg);
 
     expect(signals).toHaveLength(10);
     expect(ratings).toHaveLength(10);
-    expect(signals[0]?.rounds).toBe(16);
-    expect(signals[0]?.combat.killsByBuyDelta).toEqual({ disadvantage: 2, even: 3, advantage: 8 });
-    expect(signals[0]?.combat.killsByManState).toEqual({ manDown: 2, even: 5, manUp: 6 });
+    expect(signals[0]?.rounds).toBe(23);
+    // 新 fixture（Team Liquid vs FlyQuest, de_anubis, 15 回合）的 combat 分布
     expect(signals[0]?.trade.tradedOpeningDeaths).toBe(0);
-    expect(ratings[0]?.rr.model).toBe("value-accounts-v2-lite");
+    expect(ratings[0]?.rr.model).toBe("rr-six-accounts");
     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);
+  it("scores accountRR against the frozen pro baseline instead of the match mean", () => {
     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(mean).toBeGreaterThan(0);
+    expect(mean).not.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);
+  it("exposes RRIndicators without rebuilding them in cohort callers", () => {
     const indicators = deriveRRIndicators(pkg);
     const bundle = analyzeDemoPackage(pkg);
 
@@ -72,9 +73,7 @@ describe("analyzeDemoPackage", () => {
     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);
+  it("wires player-stats truth into RRIndicators instead of legacy approximations", () => {
     const statsTruth = pkg.playerStats[0]!;
     const patchedStats = {
       ...statsTruth,
@@ -84,14 +83,16 @@ describe("analyzeDemoPackage", () => {
     };
     const patchedPkg = {
       ...pkg,
-      playerStats: pkg.playerStats.map((row) => row.steamId64 === statsTruth.steamId64 ? patchedStats : row)
+      playerStats: pkg.playerStats.map((row) => row.playerIndex === statsTruth.playerIndex ? 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)!;
+    const bombDeathSteamId64 = pkg.players[statsTruth.playerIndex]?.steamId64 ?? "unknown";
+    const wallbangSteamId64 = pkg.players[wallbangStats.playerIndex]?.steamId64 ?? "unknown";
+    const bombDeathIndicators = indicators.find((row) => row.steamId64 === bombDeathSteamId64)!;
+    const wallbangIndicators = indicators.find((row) => row.steamId64 === wallbangSteamId64)!;
 
     expect(bombDeathStats.deaths).not.toBe(bombDeathStats.combatDeathCount);
     expect(bombDeathIndicators.combatDeathCount).toBe(bombDeathStats.combatDeathCount);
@@ -99,9 +100,7 @@ describe("analyzeDemoPackage", () => {
     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);
+  it("surfaces account breakdown and context status on the scoreboard", () => {
     const bundle = analyzeDemoPackage(pkg);
     const row = bundle.scoreboard[0]!;
 
@@ -111,17 +110,15 @@ describe("analyzeDemoPackage", () => {
     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);
+  it("surfaces rich v2 fields and confidence on the scoreboard", () => {
     const bundle = analyzeDemoPackage(pkg);
     const row = bundle.scoreboard[0]!;
 
-    expect(row.combatDeathCount).toBe(9);
+    expect(row.combatDeathCount).toBe(13);
     expect(row.bombDeathCount).toBe(0);
-    expect(row.bombPlantCount).toBe(0);
+    expect(row.bombPlantCount).toBeGreaterThanOrEqual(0);
     expect(row.noScopeKillCount).toBe(0);
-    expect(row.throughSmokeKillCount).toBe(0);
+    expect(row.throughSmokeKillCount).toBe(1);
     expect(row.fieldAvailability).toEqual({
       playerStats: "available",
       economy: "available",
@@ -133,9 +130,7 @@ describe("analyzeDemoPackage", () => {
     expect(row.confidence).toBeCloseTo(0.917, 3);
   });
 
-  it("derives reusable per-player weapon kill distribution and highlight facts", async () => {
-    const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
-    const pkg = await loadDemoPackageFromZip(zip);
+  it("derives reusable per-player weapon kill distribution and highlight facts", () => {
     const facts = derivePlayerWeaponHighlights(pkg);
     const bundle = analyzeDemoPackage(pkg);
 
@@ -155,17 +150,15 @@ describe("analyzeDemoPackage", () => {
     expect(facts.every((row) => row.highlights.throughSmokeKills != null)).toBe(true);
   });
 
-  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);
-
+  it("emits null context buckets (not zero) when the data source is missing", () => {
     // 剥离经济源 → buyDelta 降级为 null（而非零桶）；manState 仍可用
-    const noEconomy = deriveAccountSignalsV2({ ...pkg, playerEconomies: [] });
+    const noEconomy = deriveRRSignals({ ...pkg, playerEconomies: [] });
     expect(noEconomy[0]?.combat.killsByBuyDelta).toBeNull();
     expect(noEconomy[0]?.combat.killsByManState).not.toBeNull();
 
     // 剥离回合源 → manState 降级为 null
-    const noRounds = deriveAccountSignalsV2({ ...pkg, rounds: [] });
+    const noRounds = deriveRRSignals({ ...pkg, rounds: [] });
     expect(noRounds[0]?.combat.killsByManState).toBeNull();
   });
+
 });

package/src/index.ts

@@ -8,17 +8,32 @@ import { buildPlayerWeaponHighlights } from "./weapon-highlights.js";
 
 export { loadDemoPackageFromZip } from "./loader.js";
 export { normalizeDemoPackage } from "./normalize.js";
-export { deriveAccountSignalsV2, computeAccountRatingsV2 } from "./signals.js";
+export { createPlayerResolver, createResolverFromPackage } from "./resolve.js";
+export type { PlayerResolver } from "./resolve.js";
+export { demoSourceAvailability, type DemoSourceAvailability } from "./qa.js";
+export { deriveRRSignals, computeAccountRatingsV2 } from "./signals.js";
+export { activeDamages, groupBy } from "./utils.js";
+export * from "./spatial/index.js";
 export { deriveRRIndicators } from "./scoreboard.js";
+export { buildPlayerRoundFacts } from "./scoreboard.js";
+export { buildPlayerRoundUtilityFacts, type PlayerRoundUtilityFact } from "./utility-facts.js";
 export { derivePlayerWeaponHighlights } from "./weapon-highlights.js";
-export { buildEconomyConversion } from "./economy.js";
 export { buildTeamSideWinRates } from "./side-win-rate.js";
-export type {
-  EconomyTypeStats,
-  EconomyConversion,
-  MatchEconomyConversion,
-} from "./economy.js";
+export { buildDuelsSignals, deriveDuels, deriveOpeningDuels } from "./duels.js";
+export { buildMechanicsSignals, counterStrafeThresholdForWeapon, derivePlayerMechanics } from "./mechanics.js";
+export { buildMatchRadarField, aggregateRadarFields, RADAR_FIELD_VERSION } from "./radar-field.js";
+export type { BuildMatchRadarFieldOptions } from "./radar-field.js";
 export type { SideWinRateStats, TeamSideWinRates } from "./side-win-rate.js";
+export type { DuelClassification, DuelHpBucket, DuelRecord, DuelSignals, TtkDistribution } from "./duels.js";
+export type {
+  BurstLengthBuckets,
+  MechanicsMetricSet,
+  MechanicsSignals,
+  MedianSample,
+  PlayerMechanicsFact,
+  PreaimSample,
+  RateSample,
+} from "./mechanics.js";
 
 export function analyzeDemoPackage(input: unknown): AnalysisBundle {
   const pkg = normalizeDemoPackage(input);
@@ -36,7 +51,7 @@ export function analyzeDemoPackage(input: unknown): AnalysisBundle {
     version: "cs2-demo-analysis-kit/1.0",
     sourceSchemaVersion: pkg.manifest.schemaVersion,
     provenance: {
-      analysisVersion: "cs2-demo-analysis-kit/1.0",
+      analysisVersion: "cs2-demo-analysis-kit/1.0.1",
       sourceSchemaVersion: pkg.manifest.schemaVersion,
       sourceDemoHash: pkg.manifest.demo?.hash ?? null,
       exporter: pkg.manifest.exporter,
@@ -62,3 +77,5 @@ export function analyzeDemoPackage(input: unknown): AnalysisBundle {
     qa
   });
 }
+export * from "./tactics/index.js";
+export * from "./map-intelligence/index.js";

package/src/loader.ts

@@ -1,5 +1,6 @@
 import JSZip from "jszip";
 import type { DemoPackage } from "@cs2dak/contract";
+import { manifestSchema } from "@cs2dak/contract";
 import { normalizeDemoPackage, parsePackageJson } from "./normalize.js";
 
 export async function loadDemoPackageFromZip(bytes: ArrayBuffer | Uint8Array): Promise<DemoPackage> {
@@ -12,21 +13,34 @@ export async function loadDemoPackageFromZip(bytes: ArrayBuffer | Uint8Array): P
     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);
+  const rawManifest = await readJson<{ schemaVersion?: string }>("manifest.json");
+  const version = rawManifest?.schemaVersion ?? "unknown";
+  if (!version.startsWith("cs2-demo-format/3.")) {
+    throw new Error(
+      `不支持的包版本 ${version}：本版本只读取 cs2-demo-format/3.x，请用 cs2df 重新导出该 demo`
+    );
+  }
+  const manifest = manifestSchema.parse(rawManifest);
+  const files = manifest.files;
+
+  const optional = async (name: string | undefined): Promise<unknown> =>
+    name ? readJson<unknown>(name).catch(() => undefined) : undefined;
+  const match = await readJson<unknown>(files.match);
+  const players = await readJson<unknown>(files.players);
+  const rounds = await readJson<unknown>(files.rounds);
+  // cs2-demo-format/3.x requires these files. An empty, valid array means no
+  // event occurred; a missing or invalid file is a malformed package, not [] .
+  const playerEconomies = await readJson<unknown>(files.playerEconomies);
+  const playerStats = await readJson<unknown>(files.playerStats);
+  const kills = await readJson<unknown>(files.kills);
+  const damages = await readJson<unknown>(files.damages);
+  const blinds = await readJson<unknown>(files.blinds);
+  const bombs = await readJson<unknown>(files.bombs);
+  const grenades = await readJson<unknown>(files.grenades);
+  const clutches = await readJson<unknown>(files.clutches);
+  const shots = await optional(files.shots);
+  const replay = await optional(files.replay);
+  const duels = await optional(files.duels);
 
   return normalizeDemoPackage({
     manifest,
@@ -42,7 +56,7 @@ export async function loadDemoPackageFromZip(bytes: ArrayBuffer | Uint8Array): P
     grenades,
     clutches,
     shots,
-    positions1s,
-    replay
+    replay,
+    duels
   });
 }

package/src/map-intelligence/awp.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import { FLAG_ALIVE, type DemoPackage } from "@cs2dak/contract";
+import { extractAwpRoundFacts } from "./awp.js";
+import { extractTeamAwpRoundFacts } from "./team-awp-round.js";
+import type { ReplayRoundContext, ReplayRoundTrack } from "../tactics/replay-round-context.js";
+
+describe("extractAwpRoundFacts", () => {
+  it("stops active AWP time after death and ignores invalid trajectory frames", () => {
+    const track: ReplayRoundTrack = {
+      playerIndex: 0, teamKey: "teamA", side: "ct", steamId64: "76561198000000001",
+      x: [1, 1, 1, Number.NaN], y: [1, 1, 1, 1], z: [1, 1, 1, 1],
+      flags: [FLAG_ALIVE, FLAG_ALIVE, 0, FLAG_ALIVE], place: [0, 0, 0, 0], weapon: [0, 0, 0, 0],
+    };
+    const round = { roundNumber: 1, freezeEndTick: 0, endTick: 128 } as DemoPackage["rounds"][number];
+    const context: ReplayRoundContext = { round, startTick: 0, tickStep: 32, frameCount: 4, placeDict: [], weaponDict: ["awp"], tracks: [track] };
+    const pkg = {
+      match: { tickrate: 64 }, playerEconomies: [], shots: undefined, kills: [],
+    } as unknown as DemoPackage;
+    expect(extractAwpRoundFacts(pkg, context, track).activeAwpSeconds).toBe(1);
+  });
+
+  it("does not count invalid-coordinate teammates toward double-AWP active time", () => {
+    const tracks: ReplayRoundTrack[] = [0, 1].map((playerIndex) => ({
+      playerIndex, teamKey: "teamA", side: "ct", steamId64: `7656119800000000${playerIndex + 1}`,
+      x: playerIndex === 0 ? [1, 1] : [Number.NaN, Number.NaN], y: [1, 1], z: [1, 1],
+      flags: [FLAG_ALIVE, FLAG_ALIVE], place: [0, 0], weapon: [0, 0],
+    }));
+    const round = { roundNumber: 1, freezeEndTick: 0, endTick: 64, teamASide: "ct", teamBSide: "t", teamAEconomy: "full", teamBEconomy: "full", winnerTeamKey: "teamA" } as DemoPackage["rounds"][number];
+    const context: ReplayRoundContext = { round, startTick: 0, tickStep: 32, frameCount: 2, placeDict: [], weaponDict: ["awp"], tracks };
+    const pkg = { match: { tickrate: 64, mapName: "de_nuke" }, rounds: [round], players: [{ teamKey: "teamA" }, { teamKey: "teamA" }], kills: [] } as unknown as DemoPackage;
+    const rows = tracks.map((track) => ({ teamKey: "teamA", playerIndex: track.playerIndex, freezeAwpOwnership: true, activeAwpSeconds: 1, awpShots: 0, awpKills: 0, availability: { replay: "available", nav: "missing", callouts: "missing", shots: "missing" } })) as unknown as import("@cs2dak/contract").PlayerPositionRoundFact[];
+    expect(extractTeamAwpRoundFacts(pkg, "m1", context, rows).find((item) => item.teamKey === "teamA")?.doubleAwpActiveSeconds).toBe(0);
+  });
+
+  it("materializes effective enemy-only AWP damage and retains zero for a damage-complete round", () => {
+    const round = { roundNumber: 1, freezeEndTick: 10, endTick: 100, teamASide: "ct", teamBSide: "t", teamAEconomy: "full", teamBEconomy: "full", winnerTeamKey: "teamA" } as DemoPackage["rounds"][number];
+    const tracks: ReplayRoundTrack[] = [
+      { playerIndex: 0, teamKey: "teamA", side: "ct", steamId64: "a", x: [1], y: [1], z: [1], flags: [FLAG_ALIVE], place: [0], weapon: [0] },
+      { playerIndex: 1, teamKey: "teamB", side: "t", steamId64: "b", x: [1], y: [1], z: [1], flags: [FLAG_ALIVE], place: [0], weapon: [0] },
+    ];
+    const context: ReplayRoundContext = { round, startTick: 10, tickStep: 32, frameCount: 1, placeDict: [], weaponDict: ["awp"], tracks };
+    const pkg = {
+      manifest: { files: { damages: "damages.json" } }, match: { tickrate: 64, mapName: "de_nuke" }, rounds: [round], players: [{ teamKey: "teamA" }, { teamKey: "teamB" }], kills: [],
+      damages: [
+        { roundNumber: 1, tick: 20, attackerIndex: 0, victimIndex: 1, weapon: "weapon_awp", healthDamage: 40, healthDamageRaw: 100 },
+        { roundNumber: 1, tick: 20, attackerIndex: 0, victimIndex: 0, weapon: "awp", healthDamage: 80, healthDamageRaw: 80 },
+        { roundNumber: 1, tick: 20, attackerIndex: null, victimIndex: 1, weapon: "awp", healthDamage: 90, healthDamageRaw: 90 },
+        { roundNumber: 1, tick: 20, attackerIndex: 0, victimIndex: 1, weapon: "ak47", healthDamage: 30, healthDamageRaw: 30 },
+        { roundNumber: 1, tick: 5, attackerIndex: 0, victimIndex: 1, weapon: "awp", healthDamage: 20, healthDamageRaw: 20 },
+      ],
+    } as unknown as DemoPackage;
+    const rows = tracks.map((track) => ({ teamKey: track.teamKey, playerIndex: track.playerIndex, freezeAwpOwnership: false, activeAwpSeconds: 0, awpShots: 0, awpKills: 0, availability: { replay: "available", nav: "missing", callouts: "missing", shots: "missing" } })) as unknown as import("@cs2dak/contract").PlayerPositionRoundFact[];
+    const facts = extractTeamAwpRoundFacts(pkg, "m1", context, rows);
+    expect(facts.find((row) => row.teamKey === "teamA")?.awpDamage).toBe(40);
+    expect(facts.find((row) => row.teamKey === "teamB")?.awpDamage).toBe(0);
+  });
+});

package/src/map-intelligence/awp.ts

@@ -0,0 +1,45 @@
+import { decodeDelta, FLAG_ALIVE, type DemoPackage } from "@cs2dak/contract";
+import { replayWeaponAt, type ReplayRoundContext, type ReplayRoundTrack } from "../tactics/replay-round-context.js";
+
+function isAwp(weapon: string | null | undefined): boolean {
+  return weapon?.trim().toLowerCase().replace(/^weapon_/, "") === "awp";
+}
+
+export interface AwpRoundFacts {
+  freezeAwpOwnership: boolean | null;
+  activeAwpSeconds: number | null;
+  awpShots: number | null;
+  awpKills: number | null;
+}
+
+/** AWP is deliberately exact-name only: SSG 08 and other snipers do not qualify. */
+export function extractAwpRoundFacts(
+  pkg: DemoPackage,
+  context: ReplayRoundContext | null,
+  track: ReplayRoundTrack | null,
+): AwpRoundFacts {
+  const playerIndex = track?.playerIndex ?? -1;
+  const roundNumber = context?.round.roundNumber ?? -1;
+  if (!context || !track) {
+    return { freezeAwpOwnership: null, activeAwpSeconds: null, awpShots: null, awpKills: null };
+  }
+  const economy = pkg.playerEconomies.find((row) => row.roundNumber === roundNumber && row.playerIndex === playerIndex);
+  const freezeAwpOwnership = economy ? isAwp(economy.primaryWeapon) : null;
+  const frameSeconds = context.tickStep / (pkg.match.tickrate || 64);
+  let activeFrames = 0;
+  for (let index = 0; index < context.frameCount; index += 1) {
+    const tick = context.startTick + index * context.tickStep;
+    if (tick < context.round.freezeEndTick || tick > context.round.endTick) continue;
+    if (((track.flags[index] ?? 0) & FLAG_ALIVE) === 0) continue;
+    if (![track.x[index], track.y[index], track.z[index]].every((value) => value != null && Number.isFinite(value))) continue;
+    if (isAwp(replayWeaponAt(context, track, index))) activeFrames += 1;
+  }
+  const shotTrack = pkg.shots?.tracks.find((row) => row.roundNumber === roundNumber && row.playerIndex === playerIndex);
+  const awpShots = shotTrack
+    ? decodeDelta(shotTrack.tick).filter((_, index) => isAwp(pkg.shots?.weaponDict[shotTrack.weapon[index] ?? -1])).length
+    : pkg.shots ? 0 : null;
+  const awpKills = pkg.kills
+    .filter((kill) => kill.roundNumber === roundNumber && kill.killerIndex === playerIndex)
+    .filter((kill) => isAwp(kill.killerActiveWeapon) || isAwp(kill.weapon)).length;
+  return { freezeAwpOwnership, activeAwpSeconds: activeFrames * frameSeconds, awpShots, awpKills };
+}

package/src/map-intelligence/ct-rotation.test.ts

@@ -0,0 +1,149 @@
+import { describe, expect, it } from "vitest";
+import { FLAG_ALIVE, type DemoPackage } from "@cs2dak/contract";
+import type { ReplayRoundContext, ReplayRoundTrack } from "../tactics/replay-round-context.js";
+import { extractCtRotationRoundFacts } from "./ct-rotation.js";
+import { buildRoundSpatialFrames } from "./spatial.js";
+
+const frameCount = 71;
+const placeDict = ["BombsiteA", "CTSpawn", "BombsiteB", "TRamp", "Apartments"];
+const round = {
+  roundNumber: 1,
+  freezeEndTick: 100,
+  endTick: 800,
+  teamASide: "ct",
+  teamBSide: "t",
+} as DemoPackage["rounds"][number];
+
+function track(
+  playerIndex: number,
+  teamKey: "teamA" | "teamB",
+  side: "ct" | "t",
+  places: number[],
+  flags = Array(frameCount).fill(FLAG_ALIVE),
+): ReplayRoundTrack {
+  return {
+    playerIndex,
+    teamKey,
+    side,
+    steamId64: `7656119800000000${playerIndex + 1}`,
+    x: Array(frameCount).fill(playerIndex * 100),
+    y: Array(frameCount).fill(0),
+    z: Array(frameCount).fill(0),
+    flags,
+    place: places,
+    weapon: Array(frameCount).fill(-1),
+  };
+}
+
+function scenario(options: { deathTick?: number; otherContactTick?: number; secondRotates?: boolean; deathWithoutEnemyContact?: boolean } = {}) {
+  const deathTick = options.deathTick ?? null;
+  const otherContactTick = options.otherContactTick ?? 305;
+  const rotatingFlags = Array(frameCount).fill(FLAG_ALIVE);
+  if (deathTick != null) rotatingFlags.fill(0, Math.floor((deathTick - 100) / 10) + 1);
+  const rotatingPlaces = Array.from({ length: frameCount }, (_, index) => index <= 20 ? 0 : index < 30 ? 1 : 2);
+  const otherContactFrame = Math.round((otherContactTick - 100) / 10);
+  const context: ReplayRoundContext = {
+    round,
+    startTick: 100,
+    tickStep: 10,
+    frameCount,
+    placeDict,
+    weaponDict: [],
+    tracks: [
+      track(0, "teamA", "ct", rotatingPlaces, rotatingFlags),
+      track(1, "teamA", "ct", options.secondRotates ? rotatingPlaces : Array(frameCount).fill(0)),
+      track(2, "teamB", "t", Array.from({ length: frameCount }, (_, index) => index < otherContactFrame ? 3 : 4)),
+    ],
+  };
+  const pkg = {
+    match: { mapName: "de_mirage", tickrate: 10 },
+    rounds: [round],
+    players: [
+      { steamId64: "76561198000000001", teamKey: "teamA" },
+      { steamId64: "76561198000000002", teamKey: "teamA" },
+      { steamId64: "76561198000000003", teamKey: "teamB" },
+    ],
+    damages: [
+      { roundNumber: 1, tick: 250, attackerIndex: 2, victimIndex: 0, healthDamageRaw: 10 },
+      { roundNumber: 1, tick: otherContactTick, attackerIndex: 2, victimIndex: 0, healthDamageRaw: 10 },
+    ],
+    kills: deathTick == null ? [] : [{ roundNumber: 1, tick: deathTick, killerIndex: options.deathWithoutEnemyContact ? null : 2, victimIndex: 0 }],
+    shots: undefined,
+  } as unknown as DemoPackage;
+  const frames = buildRoundSpatialFrames(context, null, null);
+  return extractCtRotationRoundFacts(pkg, "m1", context, round, frames, null, false);
+}
+
+describe("extractCtRotationRoundFacts", () => {
+  it("records a stable cross-area response and its team-relative order without emitting a role", () => {
+    const row = scenario().find((candidate) => candidate.playerIndex === 0)!;
+
+    expect(row).toMatchObject({
+      initialPositionGroupId: "a_site",
+      initialRegion: "a",
+      initialPositionGroupShare: 1,
+      initialResponsibilityResolved: true,
+      firstOwnAreaContactTick: 250,
+      firstOtherAreaContactTick: 305,
+      firstTeamContactTick: 250,
+      leftInitialPositionGroupTick: 310,
+      leaveDelayAfterFirstOtherAreaContactSeconds: 0.5,
+      firstStableDestinationPositionGroupId: "b_site",
+      firstStableDestinationRegion: "b",
+      crossedResponsibilityArea: true,
+      returnedToInitialPositionGroup: false,
+      transitToStableDestinationSeconds: 9,
+      crossAreaDepartureOrder: 1,
+      firstCrossAreaDeparture: true,
+      priorCrossAreaDeparturesAlive: 0,
+      initialAreaStillCovered: true,
+      censoredByDeath: false,
+    });
+    expect(row).not.toHaveProperty("role");
+  });
+
+  it("keeps an unfinished response unknown when death truncates observation", () => {
+    const row = scenario({ deathTick: 330 }).find((candidate) => candidate.playerIndex === 0)!;
+
+    expect(row.deathTick).toBe(330);
+    expect(row.censoredByDeath).toBe(true);
+    expect(row.leftInitialPositionGroupTick).toBeNull();
+    expect(row.firstStableDestinationPositionGroupId).toBeNull();
+    expect(row.crossedResponsibilityArea).toBeNull();
+    expect(row.crossAreaDepartureOrder).toBeNull();
+  });
+
+  it("records an observed full-round stay as false rather than unknown", () => {
+    const row = scenario().find((candidate) => candidate.playerIndex === 1)!;
+
+    expect(row.initialResponsibilityResolved).toBe(true);
+    expect(row.deathTick).toBeNull();
+    expect(row.censoredByDeath).toBe(false);
+    expect(row.crossedResponsibilityArea).toBe(false);
+  });
+
+  it("uses signed contact delay instead of hiding a departure that came first", () => {
+    const row = scenario({ otherContactTick: 350 }).find((candidate) => candidate.playerIndex === 0)!;
+
+    expect(row.leftInitialPositionGroupTick).toBe(310);
+    expect(row.firstOtherAreaContactTick).toBe(350);
+    expect(row.leaveDelayAfterFirstOtherAreaContactSeconds).toBe(-4);
+  });
+
+  it("clips team contacts to the player's observable lifetime", () => {
+    const row = scenario({ deathTick: 190, deathWithoutEnemyContact: true }).find((candidate) => candidate.playerIndex === 0)!;
+
+    expect(row.censoredByDeath).toBe(true);
+    expect(row.firstTeamContactTick).toBeNull();
+    expect(row.firstOwnAreaContactTick).toBeNull();
+    expect(row.firstOtherAreaContactTick).toBeNull();
+  });
+
+  it("preserves simultaneous departures as deterministic shared ranks", () => {
+    const rows = scenario({ secondRotates: true }).filter((candidate) => candidate.playerIndex < 2);
+
+    expect(rows.map((row) => row.crossAreaDepartureOrder)).toEqual([1, 1]);
+    expect(rows.map((row) => row.firstCrossAreaDeparture)).toEqual([true, true]);
+    expect(rows.map((row) => row.priorCrossAreaDeparturesAlive)).toEqual([0, 0]);
+  });
+});