@cs2dak/core 1.0.0 → 2.0.0

package/src/duels.ts

@@ -0,0 +1,538 @@
+import type { DemoPackage, DuelWindow, PackageDamage, PackageKill, PackageShots, ReplayPlayerTrack, Vec3 } from "@cs2dak/contract";
+import type { TriangleBvh } from "@cs2dak/maps";
+import { decodeDelta } from "@cs2dak/contract";
+import { decodeDuelWindow, frameIndexForTick, isVisibleAt, type VisibilityContext } from "./duel-window.js";
+import { createResolverFromPackage, type PlayerResolver } from "./resolve.js";
+import { activeDamages, killWeaponName, normalizeWeapon, round } from "./utils.js";
+
+const ENGAGEMENT_GAP_SECONDS = 1.5;
+const CONTESTED_WINDOW_SECONDS = 1.5;
+const DUEL_PAIR_WINDOW_SECONDS = 2;
+const FULL_HEALTH_HP = 80;
+const SUPPRESSED_ANGLE_DEGREES = 60;
+const BURST_GAP_SECONDS = 0.25;
+const RUNNING_SPEED_THRESHOLD = 120;
+
+export type DuelClassification = "contested_duel" | "suppressed_kill" | "caught_off_guard";
+export type DuelHpBucket = "full_hp" | "low_hp";
+
+export interface DuelEvidenceTicks {
+  engagementStartTick: number;
+  engagementEndTick: number;
+  killerFirstShotTick: number | null;
+  victimResponseTick: number | null;
+  killTick: number;
+  windowStartTick?: number;
+  windowEndTick?: number;
+}
+
+export interface DuelRecord {
+  id: string;
+  roundNumber: number;
+  tick: number;
+  engagementId: string;
+  duelPairId: string;
+  killerSteamId64: string;
+  victimSteamId64: string;
+  killerName: string;
+  victimName: string;
+  killerTeamKey: string;
+  victimTeamKey: string;
+  killerIndex: number;
+  victimIndex: number;
+  weapon: string;
+  headshot: boolean;
+  throughSmoke: boolean;
+  penetratedObjects: number;
+  classification: DuelClassification;
+  hpBucket: DuelHpBucket;
+  fullHealth: boolean;
+  victimHealthBefore: number;
+  killerHealthBefore: number | null;
+  ttkMs: number | null;
+  thirdParty: boolean;
+  oneShotKill: boolean;
+  killerPosition: Vec3 | null;
+  victimPosition: Vec3;
+  facedAttacker: boolean | null;
+  evidenceTicks: DuelEvidenceTicks;
+}
+
+export interface TtkDistribution {
+  count: number;
+  median: number | null;
+  p25: number | null;
+  p75: number | null;
+  histogram: Array<{ minMs: number; maxMs: number; count: number }>;
+}
+
+export interface DuelSignals {
+  version: "cs2-demo-analysis-kit/duel-signals-0.1";
+  tickrate: number;
+  records: DuelRecord[];
+  ttk: {
+    allFullHp: TtkDistribution;
+    byWeapon: Array<{ weapon: string; distribution: TtkDistribution }>;
+  };
+}
+
+export interface DuelSignalsOptions {
+  visibility?: TriangleBvh | null;
+}
+
+interface FlatShot {
+  roundNumber: number;
+  playerIndex: number;
+  tick: number;
+  weapon: string;
+  vx: number;
+  vy: number;
+}
+
+interface Engagement {
+  id: string;
+  roundNumber: number;
+  startTick: number;
+  endTick: number;
+  events: Array<{ tick: number; attackerIndex: number | null; victimIndex: number | null; kind: "shot" | "damage" | "kill" }>;
+}
+
+function tickrateOf(pkg: DemoPackage): number {
+  return pkg.match.tickrate || pkg.manifest.tickrate || 64;
+}
+
+function ticks(seconds: number, tickrate: number): number {
+  return Math.round(seconds * tickrate);
+}
+
+function msBetween(startTick: number, endTick: number, tickrate: number): number {
+  return Math.max(0, round((endTick - startTick) / tickrate * 1000, 1));
+}
+
+function pct(sorted: number[], percentile: number): number | null {
+  if (sorted.length === 0) return null;
+  const index = (sorted.length - 1) * percentile;
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  if (lower === upper) return sorted[lower]!;
+  return round(sorted[lower]! + (sorted[upper]! - sorted[lower]!) * (index - lower), 1);
+}
+
+function distribution(values: number[]): TtkDistribution {
+  const sorted = [...values].sort((a, b) => a - b);
+  const buckets = [
+    { minMs: 0, maxMs: 100, count: 0 },
+    { minMs: 100, maxMs: 250, count: 0 },
+    { minMs: 250, maxMs: 500, count: 0 },
+    { minMs: 500, maxMs: 1000, count: 0 },
+    { minMs: 1000, maxMs: 2000, count: 0 },
+    { minMs: 2000, maxMs: Number.POSITIVE_INFINITY, count: 0 }
+  ];
+  for (const value of sorted) {
+    const bucket = buckets.find((row) => value >= row.minMs && value < row.maxMs) ?? buckets[buckets.length - 1]!;
+    bucket.count += 1;
+  }
+  return {
+    count: sorted.length,
+    median: pct(sorted, 0.5),
+    p25: pct(sorted, 0.25),
+    p75: pct(sorted, 0.75),
+    histogram: buckets
+  };
+}
+
+function flattenShots(shots: PackageShots | undefined): FlatShot[] {
+  if (!shots) return [];
+  const rows: FlatShot[] = [];
+  for (const track of shots.tracks) {
+    const trackTicks = decodeDelta(track.tick);
+    for (let i = 0; i < trackTicks.length; i++) {
+      const weaponIdx = track.weapon[i] ?? -1;
+      rows.push({
+        roundNumber: track.roundNumber,
+        playerIndex: track.playerIndex,
+        tick: trackTicks[i]!,
+        weapon: normalizeWeapon(weaponIdx >= 0 ? (shots.weaponDict[weaponIdx] ?? "") : ""),
+        vx: track.vx[i] ?? 0,
+        vy: track.vy[i] ?? 0
+      });
+    }
+  }
+  return rows.sort((a, b) => a.roundNumber - b.roundNumber || a.tick - b.tick);
+}
+
+function buildEngagements(damages: PackageDamage[], pkg: DemoPackage, shots: FlatShot[], tickrate: number): Engagement[] {
+  const maxGap = ticks(ENGAGEMENT_GAP_SECONDS, tickrate);
+  const events = [
+    ...shots.map((shot) => ({
+      roundNumber: shot.roundNumber,
+      tick: shot.tick,
+      attackerIndex: shot.playerIndex,
+      victimIndex: null,
+      kind: "shot" as const
+    })),
+    ...damages.map((damage) => ({
+      roundNumber: damage.roundNumber,
+      tick: damage.tick,
+      attackerIndex: damage.attackerIndex,
+      victimIndex: damage.victimIndex,
+      kind: "damage" as const
+    })),
+    ...pkg.kills.map((kill) => ({
+      roundNumber: kill.roundNumber,
+      tick: kill.tick,
+      attackerIndex: kill.killerIndex,
+      victimIndex: kill.victimIndex,
+      kind: "kill" as const
+    }))
+  ].sort((a, b) => a.roundNumber - b.roundNumber || a.tick - b.tick);
+
+  const out: Engagement[] = [];
+  for (const event of events) {
+    const current = out[out.length - 1];
+    if (!current || current.roundNumber !== event.roundNumber || event.tick - current.endTick > maxGap) {
+      out.push({
+        id: `${event.roundNumber}:${event.tick}:${out.length}`,
+        roundNumber: event.roundNumber,
+        startTick: event.tick,
+        endTick: event.tick,
+        events: [event]
+      });
+    } else {
+      current.endTick = Math.max(current.endTick, event.tick);
+      current.events.push(event);
+    }
+  }
+  return out;
+}
+
+function engagementForKill(engagements: Engagement[], kill: PackageKill): Engagement {
+  return engagements.find((row) => row.roundNumber === kill.roundNumber && row.startTick <= kill.tick && row.endTick >= kill.tick) ?? {
+    id: `${kill.roundNumber}:${kill.tick}:fallback`,
+    roundNumber: kill.roundNumber,
+    startTick: kill.tick,
+    endTick: kill.tick,
+    events: []
+  };
+}
+
+function pairId(roundNumber: number, a: number, b: number): string {
+  const first = Math.min(a, b);
+  const second = Math.max(a, b);
+  return `${roundNumber}:${first}:${second}`;
+}
+
+function yawTo(target: Vec3, from: Vec3): number {
+  return Math.atan2(target.y - from.y, target.x - from.x) * 180 / Math.PI;
+}
+
+function angleDiff(a: number, b: number): number {
+  return Math.abs(((a - b + 540) % 360) - 180);
+}
+
+function replayTrackAtKill(pkg: DemoPackage, kill: PackageKill): { track: ReplayPlayerTrack; frameIndex: number } | null {
+  const replayRound = pkg.replay?.rounds.find((round) => round.roundNumber === kill.roundNumber);
+  if (!replayRound) return null;
+  const track = replayRound.players.find((player) => player.playerIndex === kill.victimIndex);
+  if (!track) return null;
+  const rawIndex = Math.round((kill.tick - replayRound.startTick) / replayRound.tickStep);
+  return { track, frameIndex: Math.max(0, Math.min(replayRound.frameCount - 1, rawIndex)) };
+}
+
+function duelWindowForKill(pkg: DemoPackage, kill: PackageKill): DuelWindow | null {
+  return pkg.duels?.windows.find((window) =>
+    window.roundNumber === kill.roundNumber &&
+    window.anchors.some((anchor) => anchor.tick === kill.tick || Math.abs(anchor.tick - kill.tick) <= 2)
+  ) ?? null;
+}
+
+function victimFrameInDuelWindow(pkg: DemoPackage, kill: PackageKill): { position: Vec3; yaw: number; moving: boolean } | null {
+  const window = duelWindowForKill(pkg, kill);
+  if (!window) return null;
+  const track = window.players.find((player) => player.playerIndex === kill.victimIndex);
+  if (!track) return null;
+  const index = Math.max(0, Math.min(window.frameCount - 1, Math.round((kill.tick - window.startTick) / window.tickStep)));
+  const x = decodeDelta(track.x);
+  const y = decodeDelta(track.y);
+  const z = decodeDelta(track.z);
+  const yaw = decodeDelta(track.yaw);
+  const prevIndex = Math.max(0, index - 1);
+  const dt = Math.max(1, index - prevIndex);
+  const distance = Math.hypot((x[index] ?? 0) - (x[prevIndex] ?? 0), (y[index] ?? 0) - (y[prevIndex] ?? 0));
+  const tickrate = pkg.duels?.meta.sampleRate ?? tickrateOf(pkg);
+  return {
+    position: {
+      x: (x[index] ?? kill.victimPosition.x) / (pkg.duels?.meta.coordScale ?? 1),
+      y: (y[index] ?? kill.victimPosition.y) / (pkg.duels?.meta.coordScale ?? 1),
+      z: (z[index] ?? kill.victimPosition.z) / (pkg.duels?.meta.coordScale ?? 1)
+    },
+    yaw: (yaw[index] ?? 0) / (pkg.duels?.meta.angleScale ?? 10),
+    moving: distance / dt * tickrate > RUNNING_SPEED_THRESHOLD
+  };
+}
+
+function victimFacingState(pkg: DemoPackage, kill: PackageKill): { faced: boolean | null; moving: boolean } {
+  if (!kill.killerPosition) return { faced: null, moving: false };
+  const fromDuel = victimFrameInDuelWindow(pkg, kill);
+  if (fromDuel) {
+    return {
+      faced: angleDiff(fromDuel.yaw, yawTo(kill.killerPosition, fromDuel.position)) <= SUPPRESSED_ANGLE_DEGREES,
+      moving: fromDuel.moving
+    };
+  }
+  const replay = replayTrackAtKill(pkg, kill);
+  if (!replay) return { faced: null, moving: false };
+  const angleScale = pkg.replay?.meta.angleScale ?? 10;
+  const coordScale = pkg.replay?.meta.coordScale ?? 1;
+  const xAbs = decodeDelta(replay.track.x);
+  const yAbs = decodeDelta(replay.track.y);
+  const zAbs = decodeDelta(replay.track.z);
+  const yawAbs = decodeDelta(replay.track.yaw);
+  const prevIndex = Math.max(0, replay.frameIndex - 1);
+  const position = {
+    x: (xAbs[replay.frameIndex] ?? kill.victimPosition.x) / coordScale,
+    y: (yAbs[replay.frameIndex] ?? kill.victimPosition.y) / coordScale,
+    z: (zAbs[replay.frameIndex] ?? kill.victimPosition.z) / coordScale
+  };
+  const distance = Math.hypot(
+    (xAbs[replay.frameIndex] ?? 0) - (xAbs[prevIndex] ?? 0),
+    (yAbs[replay.frameIndex] ?? 0) - (yAbs[prevIndex] ?? 0)
+  ) / coordScale;
+  const moving = distance * (pkg.replay?.meta.sampleRate ?? 8) > RUNNING_SPEED_THRESHOLD;
+  const yaw = (yawAbs[replay.frameIndex] ?? 0) / angleScale;
+  return { faced: angleDiff(yaw, yawTo(kill.killerPosition, position)) <= SUPPRESSED_ANGLE_DEGREES, moving };
+}
+
+function victimResponseTick(shots: FlatShot[], kill: PackageKill, tickrate: number): number | null {
+  if (kill.killerIndex === null) return null;
+  const window = ticks(CONTESTED_WINDOW_SECONDS, tickrate);
+  return shots.find((shot) =>
+    shot.roundNumber === kill.roundNumber &&
+    shot.playerIndex === kill.victimIndex &&
+    Math.abs(shot.tick - kill.tick) <= window
+  )?.tick ?? null;
+}
+
+function burstForKill(shots: FlatShot[], kill: PackageKill, tickrate: number): FlatShot[] {
+  if (kill.killerIndex === null) return [];
+  const maxGap = ticks(BURST_GAP_SECONDS, tickrate);
+  const targetWeapon = normalizeWeapon(killWeaponName(kill));
+  const prior = shots
+    .filter((shot) =>
+      shot.roundNumber === kill.roundNumber &&
+      shot.playerIndex === kill.killerIndex &&
+      shot.tick <= kill.tick &&
+      (!targetWeapon || shot.weapon === targetWeapon)
+    )
+    .sort((a, b) => a.tick - b.tick);
+  const bursts: FlatShot[][] = [];
+  for (const shot of prior) {
+    const current = bursts[bursts.length - 1];
+    if (!current || shot.tick - current[current.length - 1]!.tick > maxGap) bursts.push([shot]);
+    else current.push(shot);
+  }
+  return bursts[bursts.length - 1] ?? [];
+}
+
+function victimHealthBefore(damages: PackageDamage[], kill: PackageKill): number {
+  const direct = damages
+    .filter((row) =>
+      row.roundNumber === kill.roundNumber &&
+      row.victimIndex === kill.victimIndex &&
+      row.tick <= kill.tick &&
+      (kill.killerIndex === null || row.attackerIndex === kill.killerIndex)
+    )
+    .sort((a, b) => a.tick - b.tick)[0];
+  return direct?.victimHealthBefore ?? 100;
+}
+
+function killerHealthBefore(damages: PackageDamage[], kill: PackageKill): number | null {
+  if (kill.killerIndex === null) return null;
+  const prior = damages
+    .filter((row) => row.roundNumber === kill.roundNumber && row.victimIndex === kill.killerIndex && row.tick <= kill.tick)
+    .sort((a, b) => b.tick - a.tick)[0];
+  return prior ? Math.max(0, prior.victimHealthBefore - prior.healthDamage) : 100;
+}
+
+function hasThirdPartyImpact(damages: PackageDamage[], pkg: DemoPackage, kill: PackageKill, engagement: Engagement): boolean {
+  if (kill.killerIndex === null) return true;
+  const pairedWindow = ticks(DUEL_PAIR_WINDOW_SECONDS, tickrateOf(pkg));
+  return damages.some((damage) =>
+    damage.roundNumber === kill.roundNumber &&
+    damage.victimIndex === kill.victimIndex &&
+    damage.attackerIndex !== null &&
+    damage.attackerIndex !== kill.killerIndex &&
+    Math.abs(damage.tick - kill.tick) <= pairedWindow &&
+    damage.tick >= engagement.startTick &&
+    damage.tick <= engagement.endTick
+  );
+}
+
+function isEnemyKill(resolver: PlayerResolver, kill: PackageKill): kill is PackageKill & { killerIndex: number } {
+  if (kill.killerIndex === null || kill.killerIndex === kill.victimIndex) return false;
+  const killer = resolver.byIndexOrNull(kill.killerIndex);
+  const victim = resolver.byIndexOrNull(kill.victimIndex);
+  return Boolean(killer && victim && killer.teamKey !== victim.teamKey);
+}
+
+function isCleanDuelRecord(record: DuelRecord): boolean {
+  return !record.thirdParty && !record.throughSmoke && record.penetratedObjects <= 0;
+}
+
+/**
+ * 对枪三分类（视野时间线版）：用「受害者 → 击杀者」可见性判定，比旧的 ±1.5s 任意开枪更准。
+ * - contested_duel：受害者在交火中对击杀者造成伤害，或在 [击杀者首发, 击杀] 间「看得到击杀者」时开过枪。
+ * - suppressed_kill：受害者死前曾有「看得到击杀者」的机会，但没有有效还手。
+ * - caught_off_guard：受害者死前从未获得有效可见机会（无有效视野 / 被预瞄）。
+ * 可见性用 duels 满 tick 窗口的视野锥 + hp + flash + 烟雾 + 静态 LOS（调用方传入 .tri 时）。
+ * 无窗口时回退启发式。
+ */
+function classifyDuel(
+  ctx: VisibilityContext,
+  damages: PackageDamage[],
+  kill: PackageKill & { killerIndex: number },
+  window: DuelWindow | null,
+  shots: FlatShot[],
+  engagement: Engagement,
+  killerFirstShotTick: number | null,
+  fallback: DuelClassification
+): DuelClassification {
+  if (!window) return fallback;
+  const view = decodeDuelWindow(ctx.pkg, window);
+  const victimDamagedKiller = damages.some((damage) =>
+    damage.roundNumber === kill.roundNumber &&
+    damage.attackerIndex === kill.victimIndex &&
+    damage.victimIndex === kill.killerIndex &&
+    damage.tick >= engagement.startTick &&
+    damage.tick <= kill.tick
+  );
+  if (victimDamagedKiller) return "contested_duel";
+  const contestStart = killerFirstShotTick ?? engagement.startTick;
+  const victimShots = shots.filter((shot) =>
+    shot.roundNumber === kill.roundNumber && shot.playerIndex === kill.victimIndex && shot.tick >= contestStart && shot.tick <= kill.tick
+  );
+  for (const shot of victimShots) {
+    if (isVisibleAt(ctx, view, kill.victimIndex, kill.killerIndex, frameIndexForTick(view, shot.tick))) return "contested_duel";
+  }
+  const killFrame = frameIndexForTick(view, kill.tick);
+  for (let frame = 0; frame <= killFrame; frame++) {
+    if (isVisibleAt(ctx, view, kill.victimIndex, kill.killerIndex, frame)) return "suppressed_kill";
+  }
+  return "caught_off_guard";
+}
+
+/** buildDuelsSignals 默认路径按 pkg 实例记忆化；传入 visibility 时结果依赖 BVH，跳过全局缓存。 */
+const duelSignalsCache = new WeakMap<DemoPackage, DuelSignals>();
+
+export function buildDuelsSignals(input: DemoPackage, options: DuelSignalsOptions = {}): DuelSignals {
+  const cacheable = options.visibility == null;
+  const cached = cacheable ? duelSignalsCache.get(input) : undefined;
+  if (cached) return cached;
+  const pkg = input;
+  const resolver = createResolverFromPackage(pkg);
+  const tickrate = tickrateOf(pkg);
+  const ctx: VisibilityContext = { pkg, visibility: options.visibility };
+  const shots = flattenShots(pkg.shots);
+  const damages = activeDamages(pkg);
+  const engagements = buildEngagements(damages, pkg, shots, tickrate);
+  const records = pkg.kills
+    .filter((kill) => isEnemyKill(resolver, kill))
+    .map((kill, index): DuelRecord => {
+      const killer = resolver.byIndex(kill.killerIndex!);
+      const victim = resolver.byIndex(kill.victimIndex);
+      const engagement = engagementForKill(engagements, kill);
+      const responseTick = victimResponseTick(shots, kill, tickrate);
+      const facing = victimFacingState(pkg, kill);
+      const burst = burstForKill(shots, kill, tickrate);
+      const window = duelWindowForKill(pkg, kill);
+      // 有 duels 满 tick 窗口时用「受害者 → 击杀者」可见性时间线判定；否则回退到还手/朝向启发式。
+      const fallbackClass: DuelClassification = responseTick != null
+        ? "contested_duel"
+        : facing.faced === true && !facing.moving
+          ? "suppressed_kill"
+          : "caught_off_guard";
+      const classification = classifyDuel(ctx, damages, kill, window, shots, engagement, burst[0]?.tick ?? null, fallbackClass);
+      const hp = victimHealthBefore(damages, kill);
+      const hpBucket: DuelHpBucket = hp >= FULL_HEALTH_HP ? "full_hp" : "low_hp";
+      const thirdParty = hasThirdPartyImpact(damages, pkg, kill, engagement);
+      const ttkMs = hpBucket === "full_hp" && !thirdParty && burst.length > 0
+        ? msBetween(burst[0]!.tick, kill.tick, tickrate)
+        : null;
+      return {
+        id: `${kill.roundNumber}-${kill.tick}-${kill.killerIndex}-${kill.victimIndex}-${index}`,
+        roundNumber: kill.roundNumber,
+        tick: kill.tick,
+        engagementId: engagement.id,
+        duelPairId: pairId(kill.roundNumber, kill.killerIndex!, kill.victimIndex),
+        killerSteamId64: killer.steamId64,
+        victimSteamId64: victim.steamId64,
+        killerName: killer.name,
+        victimName: victim.name,
+        killerTeamKey: killer.teamKey,
+        victimTeamKey: victim.teamKey,
+        killerIndex: kill.killerIndex!,
+        victimIndex: kill.victimIndex,
+        weapon: killWeaponName(kill),
+        headshot: kill.headshot,
+        throughSmoke: kill.throughSmoke,
+        penetratedObjects: kill.penetratedObjects ?? 0,
+        classification,
+        hpBucket,
+        fullHealth: hpBucket === "full_hp",
+        victimHealthBefore: hp,
+        killerHealthBefore: killerHealthBefore(damages, kill),
+        ttkMs,
+        thirdParty,
+        oneShotKill: burst.length === 1,
+        killerPosition: kill.killerPosition,
+        victimPosition: kill.victimPosition,
+        facedAttacker: facing.faced,
+        evidenceTicks: {
+          engagementStartTick: engagement.startTick,
+          engagementEndTick: engagement.endTick,
+          killerFirstShotTick: burst[0]?.tick ?? null,
+          victimResponseTick: responseTick,
+          killTick: kill.tick,
+          windowStartTick: window?.startTick,
+          windowEndTick: window ? window.startTick + window.tickStep * Math.max(0, window.frameCount - 1) : undefined
+        }
+      };
+    })
+    .sort((a, b) => a.roundNumber - b.roundNumber || a.tick - b.tick);
+
+  const fullHpTtk = records
+    .filter((record) => record.hpBucket === "full_hp" && isCleanDuelRecord(record) && record.ttkMs != null)
+    .map((record) => record.ttkMs!);
+  const weaponKeys = [...new Set(records.map((record) => normalizeWeapon(record.weapon)))].sort();
+  const signals: DuelSignals = {
+    version: "cs2-demo-analysis-kit/duel-signals-0.1",
+    tickrate,
+    records,
+    ttk: {
+      allFullHp: distribution(fullHpTtk),
+      byWeapon: weaponKeys.map((weapon) => ({
+        weapon,
+        distribution: distribution(records
+          .filter((record) => normalizeWeapon(record.weapon) === weapon && record.hpBucket === "full_hp" && isCleanDuelRecord(record) && record.ttkMs != null)
+          .map((record) => record.ttkMs!))
+      }))
+    }
+  };
+  if (cacheable) duelSignalsCache.set(input, signals);
+  return signals;
+}
+
+export function deriveDuels(pkg: DemoPackage, options: DuelSignalsOptions = {}): DuelRecord[] {
+  return buildDuelsSignals(pkg, options).records;
+}
+
+export function deriveOpeningDuels(pkg: DemoPackage, options: DuelSignalsOptions = {}): DuelRecord[] {
+  const seen = new Set<number>();
+  const rows: DuelRecord[] = [];
+  for (const duel of deriveDuels(pkg, options)) {
+    if (seen.has(duel.roundNumber)) continue;
+    seen.add(duel.roundNumber);
+    rows.push(duel);
+  }
+  return rows;
+}

