@cs2dak/core 0.2.1 → 2.0.0

package/LICENSE

@@ -1,3 +1,10 @@
+Licensing note / 适用范围
+-------------------------
+The MIT License below applies to this repository EXCEPT apps/dak-studio/,
+which is licensed under the GNU AGPL-3.0-only (see apps/dak-studio/LICENSE).
+Ecosystem packages (@cs2dak/*, python exporter) are MIT; the DAK Studio
+product is AGPL. Third-party attributions: THIRD-PARTY-NOTICES.md.
+
 MIT License
 
 Copyright (c) 2026 Starfie1d

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@cs2dak/core",
-  "version": "0.2.1",
+  "version": "2.0.0",
   "type": "module",
   "license": "MIT",
   "exports": {
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@rivalhub/rival-rating": "^0.1.0",
+    "@rivalhub/rival-rating": "^0.3.0",
     "jszip": "^3.10.1",
-    "@cs2dak/contract": "0.2.1"
+    "@cs2dak/contract": "1.1.0",
+    "@cs2dak/maps": "1.0.0"
   },
   "files": [
     "src"

package/src/duel-window.ts

@@ -0,0 +1,199 @@
+import type { DemoPackage, DuelWindow, PackageGrenade } from "@cs2dak/contract";
+import { decodeDelta } from "@cs2dak/contract";
+import { staticLineOfSight, type TriangleBvh, type Vec3 } from "@cs2dak/maps";
+
+/**
+ * duels.json 满 tick 窗口的可见性原语。
+ *
+ * 围绕 kill/damage 锚点的连续逐 tick 流（x/y/z/yaw/pitch/hp/flash）让我们能在
+ * 交火窗口内严格计算「敌人何时进入有效视野」「开枪前是否完成停稳」「预瞄误差」，
+ * 而不必依赖全局 8Hz replay 或静态 LOS 退化口径。该模块只解码 + 几何判定，不做指标聚合。
+ */
+
+/** 眼睛相对脚底坐标的 z 偏移（游戏单位）。LOS 与视野锥都从眼睛发射。 */
+export const EYE_HEIGHT = 64;
+/** 目标取胸口高度，略低于眼睛，减少擦边遮挡误判。 */
+export const TARGET_HEIGHT = 56;
+/** 有效视野锥半角（度）。CS2 FOV 约 90°，取 40° 半角作为「能交火/已捕获目标」的判定锥。 */
+export const VIEW_CONE_HALF_DEGREES = 40;
+/** CS2 烟雾半径约 144 游戏单位，用于射线-球遮挡判定。 */
+export const SMOKE_RADIUS = 144;
+
+const SMOKE_TYPES = new Set(["smoke", "smokegrenade"]);
+
+export interface DecodedTrack {
+  playerIndex: number;
+  x: number[];
+  y: number[];
+  z: number[];
+  yaw: number[];
+  pitch: number[];
+  hp: number[];
+  flash: number[];
+}
+
+export interface DuelWindowView {
+  window: DuelWindow;
+  startTick: number;
+  tickStep: number;
+  frameCount: number;
+  tracks: Map<number, DecodedTrack>;
+}
+
+const viewCache = new WeakMap<DuelWindow, DuelWindowView>();
+
+function decodeTrack(track: DuelWindow["players"][number], coordScale: number, angleScale: number): DecodedTrack {
+  const scale = (arr: number[], by: number) => arr.map((value) => value / by);
+  return {
+    playerIndex: track.playerIndex,
+    x: scale(decodeDelta(track.x), coordScale),
+    y: scale(decodeDelta(track.y), coordScale),
+    z: scale(decodeDelta(track.z), coordScale),
+    yaw: scale(decodeDelta(track.yaw), angleScale),
+    pitch: scale(decodeDelta(track.pitch), angleScale),
+    hp: [...track.hp],
+    flash: [...track.flash]
+  };
+}
+
+/** 解码一个 duel 窗口的全部玩家轨迹（按 pkg 内 window 实例记忆化）。 */
+export function decodeDuelWindow(pkg: DemoPackage, window: DuelWindow): DuelWindowView {
+  const cached = viewCache.get(window);
+  if (cached) return cached;
+  const coordScale = pkg.duels?.meta.coordScale ?? 1;
+  const angleScale = pkg.duels?.meta.angleScale ?? 10;
+  const tracks = new Map<number, DecodedTrack>();
+  for (const track of window.players) tracks.set(track.playerIndex, decodeTrack(track, coordScale, angleScale));
+  const view: DuelWindowView = {
+    window,
+    startTick: window.startTick,
+    tickStep: window.tickStep,
+    frameCount: window.frameCount,
+    tracks
+  };
+  viewCache.set(window, view);
+  return view;
+}
+
+/** 找到覆盖 (round, tick) 的 duel 窗口；窗口同回合内已合并，故至多一个。 */
+export function findWindowCovering(pkg: DemoPackage, roundNumber: number, tick: number): DuelWindow | null {
+  if (!pkg.duels) return null;
+  return pkg.duels.windows.find((window) =>
+    window.roundNumber === roundNumber &&
+    window.startTick <= tick &&
+    window.startTick + window.tickStep * Math.max(0, window.frameCount - 1) >= tick
+  ) ?? null;
+}
+
+/** tick → 最近帧索引（夹在 [0, frameCount-1]）。 */
+export function frameIndexForTick(view: DuelWindowView, tick: number): number {
+  const raw = Math.round((tick - view.startTick) / view.tickStep);
+  return Math.max(0, Math.min(view.frameCount - 1, raw));
+}
+
+export function tickAtFrame(view: DuelWindowView, frame: number): number {
+  return view.startTick + frame * view.tickStep;
+}
+
+function forwardVector(yawDeg: number, pitchDeg: number): Vec3 {
+  const yaw = (yawDeg * Math.PI) / 180;
+  const pitch = (pitchDeg * Math.PI) / 180;
+  const cosPitch = Math.cos(pitch);
+  return { x: cosPitch * Math.cos(yaw), y: cosPitch * Math.sin(yaw), z: -Math.sin(pitch) };
+}
+
+function normalize(v: Vec3): Vec3 | null {
+  const len = Math.hypot(v.x, v.y, v.z);
+  if (len < 1e-6) return null;
+  return { x: v.x / len, y: v.y / len, z: v.z / len };
+}
+
+function dot(a: Vec3, b: Vec3): number {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+
+/** 准星视线方向与目标方向的三维夹角（度）。yaw+pitch 都参与。null = 重合/无法定义。 */
+export function aimErrorDegrees(yawDeg: number, pitchDeg: number, eye: Vec3, target: Vec3): number | null {
+  const aim = forwardVector(yawDeg, pitchDeg);
+  const toTarget = normalize({ x: target.x - eye.x, y: target.y - eye.y, z: target.z - eye.z });
+  if (!toTarget) return null;
+  const cos = Math.max(-1, Math.min(1, dot(aim, toTarget)));
+  return (Math.acos(cos) * 180) / Math.PI;
+}
+
+/** 目标是否落在视野锥内（半角 VIEW_CONE_HALF_DEGREES）。 */
+export function insideViewCone(yawDeg: number, pitchDeg: number, eye: Vec3, target: Vec3): boolean {
+  const err = aimErrorDegrees(yawDeg, pitchDeg, eye, target);
+  return err != null && err <= VIEW_CONE_HALF_DEGREES;
+}
+
+function pointToSegmentDistance(point: Vec3, a: Vec3, b: Vec3): number {
+  const ab = { x: b.x - a.x, y: b.y - a.y, z: b.z - a.z };
+  const ap = { x: point.x - a.x, y: point.y - a.y, z: point.z - a.z };
+  const denom = dot(ab, ab);
+  const t = denom < 1e-6 ? 0 : Math.max(0, Math.min(1, dot(ap, ab) / denom));
+  const closest = { x: a.x + ab.x * t, y: a.y + ab.y * t, z: a.z + ab.z * t };
+  return Math.hypot(point.x - closest.x, point.y - closest.y, point.z - closest.z);
+}
+
+/** 在 tick 时刻，是否有生效中的烟雾遮挡 from→to 视线。 */
+export function smokeBlocksRay(grenades: PackageGrenade[] | undefined, roundNumber: number, tick: number, from: Vec3, to: Vec3): boolean {
+  if (!grenades || grenades.length === 0) return false;
+  for (const grenade of grenades) {
+    if (grenade.roundNumber !== roundNumber) continue;
+    if (!SMOKE_TYPES.has(grenade.grenade)) continue;
+    const active = grenade.effectTick <= tick && (grenade.destroyTick == null || tick <= grenade.destroyTick);
+    if (!active) continue;
+    if (pointToSegmentDistance(grenade.effectPosition, from, to) <= SMOKE_RADIUS) return true;
+  }
+  return false;
+}
+
+export interface VisibilityContext {
+  pkg: DemoPackage;
+  visibility?: TriangleBvh | null;
+}
+
+/**
+ * attacker 在 frame 是否对 victim 有「有效可见」：双方存活、attacker 未被闪、
+ * victim 落在 attacker 视野锥内、静态 LOS 通透（有 .tri 时）、且无烟雾遮挡。
+ * 缺 .tri 时跳过 LOS（只保留 hp/flash/锥/烟），由调用方决定是否信任。
+ */
+export function isVisibleAt(
+  ctx: VisibilityContext,
+  view: DuelWindowView,
+  attackerIndex: number,
+  victimIndex: number,
+  frame: number
+): boolean {
+  const attacker = view.tracks.get(attackerIndex);
+  const victim = view.tracks.get(victimIndex);
+  if (!attacker || !victim) return false;
+  if ((attacker.hp[frame] ?? 0) <= 0 || (victim.hp[frame] ?? 0) <= 0) return false;
+  if ((attacker.flash[frame] ?? 0) > 0) return false;
+  const eye: Vec3 = { x: attacker.x[frame] ?? 0, y: attacker.y[frame] ?? 0, z: (attacker.z[frame] ?? 0) + EYE_HEIGHT };
+  const target: Vec3 = { x: victim.x[frame] ?? 0, y: victim.y[frame] ?? 0, z: (victim.z[frame] ?? 0) + TARGET_HEIGHT };
+  if (!insideViewCone(attacker.yaw[frame] ?? 0, attacker.pitch[frame] ?? 0, eye, target)) return false;
+  if (ctx.visibility && !staticLineOfSight(ctx.visibility, eye, target)) return false;
+  const tick = tickAtFrame(view, frame);
+  if (smokeBlocksRay(ctx.pkg.grenades, view.window.roundNumber, tick, eye, target)) return false;
+  return true;
+}
+
+/**
+ * 从 fromFrame 向前回溯，返回「当前连续可见段」的起始帧。
+ * - fromFrame 本身不可见 → null（prefire / 未捕获目标，调用方判 prefire）。
+ * - 可见段一直延伸到窗口起点（frame 0）→ 返回 0，但调用方应视为左截断（窗口外早已可见）。
+ */
+export function visibleOnsetFrame(
+  ctx: VisibilityContext,
+  view: DuelWindowView,
+  attackerIndex: number,
+  victimIndex: number,
+  fromFrame: number
+): number | null {
+  if (!isVisibleAt(ctx, view, attackerIndex, victimIndex, fromFrame)) return null;
+  let onset = fromFrame;
+  while (onset > 0 && isVisibleAt(ctx, view, attackerIndex, victimIndex, onset - 1)) onset -= 1;
+  return onset;
+}

package/src/duels.test.ts

@@ -0,0 +1,370 @@
+import { describe, expect, it } from "vitest";
+import type { DemoPackage, Duels, PackageDamage, PackageKill, PackageShots, Replay } from "@cs2dak/contract";
+import { buildTriangleBvh } from "@cs2dak/maps";
+import { buildDuelsSignals, deriveDuels, deriveOpeningDuels } from "./duels.js";
+
+const A = "76561198000000001";
+const B = "76561198000000002";
+const C = "76561198000000003";
+
+// Player indices matching pkg().players order
+const AI = 0;
+const BI = 1;
+const CI = 2;
+
+function damage(row: { attackerIndex: number | null; victimIndex: number; tick: number } & Partial<PackageDamage>): PackageDamage {
+  return {
+    roundNumber: 1,
+    weapon: "ak47",
+    hitgroup: "chest",
+    healthDamage: 40,
+    healthDamageRaw: 40,
+    armorDamage: 0,
+    victimHealthBefore: 100,
+    attackerPosition: { x: 0, y: 0, z: 0 },
+    victimPosition: { x: 100, y: 0, z: 0 },
+    ...row
+  } as PackageDamage;
+}
+
+function kill(row: { killerIndex: number | null; victimIndex: number; tick: number } & Partial<PackageKill>): PackageKill {
+  return {
+    roundNumber: 1,
+    assisterIndex: null,
+    flashAssisterIndex: null,
+    weapon: "ak47",
+    killerActiveWeapon: "ak47",
+    victimActiveWeapon: "ak47",
+    headshot: false,
+    flashAssist: false,
+    tradeKill: false,
+    tradeDeath: false,
+    throughSmoke: false,
+    noScope: false,
+    penetratedObjects: 0,
+    killerPosition: { x: 0, y: 0, z: 0 },
+    victimPosition: { x: 100, y: 0, z: 0 },
+    ...row
+  } as PackageKill;
+}
+
+/** Build columnar PackageShots from a flat shot list. Ticks are delta-encoded per track. */
+function buildShots(
+  shots: Array<{ tick: number; playerIndex: number; roundNumber?: number }>
+): PackageShots {
+  const groups = new Map<string, Array<{ tick: number; playerIndex: number; roundNumber: number }>>();
+  for (const s of shots) {
+    const rn = s.roundNumber ?? 1;
+    const key = `${rn}:${s.playerIndex}`;
+    const arr = groups.get(key) ?? [];
+    arr.push({ tick: s.tick, playerIndex: s.playerIndex, roundNumber: rn });
+    groups.set(key, arr);
+  }
+  const tracks: PackageShots["tracks"] = [];
+  for (const items of groups.values()) {
+    const deltas: number[] = [];
+    let prev = 0;
+    for (const { tick } of items) { deltas.push(tick - prev); prev = tick; }
+    const n = items.length;
+    tracks.push({
+      roundNumber: items[0]!.roundNumber,
+      playerIndex: items[0]!.playerIndex,
+      tick: deltas,
+      weapon: Array<number>(n).fill(0),
+      vx: Array<number>(n).fill(0),
+      vy: Array<number>(n).fill(0),
+      vz: Array<number>(n).fill(0),
+      yaw: Array<number>(n).fill(0),
+      pitch: Array<number>(n).fill(0),
+      x: Array<number>(n).fill(0),
+      y: Array<number>(n).fill(0),
+      z: Array<number>(n).fill(0),
+    });
+  }
+  return { meta: { coordScale: 1, angleScale: 10 }, weaponDict: ["ak47"], tracks };
+}
+
+function encodeDelta(values: number[]): number[] {
+  const out: number[] = [];
+  let prev = 0;
+  for (const value of values) { out.push(value - prev); prev = value; }
+  return out;
+}
+
+function duelTrack(playerIndex: number, abs: { x: number[]; y: number[]; z: number[]; yaw: number[]; pitch: number[]; hp: number[]; flash: number[] }) {
+  return {
+    playerIndex,
+    x: encodeDelta(abs.x),
+    y: encodeDelta(abs.y),
+    z: encodeDelta(abs.z),
+    yaw: encodeDelta(abs.yaw.map((deg) => deg * 10)),
+    pitch: encodeDelta(abs.pitch.map((deg) => deg * 10)),
+    hp: abs.hp,
+    flash: abs.flash
+  };
+}
+
+function pkg(overrides: Partial<DemoPackage>): DemoPackage {
+  return {
+    manifest: {
+      schemaVersion: "cs2-demo-format/3.0",
+      exporter: { name: "test", version: "0" },
+      parser: { name: "test", version: "0" },
+      demo: { hash: null, sourceFileName: null },
+      mapName: "de_mirage",
+      tickrate: 64,
+      exportedAt: "2026-01-01T00:00:00Z",
+      files: {
+        match: "match.json",
+        players: "players.json",
+        rounds: "rounds.json",
+        playerStats: "player-stats.json",
+        playerEconomies: "player-economies.json",
+        kills: "kills.json",
+        damages: "damages.json",
+        blinds: "blinds.json",
+        bombs: "bombs.json",
+        grenades: "grenades.json",
+        clutches: "clutches.json"
+      }
+    },
+    match: {
+      mapName: "de_mirage",
+      tickrate: 64,
+      durationSeconds: 120,
+      serverName: null,
+      source: "test",
+      teamA: { teamKey: "teamA", name: "A", score: 1 },
+      teamB: { teamKey: "teamB", name: "B", score: 0 }
+    },
+    players: [
+      { steamId64: A, name: "A", teamKey: "teamA" },
+      { steamId64: B, name: "B", teamKey: "teamB" },
+      { steamId64: C, name: "C", teamKey: "teamB" }
+    ],
+    rounds: [{
+      roundNumber: 1,
+      startTick: 1,
+      freezeEndTick: 64,
+      endTick: 4096,
+      teamASide: "t",
+      teamBSide: "ct",
+      teamAScoreBefore: 0,
+      teamBScoreBefore: 0,
+      teamAEconomy: "full",
+      teamBEconomy: "full",
+      winnerTeamKey: "teamA",
+      winnerSide: "t"
+    }],
+    playerEconomies: [],
+    playerStats: [],
+    kills: [],
+    damages: [],
+    blinds: [],
+    bombs: [],
+    grenades: [],
+    clutches: [],
+    ...overrides
+  } as DemoPackage;
+}
+
+describe("deriveDuels", () => {
+  it("classifies mutual damage inside the window as contested and computes burst-anchored ttk", () => {
+    const demo = pkg({
+      damages: [
+        damage({ tick: 100, attackerIndex: AI, victimIndex: BI }),
+        damage({ tick: 120, attackerIndex: BI, victimIndex: AI }),
+        damage({ tick: 150, attackerIndex: AI, victimIndex: BI, victimHealthBefore: 40 })
+      ],
+      kills: [kill({ tick: 150, killerIndex: AI, victimIndex: BI })],
+      // A fires at 96,108; B fires at 120 — B response tick 120 is in window [150-192,150]
+      shots: buildShots([
+        { tick: 96, playerIndex: AI },
+        { tick: 108, playerIndex: AI },
+        { tick: 120, playerIndex: BI }
+      ])
+    });
+
+    const rows = deriveDuels(demo);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      killerSteamId64: A,
+      victimSteamId64: B,
+      classification: "contested_duel",
+      fullHealth: true,
+      ttkMs: 843.8 // (150 - 96) / 64 * 1000 = 843.75 → 843.8
+    });
+  });
+
+  it("separates suppressed kill from caught off guard using replay yaw when victim does not return fire", () => {
+    const replay: Replay = {
+      meta: { sampleRate: 8, tickrate: 64, coordScale: 1, angleScale: 10 },
+      weaponDict: [],
+      placeDict: [],
+      rounds: [{
+        roundNumber: 1,
+        startTick: 64,
+        tickStep: 8,
+        frameCount: 1,
+        projectiles: [],
+        players: [
+          {
+            // B faces 180° (toward killer A at x=0, from x=100) → outaimed
+            playerIndex: BI,
+            x: [100], y: [0], z: [0],
+            yaw: [1800], // 180° × angleScale 10
+            pitch: [0], hp: [0], armor: [0], money: [0], equipValue: [0],
+            place: [0], flash: [0], flags: [0], weapon: [-1], grenades: [[]]
+          },
+          {
+            // C faces 90° (perpendicular to killer) → caught_off_guard
+            playerIndex: CI,
+            x: [100], y: [0], z: [0],
+            yaw: [900], // 90° × angleScale 10
+            pitch: [0], hp: [0], armor: [0], money: [0], equipValue: [0],
+            place: [0], flash: [0], flags: [0], weapon: [-1], grenades: [[]]
+          }
+        ]
+      }]
+    };
+
+    const demo = pkg({
+      replay,
+      damages: [
+        damage({ tick: 64, attackerIndex: AI, victimIndex: BI }),
+        damage({ tick: 64, attackerIndex: AI, victimIndex: CI })
+      ],
+      kills: [
+        kill({ tick: 64, killerIndex: AI, victimIndex: BI }),
+        kill({ tick: 64, killerIndex: AI, victimIndex: CI })
+      ],
+      shots: buildShots([{ tick: 64, playerIndex: AI }])
+    });
+
+    const rows = deriveDuels(demo);
+    expect(rows.find((row) => row.victimSteamId64 === B)?.classification).toBe("suppressed_kill");
+    expect(rows.find((row) => row.victimSteamId64 === C)?.classification).toBe("caught_off_guard");
+  });
+
+  it("keeps one-tap ttk near zero when the kill lands on the first burst shot", () => {
+    const demo = pkg({
+      damages: [damage({ tick: 100, attackerIndex: AI, victimIndex: BI, hitgroup: "head", healthDamage: 100 })],
+      kills: [kill({ tick: 100, killerIndex: AI, victimIndex: BI, headshot: true })],
+      shots: buildShots([{ tick: 100, playerIndex: AI }])
+    });
+
+    const row = deriveDuels(demo)[0]!;
+    expect(row.oneShotKill).toBe(true);
+    expect(row.ttkMs).toBe(0);
+  });
+
+  it("uses static LOS for full-tick classification when visibility is provided", () => {
+    const duels: Duels = {
+      meta: { tickrate: 64, sampleRate: 64, coordScale: 1, angleScale: 10, windowBeforeMs: 1000, windowAfterMs: 1000 },
+      windows: [{
+        roundNumber: 1,
+        startTick: 100,
+        tickStep: 1,
+        frameCount: 1,
+        anchors: [{ kind: "kill", tick: 100, attackerIndex: AI, victimIndex: BI }],
+        players: [
+          duelTrack(AI, { x: [-5], y: [0], z: [0], yaw: [0], pitch: [0], hp: [100], flash: [0] }),
+          duelTrack(BI, { x: [5], y: [0], z: [0], yaw: [180], pitch: [0], hp: [100], flash: [0] })
+        ]
+      }]
+    };
+    const demo = pkg({
+      duels,
+      damages: [damage({ tick: 100, attackerIndex: AI, victimIndex: BI })],
+      kills: [kill({ tick: 100, killerIndex: AI, victimIndex: BI })],
+      shots: buildShots([{ tick: 100, playerIndex: AI }])
+    });
+    const wall = buildTriangleBvh([{
+      a: { x: 0, y: -10, z: 0 },
+      b: { x: 0, y: 10, z: 0 },
+      c: { x: 0, y: 0, z: 100 }
+    }]);
+
+    expect(deriveDuels(demo)[0]!.classification).toBe("suppressed_kill");
+    expect(deriveDuels(demo, { visibility: wall })[0]!.classification).toBe("caught_off_guard");
+  });
+
+  it("treats 80 HP as full hp but excludes third-party damage from ttk distribution", () => {
+    const demo = pkg({
+      damages: [
+        damage({ tick: 90, attackerIndex: CI, victimIndex: BI, victimHealthBefore: 100, healthDamage: 20 }),
+        damage({ tick: 100, attackerIndex: AI, victimIndex: BI, victimHealthBefore: 80, healthDamage: 80 })
+      ],
+      kills: [kill({ tick: 100, killerIndex: AI, victimIndex: BI })],
+      shots: buildShots([{ tick: 92, playerIndex: AI }])
+    });
+
+    const signals = buildDuelsSignals(demo);
+    expect(signals.records[0]).toMatchObject({
+      hpBucket: "full_hp",
+      fullHealth: true,
+      victimHealthBefore: 80,
+      thirdParty: true,
+      ttkMs: null
+    });
+    expect(signals.ttk.allFullHp.count).toBe(0);
+  });
+
+  it("excludes through-smoke and wallbang kills from ttk distribution", () => {
+    const demo = pkg({
+      damages: [
+        damage({ tick: 100, attackerIndex: AI, victimIndex: BI }),
+        damage({ tick: 200, attackerIndex: AI, victimIndex: CI })
+      ],
+      kills: [
+        kill({ tick: 100, killerIndex: AI, victimIndex: BI, throughSmoke: true }),
+        kill({ tick: 200, killerIndex: AI, victimIndex: CI, penetratedObjects: 1 })
+      ],
+      shots: buildShots([
+        { tick: 100, playerIndex: AI },
+        { tick: 200, playerIndex: AI }
+      ])
+    });
+
+    const signals = buildDuelsSignals(demo);
+    expect(signals.ttk.allFullHp.count).toBe(0);
+    expect(signals.ttk.byWeapon.find((row) => row.weapon === "ak47")?.distribution.count).toBe(0);
+  });
+
+  it("marks low-hp cleanup pressure without polluting full-hp ttk", () => {
+    const demo = pkg({
+      damages: [damage({ tick: 100, attackerIndex: AI, victimIndex: BI, victimHealthBefore: 79 })],
+      kills: [kill({ tick: 100, killerIndex: AI, victimIndex: BI })],
+      shots: buildShots([{ tick: 90, playerIndex: AI }])
+    });
+
+    const signals = buildDuelsSignals(demo);
+    expect(signals.records[0]).toMatchObject({
+      hpBucket: "low_hp",
+      fullHealth: false,
+      ttkMs: null
+    });
+    expect(signals.ttk.allFullHp.count).toBe(0);
+  });
+});
+
+describe("deriveOpeningDuels", () => {
+  it("returns only the first duel per round", () => {
+    const demo = pkg({
+      damages: [
+        damage({ tick: 100, attackerIndex: AI, victimIndex: BI }),
+        damage({ tick: 200, attackerIndex: AI, victimIndex: CI })
+      ],
+      kills: [
+        kill({ tick: 100, killerIndex: AI, victimIndex: BI }),
+        kill({ tick: 200, killerIndex: AI, victimIndex: CI })
+      ],
+      shots: buildShots([
+        { tick: 100, playerIndex: AI },
+        { tick: 200, playerIndex: AI }
+      ])
+    });
+
+    expect(deriveOpeningDuels(demo).map((row) => row.victimSteamId64)).toEqual([B]);
+  });
+});