@cs2dak/core 0.2.1 → 2.0.0

package/src/map-intelligence/player-position.ts

@@ -0,0 +1,250 @@
+import {
+  MAP_INTELLIGENCE_FACT_VERSION,
+  type MapIntelligenceAvailability,
+  type PlayerPositionRoundFact,
+  type DemoPackage,
+} from "@cs2dak/contract";
+import { positionGroupOf, type CalloutGrid } from "@cs2dak/maps";
+import { extractAwpRoundFacts } from "./awp.js";
+import { mean, rounded, type TeamSpatialFrame } from "./spatial.js";
+import type { ReplayRoundContext, ReplayRoundTrack } from "../tactics/replay-round-context.js";
+import { openingResponsibilityWindow } from "./opening-window.js";
+
+function availability(context: ReplayRoundContext | null, track: ReplayRoundTrack | null, grid: CalloutGrid | null, hasNav: boolean, hasShots: boolean): MapIntelligenceAvailability {
+  return {
+    replay: context && track ? "available" : context ? "degraded" : "missing",
+    nav: hasNav ? "available" : "missing",
+    callouts: context && (context.placeDict.length > 0 || grid) ? "available" : context ? "degraded" : "missing",
+    shots: hasShots ? "available" : "missing",
+  };
+}
+
+function distances(frame: TeamSpatialFrame, playerIndex: number): { nearest: number | null; centroid: number | null; componentSize: number | null } {
+  const player = frame.players.find((row) => row.playerIndex === playerIndex);
+  if (!player) return { nearest: null, centroid: null, componentSize: null };
+  const teammates = frame.players.filter((row) => row.playerIndex !== playerIndex);
+  const distance = (first: typeof player.point, second: typeof player.point) => Math.hypot(first.x - second.x, first.y - second.y, first.z - second.z);
+  const nearest = teammates.length ? Math.min(...teammates.map((row) => distance(player.point, row.point))) : null;
+  const centroid = teammates.length
+    ? { x: teammates.reduce((sum, row) => sum + row.point.x, 0) / teammates.length, y: teammates.reduce((sum, row) => sum + row.point.y, 0) / teammates.length, z: teammates.reduce((sum, row) => sum + row.point.z, 0) / teammates.length }
+    : null;
+  const componentSize = frame.components.find((component) => component.includes(playerIndex))?.length ?? null;
+  return { nearest, centroid: centroid ? distance(player.point, centroid) : null, componentSize };
+}
+
+function movementSync(frames: readonly TeamSpatialFrame[], playerIndex: number): number | null {
+  const values: number[] = [];
+  for (let index = 1; index < frames.length; index += 1) {
+    const before = frames[index - 1]!.players.find((row) => row.playerIndex === playerIndex);
+    const after = frames[index]!.players.find((row) => row.playerIndex === playerIndex);
+    if (!before || !after) continue;
+    const teamBefore = frames[index - 1]!.players.filter((row) => row.playerIndex !== playerIndex);
+    const teamAfter = frames[index]!.players.filter((row) => row.playerIndex !== playerIndex);
+    if (teamBefore.length === 0 || teamBefore.length !== teamAfter.length) continue;
+    const self = { x: after.point.x - before.point.x, y: after.point.y - before.point.y, z: after.point.z - before.point.z };
+    const team = teamAfter.reduce((sum, row, teammateIndex) => ({ x: sum.x + row.point.x - teamBefore[teammateIndex]!.point.x, y: sum.y + row.point.y - teamBefore[teammateIndex]!.point.y, z: sum.z + row.point.z - teamBefore[teammateIndex]!.point.z }), { x: 0, y: 0, z: 0 });
+    const selfLength = Math.hypot(self.x, self.y, self.z);
+    const teamLength = Math.hypot(team.x, team.y, team.z);
+    if (selfLength === 0 || teamLength === 0) continue;
+    values.push((self.x * team.x + self.y * team.y + self.z * team.z) / (selfLength * teamLength));
+  }
+  return rounded(mean(values));
+}
+
+const MIN_DELAYED_ISOLATION_SECONDS = 2;
+const MIN_TARGET_STABILITY_SECONDS = 1;
+const MIN_CONVERGENCE_PERSISTENCE_SECONDS = 2;
+
+function samePlayers(first: TeamSpatialFrame, second: TeamSpatialFrame): boolean {
+  const a = first.players.map((row) => row.playerIndex).sort((x, y) => x - y);
+  const b = second.players.map((row) => row.playerIndex).sort((x, y) => x - y);
+  return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+
+/** Conservative per-round convergence evidence; raw rejoin ticks remain separately available. */
+export function detectDelayedConvergences(
+  frames: readonly TeamSpatialFrame[],
+  playerIndex: number,
+  tickrate: number,
+  tickStep: number,
+): PlayerPositionRoundFact["delayedConvergences"] {
+  const result: PlayerPositionRoundFact["delayedConvergences"] = [];
+  let isolatedSince: number | null = null;
+  for (let index = 0; index < frames.length; index += 1) {
+    const frame = frames[index]!;
+    const component = frame.components.find((group) => group.includes(playerIndex));
+    const isolated = component?.length === 1 && frame.players.length > 1;
+    if (isolated) {
+      isolatedSince ??= frame.tick;
+      continue;
+    }
+    if (isolatedSince == null || !component || component.length < 3 || index === 0) {
+      isolatedSince = null;
+      continue;
+    }
+    const priorIsolationSeconds = (frame.tick - isolatedSince) / tickrate;
+    const before = frames[index - 1]!;
+    if (priorIsolationSeconds < MIN_DELAYED_ISOLATION_SECONDS || !samePlayers(before, frame)) {
+      isolatedSince = null;
+      continue;
+    }
+    const target = component.filter((member) => member !== playerIndex);
+    const priorStartTick = frame.tick - MIN_TARGET_STABILITY_SECONDS * tickrate;
+    const priorFrames = frames.slice(0, index).filter((candidate) => candidate.tick >= priorStartTick);
+    const hasPriorCoverage = priorFrames.length > 0 && frame.tick - priorFrames[0]!.tick + tickStep >= MIN_TARGET_STABILITY_SECONDS * tickrate;
+    const targetWasStable = hasPriorCoverage && priorFrames.every((candidate) => {
+      const group = candidate.components.find((members) => members.includes(target[0]!));
+      return group != null && target.every((member) => group.includes(member));
+    });
+    if (!targetWasStable) {
+      isolatedSince = null;
+      continue;
+    }
+    let persistedFrames = 0;
+    for (let cursor = index; cursor < frames.length; cursor += 1) {
+      const candidate = frames[cursor]!;
+      if (!samePlayers(frame, candidate)) break;
+      const joined = candidate.components.find((group) => group.includes(playerIndex));
+      if (!joined || target.filter((member) => joined.includes(member)).length < 2) break;
+      persistedFrames += 1;
+    }
+    const persistenceSeconds = persistedFrames * tickStep / tickrate;
+    if (persistenceSeconds >= MIN_CONVERGENCE_PERSISTENCE_SECONDS) {
+      result.push({ tick: frame.tick, priorIsolationSeconds: rounded(priorIsolationSeconds)!, joinedComponentSize: component.length, persistenceSeconds: rounded(persistenceSeconds)! });
+    }
+    isolatedSince = null;
+  }
+  return result;
+}
+
+export function extractPlayerPositionRoundFacts(
+  pkg: DemoPackage,
+  matchId: string,
+  context: ReplayRoundContext | null,
+  round: DemoPackage["rounds"][number],
+  frames: readonly TeamSpatialFrame[],
+  grid: CalloutGrid | null,
+  hasNav: boolean,
+): PlayerPositionRoundFact[] {
+  const economyType = (teamKey: "teamA" | "teamB") => teamKey === "teamA" ? round.teamAEconomy : round.teamBEconomy;
+  const configuredOpeningWindow = openingResponsibilityWindow(round, pkg.match.tickrate || 64);
+  const utilityCounts = (playerIndex: number) => {
+    const events = pkg.grenades.filter((grenade) => grenade.roundNumber === round.roundNumber && grenade.throwerIndex === playerIndex);
+    const tickOf = (grenade: (typeof events)[number]) => grenade.throwTick ?? grenade.effectTick;
+    return {
+      utilityUseCount: events.length,
+      openingUtilityUseCount: events.filter((grenade) => {
+        const tick = tickOf(grenade);
+        return tick >= configuredOpeningWindow.startTick && tick < configuredOpeningWindow.endTick;
+      }).length,
+    };
+  };
+  if (!context) {
+    return pkg.players.map((player, playerIndex) => ({
+      analysisVersion: MAP_INTELLIGENCE_FACT_VERSION, matchId, mapName: pkg.match.mapName, roundNumber: round.roundNumber,
+      teamKey: player.teamKey, side: player.teamKey === "teamA" ? round.teamASide : round.teamBSide,
+      playerIndex, steamId64: player.steamId64, economyType: economyType(player.teamKey), openingWindow: null,
+      openingEligibleSeconds: null, openingPositionGroupDwell: [], openingMeanComponentSize: null, openingIsolationSeconds: null,
+      ...utilityCounts(playerIndex),
+      openingPath: [],
+      eligibleSeconds: null, positionGroupDwell: [],
+      unresolvedCalloutSeconds: null, calloutCoverage: null, meanNearestTeammateDistance: null, meanTeamCentroidDistance: null,
+      meanComponentSize: null, isolationSegments: [], rejoinTicks: [], delayedConvergences: [], movementSync: null,
+      freezeAwpOwnership: null, activeAwpSeconds: null, awpShots: null, awpKills: null,
+      availability: availability(null, null, grid, hasNav, Boolean(pkg.shots)),
+    }));
+  }
+  const frameSeconds = context.tickStep / (pkg.match.tickrate || 64);
+  return pkg.players.map((player, playerIndex) => {
+    const track = context.tracks.find((row) => row.playerIndex === playerIndex) ?? null;
+    const side = player.teamKey === "teamA" ? round.teamASide : round.teamBSide;
+    if (!track) {
+      return {
+        analysisVersion: MAP_INTELLIGENCE_FACT_VERSION, matchId, mapName: pkg.match.mapName, roundNumber: round.roundNumber,
+        teamKey: player.teamKey, side, playerIndex, steamId64: player.steamId64, economyType: economyType(player.teamKey), openingWindow: null,
+        openingEligibleSeconds: null, openingPositionGroupDwell: [], openingMeanComponentSize: null, openingIsolationSeconds: null,
+        ...utilityCounts(playerIndex),
+        openingPath: [],
+        eligibleSeconds: null, positionGroupDwell: [],
+        unresolvedCalloutSeconds: null, calloutCoverage: null, meanNearestTeammateDistance: null, meanTeamCentroidDistance: null,
+        meanComponentSize: null, isolationSegments: [], rejoinTicks: [], delayedConvergences: [], movementSync: null,
+        freezeAwpOwnership: null, activeAwpSeconds: null, awpShots: null, awpKills: null,
+        availability: availability(context, null, grid, hasNav, Boolean(pkg.shots)),
+      } satisfies PlayerPositionRoundFact;
+    }
+    const ownFrames = frames.filter((frame) => frame.teamKey === player.teamKey && frame.players.some((row) => row.playerIndex === playerIndex));
+    const openingWindow = configuredOpeningWindow;
+    const openingFrames = ownFrames.filter((frame) => frame.tick >= openingWindow.startTick && frame.tick < openingWindow.endTick);
+    const dwell = new Map<string, number>();
+    let unresolved = 0;
+    const nearest: number[] = [];
+    const centroid: number[] = [];
+    const components: number[] = [];
+    for (const frame of ownFrames) {
+      const sample = frame.players.find((row) => row.playerIndex === playerIndex)!;
+      const group = positionGroupOf(pkg.match.mapName, side, sample.callout ?? "");
+      if (group) dwell.set(group, (dwell.get(group) ?? 0) + frameSeconds);
+      if (!sample.callout) unresolved += frameSeconds;
+      const values = distances(frame, playerIndex);
+      if (values.nearest != null) nearest.push(values.nearest);
+      if (values.centroid != null) centroid.push(values.centroid);
+      if (values.componentSize != null) components.push(values.componentSize);
+    }
+    const isolationSegments: PlayerPositionRoundFact["isolationSegments"] = [];
+    const rejoinTicks: number[] = [];
+    let startTick: number | null = null;
+    for (const frame of ownFrames) {
+      const isolated = distances(frame, playerIndex).componentSize === 1 && frame.players.length > 1;
+      if (isolated && startTick == null) startTick = frame.tick;
+      if (!isolated && startTick != null) {
+        const seconds = (frame.tick - startTick) / (pkg.match.tickrate || 64);
+        if (seconds >= 0.5) isolationSegments.push({ startTick, endTick: frame.tick, seconds: rounded(seconds)! });
+        rejoinTicks.push(frame.tick);
+        startTick = null;
+      }
+    }
+    if (startTick != null && ownFrames.length > 0) {
+      const endTick = ownFrames.at(-1)!.tick + context.tickStep;
+      const seconds = (endTick - startTick) / (pkg.match.tickrate || 64);
+      if (seconds >= 0.5) isolationSegments.push({ startTick, endTick, seconds: rounded(seconds)! });
+    }
+    const eligibleSeconds = ownFrames.length * frameSeconds;
+    const openingEligibleSeconds = openingFrames.length * frameSeconds;
+    const openingDwell = new Map<string, number>();
+    const openingComponents: number[] = [];
+    let openingIsolatedFrames = 0;
+    for (const frame of openingFrames) {
+      const sample = frame.players.find((row) => row.playerIndex === playerIndex)!;
+      const group = positionGroupOf(pkg.match.mapName, side, sample.callout ?? "");
+      if (group) openingDwell.set(group, (openingDwell.get(group) ?? 0) + frameSeconds);
+      const componentSize = distances(frame, playerIndex).componentSize;
+      if (componentSize != null) openingComponents.push(componentSize);
+      if (componentSize === 1 && frame.players.length > 1) openingIsolatedFrames += 1;
+    }
+    const awp = extractAwpRoundFacts(pkg, context, track);
+    const pathStride = Math.max(1, Math.round(5 / frameSeconds));
+    const openingPath = openingFrames.filter((frame, index) => index === 0 || index === openingFrames.length - 1 || index % pathStride === 0).slice(0, 8).map((frame) => {
+      const sample = frame.players.find((row) => row.playerIndex === playerIndex)!;
+      return { tick: frame.tick, callout: sample.callout, positionGroupId: positionGroupOf(pkg.match.mapName, side, sample.callout ?? ""), ...sample.point };
+    });
+    return {
+      analysisVersion: MAP_INTELLIGENCE_FACT_VERSION, matchId, mapName: pkg.match.mapName, roundNumber: round.roundNumber,
+      teamKey: player.teamKey, side, playerIndex, steamId64: player.steamId64, economyType: economyType(player.teamKey),
+      openingWindow,
+      openingEligibleSeconds: rounded(openingEligibleSeconds),
+      openingPositionGroupDwell: [...openingDwell.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([positionGroupId, seconds]) => ({ positionGroupId, seconds: rounded(seconds)!, share: openingEligibleSeconds === 0 ? 0 : rounded(seconds / openingEligibleSeconds)! })),
+      openingMeanComponentSize: rounded(mean(openingComponents)),
+      openingIsolationSeconds: rounded(openingIsolatedFrames * frameSeconds),
+      ...utilityCounts(playerIndex),
+      openingPath,
+      eligibleSeconds: rounded(eligibleSeconds),
+      positionGroupDwell: [...dwell.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([positionGroupId, seconds]) => ({ positionGroupId, seconds: rounded(seconds)!, share: eligibleSeconds === 0 ? 0 : rounded(seconds / eligibleSeconds)! })),
+      unresolvedCalloutSeconds: rounded(unresolved), calloutCoverage: eligibleSeconds === 0 ? null : rounded(1 - unresolved / eligibleSeconds),
+      meanNearestTeammateDistance: rounded(mean(nearest)), meanTeamCentroidDistance: rounded(mean(centroid)), meanComponentSize: rounded(mean(components)),
+      isolationSegments, rejoinTicks,
+      delayedConvergences: detectDelayedConvergences(ownFrames, playerIndex, pkg.match.tickrate || 64, context.tickStep),
+      movementSync: movementSync(ownFrames, playerIndex), ...awp,
+      availability: availability(context, track, grid, hasNav, Boolean(pkg.shots)),
+    } satisfies PlayerPositionRoundFact;
+  });
+}

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

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { FLAG_ALIVE, type DemoPackage } from "@cs2dak/contract";
+import { buildRoundSpatialFrames } from "./spatial.js";
+import type { ReplayRoundContext, ReplayRoundTrack } from "../tactics/replay-round-context.js";
+
+function track(playerIndex: number, x: number, y = 1, z = 1): ReplayRoundTrack {
+  return { playerIndex, teamKey: "teamA", side: "ct", steamId64: String(playerIndex), x: [x], y: [y], z: [z], flags: [FLAG_ALIVE], place: [0], weapon: [0] };
+}
+
+describe("map-intelligence spatial frames", () => {
+  it("drops NaN and Infinity coordinates without discarding valid teammates", () => {
+    const round = { roundNumber: 1, freezeEndTick: 0, endTick: 64, teamASide: "ct", teamBSide: "t" } as DemoPackage["rounds"][number];
+    const context: ReplayRoundContext = { round, startTick: 0, tickStep: 32, frameCount: 1, placeDict: [], weaponDict: [], tracks: [track(0, 1), track(1, Number.NaN), track(2, 1, Number.POSITIVE_INFINITY)] };
+    const frames = buildRoundSpatialFrames(context, null, null);
+    expect(frames).toHaveLength(1);
+    expect(frames[0]?.players.map((player) => player.playerIndex)).toEqual([0]);
+    expect(frames[0]?.components).toEqual([[0]]);
+  });
+
+  it("emits no spatial frame when every alive coordinate is invalid", () => {
+    const round = { roundNumber: 1, freezeEndTick: 0, endTick: 64, teamASide: "ct", teamBSide: "t" } as DemoPackage["rounds"][number];
+    const context: ReplayRoundContext = { round, startTick: 0, tickStep: 32, frameCount: 1, placeDict: [], weaponDict: [], tracks: [track(0, Number.NaN), track(1, Number.NEGATIVE_INFINITY)] };
+    expect(buildRoundSpatialFrames(context, null, null)).toEqual([]);
+  });
+});

package/src/map-intelligence/spatial.ts

@@ -0,0 +1,112 @@
+import { FLAG_ALIVE, type TeamKey } from "@cs2dak/contract";
+import { findNavPath, nearestNavArea, type CalloutGrid, type CompactNav, type Vec3 } from "@cs2dak/maps";
+import { replayCalloutAt, replayPointAt, replayTickAt, type ReplayRoundContext, type ReplayRoundTrack } from "../tactics/replay-round-context.js";
+
+export interface SpatialPlayerSample {
+  playerIndex: number;
+  track: ReplayRoundTrack;
+  point: Vec3;
+  callout: string | null;
+  navAreaId: number | null;
+}
+
+export interface TeamSpatialFrame {
+  tick: number;
+  teamKey: TeamKey;
+  side: "t" | "ct";
+  players: SpatialPlayerSample[];
+  components: number[][];
+}
+
+const COMPONENT_DISTANCE = 800;
+const SAME_CALLOUT_DISTANCE = 1200;
+const MAX_NAV_HOPS = 10;
+const navConnectivityCache = new WeakMap<CompactNav, Map<string, boolean>>();
+
+function distance(a: Vec3, b: Vec3): number {
+  return Math.hypot(a.x - b.x, a.y - b.y, a.z - b.z);
+}
+
+function finitePoint(point: Vec3): boolean {
+  return Number.isFinite(point.x) && Number.isFinite(point.y) && Number.isFinite(point.z);
+}
+
+function navConnected(nav: CompactNav, first: number, second: number): boolean {
+  const key = first < second ? `${first}:${second}` : `${second}:${first}`;
+  const cache = navConnectivityCache.get(nav) ?? new Map<string, boolean>();
+  if (!navConnectivityCache.has(nav)) navConnectivityCache.set(nav, cache);
+  const cached = cache.get(key);
+  if (cached != null) return cached;
+  const forward = findNavPath(nav, first, second);
+  const reverse = forward.length === 0 ? findNavPath(nav, second, first) : forward;
+  const connected = reverse.length > 0 && reverse.length <= MAX_NAV_HOPS;
+  cache.set(key, connected);
+  return connected;
+}
+
+function areConnected(first: SpatialPlayerSample, second: SpatialPlayerSample, nav: CompactNav | null): boolean {
+  const straight = distance(first.point, second.point);
+  if (straight > COMPONENT_DISTANCE && !(first.callout && first.callout === second.callout && straight <= SAME_CALLOUT_DISTANCE)) return false;
+  if (!nav || first.navAreaId == null || second.navAreaId == null) return true;
+  return navConnected(nav, first.navAreaId, second.navAreaId);
+}
+
+function components(players: readonly SpatialPlayerSample[], nav: CompactNav | null): number[][] {
+  const remaining = new Set(players.map((player) => player.playerIndex));
+  const byIndex = new Map(players.map((player) => [player.playerIndex, player]));
+  const groups: number[][] = [];
+  while (remaining.size > 0) {
+    const first = remaining.values().next().value as number;
+    remaining.delete(first);
+    const group = [first];
+    for (let cursor = 0; cursor < group.length; cursor += 1) {
+      const current = byIndex.get(group[cursor]!)!;
+      for (const candidate of [...remaining]) {
+        if (!areConnected(current, byIndex.get(candidate)!, nav)) continue;
+        remaining.delete(candidate);
+        group.push(candidate);
+      }
+    }
+    groups.push(group.sort((a, b) => a - b));
+  }
+  return groups.sort((a, b) => b.length - a.length || a[0]! - b[0]!);
+}
+
+/** Builds only the current round's short-lived spatial samples; never persist this structure. */
+export function buildRoundSpatialFrames(
+  context: ReplayRoundContext,
+  grid: CalloutGrid | null,
+  nav: CompactNav | null,
+): TeamSpatialFrame[] {
+  const frames: TeamSpatialFrame[] = [];
+  for (let frameIndex = 0; frameIndex < context.frameCount; frameIndex += 1) {
+    const tick = replayTickAt(context, frameIndex);
+    if (tick < context.round.freezeEndTick || tick > context.round.endTick) continue;
+    for (const side of ["t", "ct"] as const) {
+      const teamKey: TeamKey = context.round.teamASide === side ? "teamA" : "teamB";
+      const players = context.tracks
+        .filter((track) => track.side === side && ((track.flags[frameIndex] ?? 0) & FLAG_ALIVE) !== 0)
+        .map((track) => {
+          const point = replayPointAt(track, frameIndex);
+          if (!finitePoint(point)) return null;
+          return {
+            playerIndex: track.playerIndex,
+            track,
+            point,
+            callout: replayCalloutAt(context, track, frameIndex, grid),
+            navAreaId: nav ? nearestNavArea(nav, point)?.id ?? null : null,
+          };
+        }).filter((player): player is SpatialPlayerSample => player != null);
+      if (players.length > 0) frames.push({ tick, teamKey, side, players, components: components(players, nav) });
+    }
+  }
+  return frames;
+}
+
+export function mean(values: readonly number[]): number | null {
+  return values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+
+export function rounded(value: number | null, digits = 3): number | null {
+  return value == null ? null : Math.round(value * 10 ** digits) / 10 ** digits;
+}

package/src/map-intelligence/team-awp-round.ts

@@ -0,0 +1,60 @@
+import { FLAG_ALIVE, MAP_INTELLIGENCE_FACT_VERSION, type DemoPackage, type PlayerPositionRoundFact, type TeamAwpRoundFact } from "@cs2dak/contract";
+import { replayWeaponAt, type ReplayRoundContext } from "../tactics/replay-round-context.js";
+import { rounded } from "./spatial.js";
+
+function isAwp(value: string | null): boolean { return value?.trim().toLowerCase().replace(/^weapon_/, "") === "awp"; }
+
+function awpDamageForTeam(pkg: DemoPackage, round: DemoPackage["rounds"][number], teamKey: "teamA" | "teamB"): number | null {
+  // A valid v3 manifest always names damages.json. Keep null only for a genuinely
+  // unavailable package rather than turning an unknown fact into zero.
+  if (!pkg.manifest?.files?.damages) return null;
+  return pkg.damages
+    .filter((damage) => damage.roundNumber === round.roundNumber && damage.tick >= round.freezeEndTick && damage.tick <= round.endTick)
+    .filter((damage) => damage.attackerIndex != null && pkg.players[damage.attackerIndex]?.teamKey === teamKey)
+    .filter((damage) => pkg.players[damage.victimIndex]?.teamKey !== teamKey)
+    .filter((damage) => isAwp(damage.weapon))
+    .reduce((sum, damage) => sum + damage.healthDamage, 0);
+}
+
+function phase(roundNumber: number): TeamAwpRoundFact["scorePhase"] {
+  return roundNumber <= 12 ? "first_half" : roundNumber <= 24 ? "second_half" : "overtime";
+}
+
+export function extractTeamAwpRoundFacts(pkg: DemoPackage, matchId: string, context: ReplayRoundContext | null, rows: PlayerPositionRoundFact[]): TeamAwpRoundFact[] {
+  const round = context?.round ?? pkg.rounds.find((candidate) => candidate.roundNumber === rows[0]?.roundNumber);
+  if (!round) return [];
+  const firstKill = [...pkg.kills].filter((kill) => kill.roundNumber === round.roundNumber).sort((a, b) => a.tick - b.tick)[0] ?? null;
+  const frameSeconds = context ? context.tickStep / (pkg.match.tickrate || 64) : 0;
+  return (["teamA", "teamB"] as const).map((teamKey) => {
+    const side = teamKey === "teamA" ? round.teamASide : round.teamBSide;
+    const teamRows = rows.filter((row) => row.teamKey === teamKey);
+    const roundStartAwpPlayerIndices = teamRows.filter((row) => row.freezeAwpOwnership).map((row) => row.playerIndex).sort((a, b) => a - b);
+    let doubleFrames = 0;
+    if (context) for (let frameIndex = 0; frameIndex < context.frameCount; frameIndex += 1) {
+      const tick = context.startTick + frameIndex * context.tickStep;
+      if (tick < round.freezeEndTick || tick > round.endTick) continue;
+      const active = context.tracks.filter((track) => track.teamKey === teamKey
+        && ((track.flags[frameIndex] ?? 0) & FLAG_ALIVE) !== 0
+        && [track.x[frameIndex], track.y[frameIndex], track.z[frameIndex]].every((value) => value != null && Number.isFinite(value))
+        && isAwp(replayWeaponAt(context, track, frameIndex))).length;
+      if (active >= 2) doubleFrames += 1;
+    }
+    const won = round.winnerTeamKey === teamKey;
+    const firstKillerTeam = firstKill?.killerIndex == null ? null : pkg.players[firstKill.killerIndex]?.teamKey ?? null;
+    const firstVictimTeam = pkg.players[firstKill?.victimIndex ?? -1]?.teamKey ?? null;
+    const available = teamRows.some((row) => row.activeAwpSeconds != null);
+    return {
+      analysisVersion: MAP_INTELLIGENCE_FACT_VERSION, matchId, mapName: pkg.match.mapName, roundNumber: round.roundNumber, teamKey, side,
+      economyType: teamKey === "teamA" ? round.teamAEconomy : round.teamBEconomy,
+      opponentEconomyType: teamKey === "teamA" ? round.teamBEconomy : round.teamAEconomy,
+      scorePhase: phase(round.roundNumber), won, roundStartAwpPlayerIndices,
+      doubleAwpActiveSeconds: context ? rounded(doubleFrames * frameSeconds) : null,
+      awpActiveSeconds: available ? rounded(teamRows.reduce((sum, row) => sum + (row.activeAwpSeconds ?? 0), 0)) : null,
+      awpShots: teamRows.some((row) => row.awpShots != null) ? teamRows.reduce((sum, row) => sum + (row.awpShots ?? 0), 0) : null,
+      awpKills: teamRows.some((row) => row.awpKills != null) ? teamRows.reduce((sum, row) => sum + (row.awpKills ?? 0), 0) : null,
+      awpDamage: awpDamageForTeam(pkg, round, teamKey),
+      openingKills: firstKillerTeam === teamKey ? 1 : 0, openingDeaths: firstVictimTeam === teamKey ? 1 : 0,
+      availability: teamRows[0]?.availability ?? { replay: "missing", nav: "missing", callouts: "missing", shots: "missing" },
+    };
+  });
+}

package/src/map-intelligence/team-shape.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import type { ReplayRoundContext } from "../tactics/replay-round-context.js";
+import type { TeamSpatialFrame } from "./spatial.js";
+import { extractTeamShapeRoundFacts } from "./team-shape.js";
+
+const round = { roundNumber: 1, freezeEndTick: 0, endTick: 3000, teamASide: "t", teamBSide: "ct" } as const;
+const context = { round, startTick: 0, tickStep: 64, frameCount: 48, placeDict: [], weaponDict: [], tracks: [] } as unknown as ReplayRoundContext;
+
+function frame(tick: number, components: number[][]): TeamSpatialFrame {
+  const indices = components.flat();
+  return {
+    tick, teamKey: "teamA", side: "t", components,
+    players: indices.map((playerIndex) => ({ playerIndex, track: {} as never, point: { x: playerIndex, y: 0, z: 0 }, callout: null, navAreaId: null })),
+  };
+}
+
+describe("team-shape compact windows", () => {
+  it.each([
+    [[[0, 1, 2, 3, 4]]],
+    [[[0, 1, 2, 3], [4]]],
+    [[[0, 1, 2], [3, 4]]],
+    [[[0, 1, 2], [3], [4]]],
+    [[[0, 1], [2, 3], [4]]],
+  ])("retains the %s partition with exact component membership", (components) => {
+    const result = extractTeamShapeRoundFacts(
+      { match: { mapName: "de_ancient", tickrate: 64 } }, "m1", context, round,
+      [frame(0, components), frame(64, components)], null, false,
+    )[0]!;
+    expect(result.windows[0]?.partition).toBe(components.map((group) => group.length).sort((a, b) => b - a).join("+"));
+    expect(result.windows[0]?.componentPlayerIndices).toEqual(components);
+  });
+
+  it("keeps late rotation in full-round windows but outside opening responsibility", () => {
+    const opening = [[0, 1, 2, 3], [4]];
+    const late = [[0, 1, 2], [3, 4]];
+    const result = extractTeamShapeRoundFacts(
+      { match: { mapName: "de_ancient", tickrate: 64 } }, "m1", context, round,
+      [frame(0, opening), frame(64, opening), frame(1408, late), frame(1472, late)], null, false,
+    )[0]!;
+    expect(result.openingWindows.map((window) => window.partition)).toEqual(["4+1"]);
+    expect(result.windows.map((window) => window.partition)).toEqual(["4+1", "3+2"]);
+  });
+});

package/src/map-intelligence/team-shape.ts

@@ -0,0 +1,58 @@
+import { MAP_INTELLIGENCE_FACT_VERSION, type MapIntelligenceAvailability, type TeamShapeRoundFact } from "@cs2dak/contract";
+import type { CalloutGrid } from "@cs2dak/maps";
+import type { ReplayRoundContext } from "../tactics/replay-round-context.js";
+import { rounded, type TeamSpatialFrame } from "./spatial.js";
+import { openingResponsibilityWindow } from "./opening-window.js";
+
+function availability(context: ReplayRoundContext | null, grid: CalloutGrid | null, hasNav: boolean, hasShots: boolean): MapIntelligenceAvailability {
+  return { replay: context ? "available" : "missing", nav: hasNav ? "available" : "missing", callouts: context && (context.placeDict.length > 0 || grid) ? "available" : context ? "degraded" : "missing", shots: hasShots ? "available" : "missing" };
+}
+
+function signature(frame: TeamSpatialFrame): string {
+  return frame.components.map((component) => component.join(",")).join("|");
+}
+
+/** Debounce one-frame component flicker while retaining exact component membership in persisted windows. */
+function smoothed(frames: readonly TeamSpatialFrame[]): TeamSpatialFrame[] {
+  return frames.map((frame, index) => {
+    const previous = frames[index - 1];
+    const next = frames[index + 1];
+    return previous && next && signature(previous) === signature(next) ? { ...frame, components: previous.components } : frame;
+  });
+}
+
+export function extractTeamShapeRoundFacts(
+  pkg: { match: { mapName: string; tickrate: number }; shots?: unknown },
+  matchId: string,
+  context: ReplayRoundContext | null,
+  round: { roundNumber: number; teamASide: "t" | "ct"; teamBSide: "t" | "ct" },
+  frames: readonly TeamSpatialFrame[],
+  grid: CalloutGrid | null,
+  hasNav: boolean,
+): TeamShapeRoundFact[] {
+  const frameSeconds = context ? context.tickStep / (pkg.match.tickrate || 64) : 0;
+  const compactWindows = (teamFrames: readonly TeamSpatialFrame[]): TeamShapeRoundFact["windows"] => {
+    const windows: TeamShapeRoundFact["windows"] = [];
+    for (let start = 0; start < teamFrames.length;) {
+      const first = teamFrames[start]!;
+      const key = signature(first);
+      let end = start + 1;
+      while (end < teamFrames.length && signature(teamFrames[end]!) === key) end += 1;
+      const last = teamFrames[end - 1]!;
+      const componentPlayerIndices = first.components.map((component) => [...component]);
+      const componentSizes = componentPlayerIndices.map((component) => component.length).sort((a, b) => b - a);
+      windows.push({ startTick: first.tick, endTick: last.tick + context!.tickStep, coverageSeconds: rounded((last.tick + context!.tickStep - first.tick) / (pkg.match.tickrate || 64))!, componentSizes, partition: componentSizes.join("+"), componentPlayerIndices });
+      start = end;
+    }
+    return windows;
+  };
+  return (["teamA", "teamB"] as const).map((teamKey) => {
+    const teamFrames = smoothed(frames.filter((frame) => frame.teamKey === teamKey));
+    const window = context ? openingResponsibilityWindow(context.round, pkg.match.tickrate || 64) : null;
+    const openingFrames = window ? teamFrames.filter((frame) => frame.tick >= window.startTick && frame.tick < window.endTick) : [];
+    const windows = compactWindows(teamFrames);
+    const openingWindows = compactWindows(openingFrames);
+    const side = teamKey === "teamA" ? round.teamASide : round.teamBSide;
+    return { analysisVersion: MAP_INTELLIGENCE_FACT_VERSION, matchId, mapName: pkg.match.mapName, roundNumber: round.roundNumber, teamKey, side, openingWindow: window, openingWindows, coverageSeconds: teamFrames.length ? rounded(teamFrames.length * frameSeconds) : null, windows, availability: availability(context, grid, hasNav, Boolean(pkg.shots)) } satisfies TeamShapeRoundFact;
+  });
+}