@cs2dak/core 0.2.1 → 2.0.0

package/src/index.test.ts

@@ -1,105 +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,
-  buildMatchWorkspaceModel,
-  buildDemoViewModel,
   computeAccountRatingsV2,
-  deriveAccountSignalsV2,
+  deriveRRSignals,
+  derivePlayerWeaponHighlights,
   deriveRRIndicators,
   loadDemoPackageFromZip
 } from "./index";
 
-describe("analyzeDemoPackage", () => {
-  it("builds a match workspace model with replay and user-facing modules from a strict v2 export", async () => {
-    const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
-    const pkg = await loadDemoPackageFromZip(zip);
-    const workspace = buildMatchWorkspaceModel(pkg);
-
-    expect(workspace.version).toBe("cs2-demo-analysis-kit/workspace-0.1");
-    expect(workspace.title).toBe("Team A vs Team B");
-    expect(workspace.tabs.map((tab) => tab.key)).toEqual(["overview", "rounds", "players", "economy", "map", "replay"]);
-    expect(workspace.overview.kpis.map((kpi) => kpi.key)).not.toContain("qa");
-    expect(workspace.overview.kpis.map((kpi) => kpi.key)).not.toContain("economySwing");
-    expect(workspace.rounds).toHaveLength(21);
-    expect(workspace.rounds[0]?.events.some((event) => event.type === "kill")).toBe(true);
-    expect(workspace.players).toHaveLength(10);
-    expect(workspace.players[0]?.rrBreakdown.length).toBe(5);
-    expect(workspace.map.modes.map((mode) => mode.key)).toEqual(["death", "kill", "grenade", "bomb", "position"]);
-    expect(workspace.replay.available).toBe(true);
-    expect(workspace.replay.rounds.length).toBeGreaterThan(0);
-    expect(workspace.replay.rounds[0]?.players[0]?.frames.length).toBeGreaterThan(0);
-    expect(workspace.replay.capabilities.hasDefuseKit).toBe(true);
-    expect(workspace.replay.capabilities.hasBombPosition).toBe(false);
-    expect(workspace.replay.rounds.some((round) => round.players.some((player) => player.frames.some((frame) => frame.weapon && /^\d+$/.test(frame.weapon))))).toBe(false);
-    expect(workspace.overview.story.length).toBeGreaterThan(0);
-    // 开场 beat 必出：含地图显示名 + 比分，且用胜负动词之一描述结果。
-    expect(workspace.overview.story[0]).toContain("Ancient");
-    expect(workspace.overview.story[0]).toContain("13:8");
-    expect(workspace.overview.story[0]).toMatch(/碾压|险胜|拿下/);
-    expect(workspace.overview.story.join("\n")).not.toContain("打成");
-    expect(workspace.adminQa.summary.errorCount).toBe(0);
-  });
+let pkg: DemoPackage;
 
-  it("builds reusable analysis and view-model artifacts from a strict v2 export", async () => {
-    const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
-    const pkg = await loadDemoPackageFromZip(zip);
-    const bundle = analyzeDemoPackage(pkg);
-    const viewModel = buildDemoViewModel(bundle);
+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);
 
-    expect(bundle.sourceSchemaVersion).toBe("cs2-demo-format/2.0");
-    expect(bundle.version).toBe("cs2-demo-analysis-kit/0.2");
+describe("analyzeDemoPackage", () => {
+  it("builds reusable analysis and view-model artifacts from a v3 export", () => {
+    const bundle = analyzeDemoPackage(pkg);
+    expect(bundle.sourceSchemaVersion).toBe("cs2-demo-format/3.0");
+    expect(bundle.version).toBe("cs2-demo-analysis-kit/1.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(21);
-    expect(bundle.playerRoundFacts).toHaveLength(210);
-    expect(bundle.economy).toHaveLength(21);
-    expect(bundle.timeline.filter((event) => event.type === "kill")).toHaveLength(142);
-    expect(bundle.timeline.filter((event) => event.type === "bomb")).toHaveLength(94);
-    expect(bundle.heatmap.filter((point) => point.kind === "death")).toHaveLength(142);
+    expect(bundle.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}$/);
-    expect(viewModel.scoreline).toBe("13:8");
-    expect(viewModel.map.name).toBe("de_ancient");
-    expect(viewModel.map.radarImageUrl).toBe("./maps/radars/de_ancient.png");
-    expect(viewModel.qa.summary.errorCount).toBe(0);
   });
 
-  it("derives value-account signals and computes v2 RR from the strict v2 fixture", async () => {
-    const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
-    const pkg = await loadDemoPackageFromZip(zip);
-    const signals = deriveAccountSignalsV2(pkg);
+  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(21);
-    expect(signals[0]?.combat.killsByBuyDelta).toEqual({ disadvantage: 0, even: 2, advantage: 5 });
-    expect(signals[0]?.combat.killsByManState).toEqual({ manDown: 1, even: 5, manUp: 1 });
-    expect(signals[0]?.trade.tradedOpeningDeaths).toBe(1);
-    expect(ratings[0]?.rr.model).toBe("value-accounts-v2-lite");
+    expect(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("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);
 
@@ -107,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,
@@ -119,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);
@@ -134,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]!;
 
@@ -146,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(11);
+    expect(row.combatDeathCount).toBe(13);
     expect(row.bombDeathCount).toBe(0);
-    expect(row.bombPlantCount).toBe(4);
+    expect(row.bombPlantCount).toBeGreaterThanOrEqual(0);
     expect(row.noScopeKillCount).toBe(0);
-    expect(row.throughSmokeKillCount).toBe(2);
+    expect(row.throughSmokeKillCount).toBe(1);
     expect(row.fieldAvailability).toEqual({
       playerStats: "available",
       economy: "available",
@@ -168,17 +130,35 @@ describe("analyzeDemoPackage", () => {
     expect(row.confidence).toBeCloseTo(0.917, 3);
   });
 
-  it("emits null context buckets (not zero) when the data source is missing", async () => {
-    const zip = await readFile(fileURLToPath(new URL("../../../fixtures/input/cs2dak-sanitized-de_ancient.zip", import.meta.url)));
-    const pkg = await loadDemoPackageFromZip(zip);
+  it("derives reusable per-player weapon kill distribution and highlight facts", () => {
+    const facts = derivePlayerWeaponHighlights(pkg);
+    const bundle = analyzeDemoPackage(pkg);
+
+    expect(facts).toHaveLength(pkg.players.length);
+    expect(bundle.playerWeaponHighlights).toEqual(facts);
+    expect(facts.every((row) => row.weapons.reduce((sum, weapon) => sum + weapon.kills, 0) === row.totalKills)).toBe(true);
+    expect(facts.flatMap((row) => row.weapons).some((weapon) => weapon.weapon === "ak47")).toBe(true);
+    expect(facts.flatMap((row) => row.weapons).every((weapon) =>
+      weapon.headshotKills <= weapon.kills
+      && weapon.tradeKills <= weapon.kills
+      && weapon.noScopeKills <= weapon.kills
+      && weapon.throughSmokeKills <= weapon.kills
+      && weapon.wallbangKills <= weapon.kills
+    )).toBe(true);
+    expect(facts.every((row) => row.highlights.wallbangKills != null)).toBe(true);
+    expect(facts.every((row) => row.highlights.noScopeKills != null)).toBe(true);
+    expect(facts.every((row) => row.highlights.throughSmokeKills != null)).toBe(true);
+  });
 
+  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

@@ -4,19 +4,36 @@ import { buildQaReport } from "./qa.js";
 import { buildPlayerRoundFacts, buildPlayerIndicators, buildScoreboard } from "./scoreboard.js";
 import { computeAccountRatingsV2 } from "./signals.js";
 import { buildTimeline, buildEconomy, buildHeatmap } from "./timeline.js";
+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 { buildDemoViewModel, buildMatchWorkspaceModel } from "./workspace.js";
-export { displayWeaponName } from "./weapons.js";
-export { buildEconomyConversion, economyLabelCn } from "./economy.js";
+export { buildPlayerRoundFacts } from "./scoreboard.js";
+export { buildPlayerRoundUtilityFacts, type PlayerRoundUtilityFact } from "./utility-facts.js";
+export { derivePlayerWeaponHighlights } from "./weapon-highlights.js";
+export { buildTeamSideWinRates } from "./side-win-rate.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 {
-  EconomyTypeStats,
-  EconomyConversion,
-  MatchEconomyConversion,
-} from "./economy.js";
+  BurstLengthBuckets,
+  MechanicsMetricSet,
+  MechanicsSignals,
+  MedianSample,
+  PlayerMechanicsFact,
+  PreaimSample,
+  RateSample,
+} from "./mechanics.js";
 
 export function analyzeDemoPackage(input: unknown): AnalysisBundle {
   const pkg = normalizeDemoPackage(input);
@@ -25,13 +42,25 @@ export function analyzeDemoPackage(input: unknown): AnalysisBundle {
   const playerIndicators = buildPlayerIndicators(pkg, playerRoundFacts);
   const accountRatings = computeAccountRatingsV2(pkg);
   const scoreboard = buildScoreboard(pkg, playerIndicators, accountRatings);
+  const playerWeaponHighlights = buildPlayerWeaponHighlights(pkg);
   const timeline = buildTimeline(pkg);
   const economy = buildEconomy(pkg);
   const heatmap = buildHeatmap(pkg);
 
   return analysisBundleSchema.parse({
-    version: "cs2-demo-analysis-kit/0.2",
+    version: "cs2-demo-analysis-kit/1.0",
     sourceSchemaVersion: pkg.manifest.schemaVersion,
+    provenance: {
+      analysisVersion: "cs2-demo-analysis-kit/1.0.1",
+      sourceSchemaVersion: pkg.manifest.schemaVersion,
+      sourceDemoHash: pkg.manifest.demo?.hash ?? null,
+      exporter: pkg.manifest.exporter,
+      parser: pkg.manifest.parser,
+      ratingVersions: {
+        rr: playerIndicators[0]?.rr.weightsVersion ?? null,
+        valueAccounts: accountRatings[0]?.rr.weightsVersion ?? null
+      }
+    },
     mapName: pkg.match.mapName,
     tickrate: pkg.match.tickrate,
     teams: {
@@ -39,6 +68,7 @@ export function analyzeDemoPackage(input: unknown): AnalysisBundle {
       teamB: { name: pkg.match.teamB.name ?? "Team B", score: pkg.match.teamB.score }
     },
     scoreboard,
+    playerWeaponHighlights,
     playerIndicators,
     playerRoundFacts,
     timeline,
@@ -47,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 };
+}