package/src/fixture-invariants.test.ts

@@ -0,0 +1,40 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { analyzeDemoPackage, loadDemoPackageFromZip } from "./index";
+
+const cologneSmokeFixture = fileURLToPath(
+  new URL("../../../fixtures/input/cologne-major-2026-stage3-smoke-de_nuke.zip", import.meta.url)
+);
+
+describe("fixture invariants", () => {
+  it("loads the Cologne Major cs2df 3.1.0 smoke fixture end-to-end", async () => {
+    const pkg = await loadDemoPackageFromZip(await readFile(cologneSmokeFixture));
+    const bundle = analyzeDemoPackage(pkg);
+
+    expect(pkg.manifest.schemaVersion).toBe("cs2-demo-format/3.0");
+    expect(pkg.manifest.exporter).toMatchObject({ name: "cs2df", version: "3.1.0" });
+    expect(pkg.manifest.demo?.sourceFileName).toBe("aurora-vs-9z-m1-nuke.dem");
+    expect(pkg.match.mapName).toBe("de_nuke");
+    expect(pkg.match.teamA.name).toBe("9z");
+    expect(pkg.match.teamB.name).toBe("Aurora Gaming");
+    expect([pkg.match.teamA.score, pkg.match.teamB.score]).toEqual([1, 13]);
+    expect(pkg.players).toHaveLength(10);
+    expect(pkg.rounds).toHaveLength(14);
+    expect(pkg.kills).toHaveLength(94);
+    expect(pkg.damages).toHaveLength(352);
+    expect(pkg.bombs).toHaveLength(41);
+    expect(pkg.grenades).toHaveLength(212);
+    expect(pkg.shots).toMatchObject({ meta: expect.any(Object), tracks: expect.any(Array) });
+    expect(pkg.replay).toMatchObject({ meta: expect.any(Object), rounds: expect.any(Array) });
+    expect(pkg.duels).toMatchObject({ meta: expect.any(Object), windows: expect.any(Array) });
+
+    expect(bundle.qa.ok).toBe(true);
+    expect(bundle.qa.summary.issueCount).toBe(0);
+    expect(bundle.scoreboard).toHaveLength(10);
+    expect(bundle.economy).toHaveLength(14);
+    expect(bundle.timeline.length).toBeGreaterThan(pkg.kills.length);
+    expect(bundle.heatmap.length).toBeGreaterThan(pkg.damages.length);
+    expect(bundle.provenance.sourceDemoHash).toBe(pkg.manifest.demo?.hash);
+  });
+});