cs2df 3.0.0__tar.gz → 3.0.3__tar.gz

{cs2df-3.0.0 → cs2df-3.0.3}/.gitignore

@@ -4,6 +4,7 @@ dist/
 *.d.ts
 .DS_Store
 .omc/
+.codegraph/
 __pycache__/
 *.py[cod]
 .pytest_cache/

{cs2df-3.0.0 → cs2df-3.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cs2df
-Version: 3.0.0
+Version: 3.0.3
 Summary: Reference exporter & validator CLI for cs2-demo-format v3 (CS2 demo → ZIP data package)
 Project-URL: Homepage, https://github.com/Starfie1d1272/cs2-demo-format
 Project-URL: Repository, https://github.com/Starfie1d1272/cs2-demo-format

{cs2df-3.0.0 → cs2df-3.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cs2df"
-version = "3.0.0"
+version = "3.0.3"
 description = "Reference exporter & validator CLI for cs2-demo-format v3 (CS2 demo → ZIP data package)"
 readme = "README.md"
 requires-python = ">=3.11"

{cs2df-3.0.0 → cs2df-3.0.3}/src/cs2df/__init__.py

@@ -5,7 +5,7 @@ demoparser2 / pandas stack installed. Heavy imports are deferred into the
 submodules that need them.
 """
 
-__version__ = "3.0.0"
+__version__ = "3.0.3"
 
 SCHEMA_VERSION = "cs2-demo-format/3.0"
 EXPORTER_NAME = "cs2df"

{cs2df-3.0.0 → cs2df-3.0.3}/src/cs2df/enums.py

@@ -124,6 +124,14 @@ _GRENADE_ITEMS = {
     "Smoke Grenade", "Flashbang", "High Explosive Grenade",
     "Incendiary Grenade", "Molotov", "Decoy Grenade",
 }
+_GRENADE_ITEM_TO_TYPE = {
+    "Smoke Grenade": "smoke",
+    "Flashbang": "flashbang",
+    "High Explosive Grenade": "hegrenade",
+    "Incendiary Grenade": "incendiary",
+    "Molotov": "molotov",
+    "Decoy Grenade": "decoy",
+}
 _PISTOL_ITEMS = {
     "Glock-18", "USP-S", "P2000", "Dual Berettas", "P250", "Five-SeveN",
     "Tec-9", "CZ75-Auto", "Desert Eagle", "R8 Revolver",
@@ -141,27 +149,28 @@ _PRIMARY_ITEMS = {
 }
 
 
-def classify_inventory(items: Any) -> tuple[str | None, str | None, int]:
-    """Return (primaryWeapon, secondaryWeapon, grenadeCount) from an inventory list.
+def classify_inventory(items: Any) -> tuple[str | None, str | None, int, list[str]]:
+    """Return (primaryWeapon, secondaryWeapon, grenadeCount, grenades) from an inventory list.
 
     primary/secondary are the first matching gun in each slot; grenadeCount counts
-    grenade items (max 4 per CS2 rules, not clamped here). Non-weapons (knife, C4,
-    Zeus) and unknown names are ignored.
+    grenade items (max 4 per CS2 rules, not clamped here), while grenades preserves
+    the normalized held utility types. Non-weapons (knife, C4, Zeus) and unknown
+    names are ignored.
     """
     if not isinstance(items, (list, tuple)):
-        return None, None, 0
+        return None, None, 0, []
     primary: str | None = None
     secondary: str | None = None
-    grenades = 0
+    grenade_types: list[str] = []
     for it in items:
         name = str(it or "").strip()
         if name in _GRENADE_ITEMS:
-            grenades += 1
+            grenade_types.append(_GRENADE_ITEM_TO_TYPE[name])
         elif primary is None and name in _PRIMARY_ITEMS:
             primary = name
         elif secondary is None and name in _PISTOL_ITEMS:
             secondary = name
-    return primary, secondary, grenades
+    return primary, secondary, len(grenade_types), grenade_types
 
 
 # ── active weapon normalization ───────────────────────────────────────────────

{cs2df-3.0.0 → cs2df-3.0.3}/src/cs2df/events.py

@@ -121,7 +121,8 @@ def _active_event_round_number(round_model: _RoundModel, row: dict) -> int | Non
         return None
     tick = int(row.get("tick") or 0)
     window = round_model.window_for_round(n)
-    if window is None or tick < window.freeze_end_tick or tick > window.end_tick:
+    event_end = round_model.event_end_tick(n)
+    if window is None or event_end is None or tick < window.freeze_end_tick or tick > event_end:
         return None
     return n
 
@@ -372,7 +373,8 @@ def build_bombs(raw: dict, players: PlayerDirectory, round_model: _RoundModel) -
                 continue
             tick = int(r.get("tick") or 0)
             window = round_model.window_for_round(n)
-            if window is None or tick < window.freeze_end_tick or tick > window.end_tick:
+            event_end = round_model.event_end_tick(n)
+            if window is None or event_end is None or tick < window.freeze_end_tick or tick > event_end:
                 continue
             actor_sid = _sid(r.get("user_steamid") or r.get("steamid") or r.get("userid"))
             site = bomb_site_from_place(r.get("user_last_place_name"))
@@ -431,7 +433,8 @@ def build_grenades(raw: dict, players: PlayerDirectory, round_model: _RoundModel
             continue
         tick = int(r.get("tick") or 0)
         window = round_model.window_for_round(n)
-        if window is None or tick < window.freeze_end_tick or tick > window.end_tick:
+        event_end = round_model.event_end_tick(n)
+        if window is None or event_end is None or tick < window.freeze_end_tick or tick > event_end:
             continue
         gtype = str(r.get("_grenade_type") or "")
         if gtype not in _GRENADE_TYPE_ENUM:
@@ -460,7 +463,7 @@ def build_grenades(raw: dict, players: PlayerDirectory, round_model: _RoundModel
         if not _is_valid_side(round_model.side_map.get((n, players.team(thrower_sid)), "unknown")):
             continue
         if destroy_tick is not None and (
-            destroy_tick < tick or window is None or destroy_tick > window.end_tick
+            destroy_tick < tick or event_end is None or destroy_tick > event_end
         ):
             destroy_tick = None
 
@@ -489,13 +492,13 @@ def build_grenades(raw: dict, players: PlayerDirectory, round_model: _RoundModel
     for g in out:
         if g["grenade"] != "molotov" or g["destroyTick"] is not None:
             continue
-        window = round_model.window_for_round(g["roundNumber"])
+        event_end = round_model.event_end_tick(g["roundNumber"])
         best = None
         best_d2 = None
         for e in expires:
             if e["used"] or e["rn"] != g["roundNumber"] or e["tick"] < g["effectTick"]:
                 continue
-            if window is not None and e["tick"] > window.end_tick:
+            if event_end is not None and e["tick"] > event_end:
                 continue
             ep, gp = e["pos"], g["effectPosition"]
             d2 = (ep["x"] - gp["x"]) ** 2 + (ep["y"] - gp["y"]) ** 2
@@ -521,11 +524,11 @@ def build_grenades(raw: dict, players: PlayerDirectory, round_model: _RoundModel
         eid = g.pop("_entityId", None)
         if g["grenade"] != "smoke" or eid is None:
             continue
-        window = round_model.window_for_round(g["roundNumber"])
+        event_end = round_model.event_end_tick(g["roundNumber"])
         for e in smoke_index.get((g["roundNumber"], eid), []):
             if e["tick"] < g["effectTick"]:
                 continue
-            if window is not None and e["tick"] > window.end_tick:
+            if event_end is not None and e["tick"] > event_end:
                 continue
             g["destroyTick"] = e["tick"]
             break
@@ -653,7 +656,7 @@ def build_economies(raw: dict, players: PlayerDirectory, round_model: _RoundMode
         equip = int(_safe_float(r.get("current_equip_value"), 0))
         start_money = int(_safe_float(r.get("start_balance"), 0))
         eco_type = _economy_type(spent, start_money, equip, n)
-        primary, secondary, grenade_count = classify_inventory(r.get("inventory"))
+        primary, secondary, grenade_count, grenades = classify_inventory(r.get("inventory"))
 
         out.append({
             "roundNumber": n,
@@ -668,6 +671,7 @@ def build_economies(raw: dict, players: PlayerDirectory, round_model: _RoundMode
             "primaryWeapon": primary,
             "secondaryWeapon": secondary,
             "grenadeCount": grenade_count,
+            "grenades": grenades,
         })
         team_round_types.setdefault((n, key), []).append(eco_type)
 

{cs2df-3.0.0 → cs2df-3.0.3}/src/cs2df/parse.py

@@ -48,13 +48,14 @@ _GRENADE_EVENTS = [
 # (raw userid is an entity slot, not a Steam64).
 _GRENADE_PLAYER_FIELDS = ["steamid", "X", "Y", "Z"]
 
-# Per-frame props for the replay grid. No `inventory`, no `has_c4` — see module
-# docstring. `balance` is the cash account (replay `money` column);
+# Per-frame props for the replay grid. `inventory` is sampled here so replay
+# consumers can render current held utility; full-tick paths still avoid it.
+# `balance` is the cash account (replay `money` column);
 # `current_equip_value` is the equipment value (`equipValue` column).
 _REPLAY_PROPS = [
     "steamid", "team_num", "X", "Y", "Z", "yaw", "pitch",
     "health", "armor", "active_weapon_name", "flash_duration",
-    "balance", "current_equip_value", "has_defuser", "last_place_name",
+    "balance", "current_equip_value", "has_defuser", "last_place_name", "inventory",
 ]
 
 # Lean per-frame props for full-tick duel windows.
@@ -129,6 +130,68 @@ def _safe_ticks_df(parser: DemoParser, props: list[str], ticks: list[int]) -> "p
     return None
 
 
+def _rebuild_blinds(parser: DemoParser, detonates: list[dict]) -> list[dict]:
+    """Reconstruct per-victim blind rows from flashbang_detonate + flash_duration.
+
+    Newer demoparser2 builds no longer emit the player_blind game event; the only
+    flash signal left is flashbang_detonate (thrower + position) plus the
+    per-player flash_duration tick property. A player whose flash_duration jumps
+    across a detonate tick was blinded by that flash; the post-detonate value is
+    the (remaining ≈ full) blind duration. When several flashes pop on the same
+    tick, attribute by closest detonate position.
+    """
+    det_by_tick: dict[int, list[dict]] = {}
+    for d in detonates:
+        tick = int(d.get("tick") or 0)
+        if tick > 0:
+            det_by_tick.setdefault(tick, []).append(d)
+    if not det_by_tick:
+        return []
+    det_ticks = sorted(det_by_tick)
+    sample_ticks = sorted({t - 1 for t in det_ticks} | {t + 2 for t in det_ticks})
+    df = _safe_ticks_df(parser, ["flash_duration", "X", "Y"], sample_ticks)
+    if df is None or df.empty or "flash_duration" not in df.columns:
+        return []
+
+    state: dict[tuple[int, str], tuple[float, float | None, float | None]] = {}
+    has_xy = "X" in df.columns and "Y" in df.columns
+    for row in df.itertuples(index=False):
+        d = row._asdict()
+        sid = d.get("steamid")
+        if sid is None:
+            continue
+        fd = float(d.get("flash_duration") or 0.0)
+        x = float(d["X"]) if has_xy and d.get("X") is not None else None
+        y = float(d["Y"]) if has_xy and d.get("Y") is not None else None
+        state[(int(d["tick"]), str(int(sid)))] = (fd, x, y)
+
+    out: list[dict] = []
+    sids = {sid for (_, sid) in state}
+    for tick in det_ticks:
+        dets = det_by_tick[tick]
+        for sid in sids:
+            before = state.get((tick - 1, sid), (0.0, None, None))[0]
+            after_state = state.get((tick + 2, sid))
+            if after_state is None:
+                continue
+            after, px, py = after_state
+            if after <= before + 0.1:
+                continue
+            det = dets[0]
+            if len(dets) > 1 and px is not None and py is not None:
+                det = min(
+                    dets,
+                    key=lambda d: (float(d.get("x") or 0.0) - px) ** 2 + (float(d.get("y") or 0.0) - py) ** 2,
+                )
+            out.append({
+                "tick": tick,
+                "attacker_steamid": det.get("user_steamid"),
+                "user_steamid": sid,
+                "blind_duration": after,
+            })
+    return out
+
+
 def parse_demo(dem_path: str, *, sample_rate: int = 8, research: bool = False,
                window_before_ms: int = 2000, window_after_ms: int = 1000,
                progress: ProgressFn | None = None) -> dict[str, Any]:
@@ -171,6 +234,14 @@ def parse_demo(dem_path: str, *, sample_rate: int = 8, research: bool = False,
     )
     _record("parse.roundEvents", stage_started)
 
+    # demoparser2 新版已移除 player_blind 事件：用 flashbang_detonate + flash_duration
+    # tick 采样重建逐人致盲数据（旧版仍发 player_blind 时维持原路径）。
+    if not g_round["player_blind"]:
+        stage_started = time.perf_counter()
+        detonates = _safe_event(p, "flashbang_detonate")
+        g_round["player_blind"] = _rebuild_blinds(p, detonates)
+        _record("parse.blindRebuild", stage_started)
+
     _p("kills", 0.12)
     stage_started = time.perf_counter()
     deaths = _safe_event(p, "player_death",
@@ -280,7 +351,7 @@ def parse_demo(dem_path: str, *, sample_rate: int = 8, research: bool = False,
     stage_started = time.perf_counter()
     round_ends = g_round["round_end"]
     step = max(1, tickrate // max(1, sample_rate))
-    replay_ticks = _build_sample_ticks(round_ends, round_freeze_ends, step)
+    replay_ticks = _build_sample_ticks(round_ends, round_freeze_ends, g_round["round_start"], step)
     replay_df = _safe_ticks_df(p, _REPLAY_PROPS, replay_ticks) if replay_ticks else None
     _record("parse.replayGrid", stage_started)
 
@@ -297,7 +368,8 @@ def parse_demo(dem_path: str, *, sample_rate: int = 8, research: bool = False,
         _p("duel windows (full tick)", 0.78)
         anchor_ticks = [int(r.get("tick") or 0) for r in deaths + hurts]
         duel_windows = _merge_windows(anchor_ticks, round_ends, round_freeze_ends,
-                                      tickrate, window_before_ms, window_after_ms)
+                                      g_round["round_start"], tickrate,
+                                      window_before_ms, window_after_ms)
         duel_ticks: list[int] = []
         for start, end in duel_windows:
             duel_ticks.extend(range(start, end + 1))
@@ -373,34 +445,50 @@ def _freeze_by_round(round_freeze_ends: list[dict]) -> dict[int, int]:
     return out
 
 
+def _round_starts_by_round(round_starts: list[dict]) -> dict[int, int]:
+    out: dict[int, int] = {}
+    for r in round_starts:
+        rn = int(r.get("total_rounds_played") or 0) + 1
+        t = int(r.get("tick") or 0)
+        if rn > 0 and t > 0 and rn not in out:
+            out[rn] = t
+    return out
+
+
 def _round_spans(round_ends: list[dict],
-                 round_freeze_ends: list[dict]) -> list[tuple[int, int]]:
-    """[(freeze_end_tick, end_tick)] for rounds with a valid window."""
+                 round_freeze_ends: list[dict],
+                 round_starts: list[dict] | None = None) -> list[tuple[int, int]]:
+    """[(freeze_end_tick, event_end_tick)] for rounds with a valid window."""
     freeze = _freeze_by_round(round_freeze_ends)
+    starts = _round_starts_by_round(round_starts or [])
     spans: list[tuple[int, int]] = []
     for r in round_ends:
         rn = int(r.get("total_rounds_played") or 0)
         end_t = int(r.get("tick") or 0)
+        next_start_t = starts.get(rn + 1)
+        event_end_t = next_start_t - 1 if next_start_t is not None else end_t
         start_t = freeze.get(rn, 0)
-        if start_t > 0 and end_t > start_t:
-            spans.append((start_t, end_t))
+        if start_t > 0 and event_end_t > start_t:
+            spans.append((start_t, event_end_t))
     return spans
 
 
 def _build_sample_ticks(round_ends: list[dict], round_freeze_ends: list[dict],
+                        round_starts: list[dict],
                         step: int) -> list[int]:
-    """Sorted unique sample ticks at interval `step` within active play."""
+    """Sorted unique sample ticks through the post-round tail."""
     ticks: list[int] = []
-    for start_t, end_t in _round_spans(round_ends, round_freeze_ends):
-        ticks.extend(range(start_t, end_t, step))
+    for start_t, end_t in _round_spans(round_ends, round_freeze_ends, round_starts):
+        ticks.extend(range(start_t, end_t + 1, step))
     return sorted(set(ticks))
 
 
 def _merge_windows(anchor_ticks: list[int], round_ends: list[dict],
-                   round_freeze_ends: list[dict], tickrate: int,
+                   round_freeze_ends: list[dict], round_starts: list[dict],
+                   tickrate: int,
                    before_ms: int, after_ms: int) -> list[tuple[int, int]]:
     """Merged [start, end] full-tick combat windows, clamped to round spans."""
-    spans = _round_spans(round_ends, round_freeze_ends)
+    spans = _round_spans(round_ends, round_freeze_ends, round_starts)
     if not spans or not anchor_ticks:
         return []
     before = (before_ms * tickrate) // 1000

{cs2df-3.0.0 → cs2df-3.0.3}/src/cs2df/rounds.py

@@ -57,6 +57,7 @@ class _RoundModel:
     # Indexes built in __post_init__; events are resolved per-row across every
     # builder, so these turn O(rounds) scans into O(1)/O(log rounds) lookups.
     _by_round: dict[int, _RoundWindow] = field(init=False, repr=False, default_factory=dict)
+    _event_end_by_round: dict[int, int] = field(init=False, repr=False, default_factory=dict)
     _sorted_starts: list[int] = field(init=False, repr=False, default_factory=list)
     _sorted_windows: list[_RoundWindow] = field(init=False, repr=False, default_factory=list)
 
@@ -65,6 +66,12 @@ class _RoundModel:
         ordered = sorted(self.windows, key=lambda w: w.start_tick)
         self._sorted_windows = ordered
         self._sorted_starts = [w.start_tick for w in ordered]
+        self._event_end_by_round = {}
+        for i, window in enumerate(ordered):
+            next_start = ordered[i + 1].start_tick if i + 1 < len(ordered) else None
+            self._event_end_by_round[window.round_number] = (
+                next_start - 1 if next_start is not None else window.end_tick
+            )
 
     def window_for_round(self, round_number: int) -> _RoundWindow | None:
         return self._by_round.get(round_number)
@@ -72,15 +79,19 @@ class _RoundModel:
     def has_round(self, round_number: int) -> bool:
         return round_number in self._by_round
 
+    def event_end_tick(self, round_number: int) -> int | None:
+        return self._event_end_by_round.get(round_number)
+
     def round_for_tick(self, tick: int) -> int | None:
         # Windows are sorted by start_tick and non-overlapping: the candidate is
-        # the last window whose start_tick <= tick; confirm tick is within it
-        # (ticks falling in inter-round gaps resolve to None, as before).
+        # the last window whose start_tick <= tick; confirm tick is before the
+        # next round start (or <= end_tick for the final round).
         i = bisect.bisect_right(self._sorted_starts, tick) - 1
         if i < 0:
             return None
         window = self._sorted_windows[i]
-        return window.round_number if window.start_tick <= tick <= window.end_tick else None
+        event_end = self.event_end_tick(window.round_number)
+        return window.round_number if event_end is not None and window.start_tick <= tick <= event_end else None
 
     def round_for_event(self, row: dict) -> int | None:
         tick = int(row.get("tick") or 0)

{cs2df-3.0.0 → cs2df-3.0.3}/src/cs2df/streams.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from .enums import normalize_weapon_name
+from .enums import classify_inventory, normalize_weapon_name
 from .events import PlayerDirectory, _sid
 from .rounds import _RoundModel
 
@@ -153,6 +153,10 @@ def build_replay(raw: dict, players: PlayerDirectory, round_model: _RoundModel,
         if str(v).strip()
     }
     df["_plidx"] = df["last_place_name"].map(place_map).fillna(-1).astype("int64")
+    if "inventory" in df.columns:
+        df["_grenades"] = df["inventory"].map(lambda items: classify_inventory(items)[3])
+    else:
+        df["_grenades"] = [[] for _ in range(len(df))]
 
     bomb_ticks, bomb_carrier = build_bomb_carrier_timeline(raw, players)
     tick_values = df["tick"].to_numpy()
@@ -174,8 +178,11 @@ def build_replay(raw: dict, players: PlayerDirectory, round_model: _RoundModel,
         })
 
     rounds_out: list[dict] = []
-    for w in sorted(round_model.windows, key=lambda w: w.round_number):
-        grid = np.arange(w.freeze_end_tick, w.end_tick, step, dtype="int64")
+    windows = sorted(round_model.windows, key=lambda w: w.round_number)
+    for i, w in enumerate(windows):
+        next_start_tick = windows[i + 1].start_tick if i + 1 < len(windows) else None
+        stop_tick = next_start_tick if next_start_tick is not None else w.end_tick + 1
+        grid = np.arange(w.freeze_end_tick, stop_tick, step, dtype="int64")
         if len(grid) == 0:
             continue
         sl = _slice_by_tick(df, tick_values, int(grid[0]), int(grid[-1]))
@@ -249,6 +256,7 @@ def _player_track(g, grid, pidx: int, bomb_ticks, bomb_carrier) -> dict | None:
     widx = np.where(present, widx, -1)
     plidx = aligned["_plidx"].fillna(-1).astype("int64").to_numpy()
     plidx = np.where(present, plidx, -1)
+    grenades = _align_grenades(aligned, present)
 
     alive = (hp > 0).astype("int64")
     has_kit = _num(aligned["has_defuser"], 0.0).to_numpy().astype(bool)
@@ -270,9 +278,24 @@ def _player_track(g, grid, pidx: int, bomb_ticks, bomb_carrier) -> dict | None:
         "place": plidx.tolist(),
         "flash": flash.tolist(),
         "flags": flags.tolist(),
+        "grenades": grenades,
     }
 
 
+def _align_grenades(aligned, present) -> list[list[str]]:
+    """Forward-fill sampled inventory lists and clear them when no player row exists."""
+    if "_grenades" not in aligned.columns:
+        return [[] for _ in range(len(aligned))]
+    filled = aligned["_grenades"].ffill().bfill()
+    out: list[list[str]] = []
+    for has_row, value in zip(present, filled, strict=False):
+        if not has_row or not isinstance(value, list):
+            out.append([])
+        else:
+            out.append([str(item) for item in value])
+    return out
+
+
 # ── duels.json ────────────────────────────────────────────────────────────────
 
 def build_duels(raw: dict, players: PlayerDirectory, round_model: _RoundModel,

{cs2df-3.0.0 → cs2df-3.0.3}/src/cs2df/validate.py

@@ -24,6 +24,7 @@ EPS = 0.02
 # stream track columns that must all share length == frameCount
 _REPLAY_COLS = ("x", "y", "z", "yaw", "pitch", "hp", "armor", "money",
                 "equipValue", "weapon", "place", "flash", "flags")
+_REPLAY_OPTIONAL_FRAME_COLS = ("grenades",)
 _DUEL_COLS = ("x", "y", "z", "yaw", "pitch", "hp", "flash")
 _SHOT_COLS = ("tick", "weapon", "x", "y", "z", "vx", "vy", "vz", "yaw", "pitch")
 
@@ -338,7 +339,8 @@ def _check_shots_stream(shots: dict, n_players: int, round_set: set,
                 break
         ticks = decode_delta(t.get("tick", []))
         rd = rounds_by_number.get(t.get("roundNumber"))
-        if rd and ticks and not all(rd.get("freezeEndTick", 0) <= tk <= rd.get("endTick", 0) for tk in ticks):
+        event_end = _round_event_end(rounds_by_number, t.get("roundNumber"))
+        if rd and ticks and event_end is not None and not all(rd.get("freezeEndTick", 0) <= tk <= event_end for tk in ticks):
             err(f"{label}: decoded ticks fall outside the round window")
 
 
@@ -369,11 +371,13 @@ def _check_replay_stream(replay: dict, n_players: int, round_set: set,
         step = rd_obj.get("tickStep", 1)
         if fc and rd:
             last_tick = start + (fc - 1) * step
-            if start < rd.get("freezeEndTick", 0) or last_tick > rd.get("endTick", 0):
+            event_end = _round_event_end(rounds_by_number, rn)
+            if event_end is not None and (start < rd.get("freezeEndTick", 0) or last_tick > event_end):
                 err(f"{label}: frame grid [{start}, {last_tick}] outside round window")
         for pi, track in enumerate(rd_obj.get("players", [])):
             tlabel = f"{label} players[{pi}]"
             _check_track_frames(tlabel, track, _REPLAY_COLS, fc, n_players, err)
+            _check_optional_track_frames(tlabel, track, _REPLAY_OPTIONAL_FRAME_COLS, fc, err)
             for w in track.get("weapon", []):
                 if w != -1 and not (0 <= w < len(wd)):
                     err(f"{tlabel}: weapon index {w} out of weaponDict range")
@@ -390,6 +394,12 @@ def _check_replay_stream(replay: dict, n_players: int, round_set: set,
                 err(f"{label} projectiles[{qi}]: throwerIndex out of range")
 
 
+def _check_optional_track_frames(label: str, track: dict, cols: tuple, frame_count: int, err) -> None:
+    bad = {c: len(track.get(c, [])) for c in cols if c in track and len(track.get(c, [])) != frame_count}
+    if bad:
+        err(f"{label}: optional column lengths != frameCount {frame_count}: {bad}")
+
+
 def _check_duels_stream(duels: dict, n_players: int, round_set: set,
                         rounds_by_number: dict, err):
     for wi, w in enumerate(duels.get("windows", [])):
@@ -406,7 +416,8 @@ def _check_duels_stream(duels: dict, n_players: int, round_set: set,
         step = w.get("tickStep", 1)
         if fc and rd:
             last_tick = start + (fc - 1) * step
-            if start < rd.get("freezeEndTick", 0) or last_tick > rd.get("endTick", 0):
+            event_end = _round_event_end(rounds_by_number, rn)
+            if event_end is not None and (start < rd.get("freezeEndTick", 0) or last_tick > event_end):
                 err(f"{label}: frame grid [{start}, {last_tick}] outside round window")
         anchors = w.get("anchors", [])
         if not anchors:
@@ -491,7 +502,7 @@ def _check_tick_windows(name: str, rows: list, rounds_by_number: dict, err,
             if not isinstance(tick, int):
                 continue
             start = round_row.get("freezeEndTick")
-            end = round_row.get("endTick")
+            end = _round_event_end(rounds_by_number, row.get("roundNumber"))
             if not isinstance(start, int) or not isinstance(end, int):
                 continue
             if tick < start or tick > end:
@@ -502,6 +513,17 @@ def _check_tick_windows(name: str, rows: list, rounds_by_number: dict, err,
         err(f"{name}.json: {len(bad)} row(s) have ticks outside their round window; sample: {sample}")
 
 
+def _round_event_end(rounds_by_number: dict, round_number) -> int | None:
+    round_row = rounds_by_number.get(round_number)
+    if not isinstance(round_row, dict):
+        return None
+    next_round = rounds_by_number.get(round_number + 1) if isinstance(round_number, int) else None
+    if isinstance(next_round, dict) and isinstance(next_round.get("startTick"), int):
+        return next_round["startTick"] - 1
+    end_tick = round_row.get("endTick")
+    return end_tick if isinstance(end_tick, int) else None
+
+
 def _check_bomb_lifecycle(bombs: list, err):
     by_round: dict[object, list[dict]] = {}
     for b in bombs:

cs2df-3.0.3/tests/test_replay_boundaries.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import pandas as pd
+
+from cs2df.events import PlayerDirectory
+from cs2df.parse import _build_sample_ticks
+from cs2df.rounds import _RoundModel, _RoundWindow
+from cs2df.streams import build_replay
+
+
+def _replay_row(tick: int) -> dict:
+    return {
+        "steamid": "76561198000000001",
+        "tick": tick,
+        "active_weapon_name": "ak47",
+        "last_place_name": "Middle",
+        "inventory": [],
+        "X": tick,
+        "Y": tick + 1,
+        "Z": tick + 2,
+        "yaw": 90,
+        "pitch": 0,
+        "balance": 800,
+        "current_equip_value": 2700,
+        "health": 100,
+        "armor": 100,
+        "flash_duration": 0,
+        "has_defuser": False,
+    }
+
+
+def test_replay_round_extends_to_sample_before_next_round_start():
+    players = PlayerDirectory([
+        {"steamId64": "76561198000000001", "name": "p1", "teamKey": "teamA"},
+    ])
+    round_model = _RoundModel(
+        windows=[
+            _RoundWindow(round_number=1, start_tick=50, freeze_end_tick=100, end_tick=200),
+            _RoundWindow(round_number=2, start_tick=300, freeze_end_tick=360, end_tick=460),
+        ],
+        side_map={},
+    )
+    raw = {
+        "replay_df": pd.DataFrame([_replay_row(tick) for tick in range(100, 360, 16)]),
+        "grenade_trajectories": [],
+    }
+
+    replay = build_replay(raw, players, round_model, tickrate=128, sample_rate=8)
+
+    assert replay is not None
+    first_round = replay["rounds"][0]
+    last_tick = first_round["startTick"] + (first_round["frameCount"] - 1) * first_round["tickStep"]
+    assert last_tick == 292
+    assert last_tick < 300
+
+
+def test_parse_replay_ticks_include_post_round_tail_before_next_start():
+    round_ends = [
+        {"total_rounds_played": 1, "tick": 200},
+        {"total_rounds_played": 2, "tick": 460},
+    ]
+    round_freeze_ends = [
+        {"total_rounds_played": 0, "tick": 100},
+        {"total_rounds_played": 1, "tick": 360},
+    ]
+    round_starts = [
+        {"total_rounds_played": 0, "tick": 50},
+        {"total_rounds_played": 1, "tick": 300},
+    ]
+
+    ticks = _build_sample_ticks(round_ends, round_freeze_ends, round_starts, step=16)
+
+    assert 292 in ticks
+    assert 300 not in ticks

cs2df-3.0.3/tests/test_round_windows.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from cs2df.events import PlayerDirectory, build_kills
+from cs2df.rounds import _RoundModel, _RoundWindow
+
+
+def test_round_for_tick_assigns_post_round_tail_to_previous_round():
+    round_model = _RoundModel(
+        windows=[
+            _RoundWindow(round_number=1, start_tick=50, freeze_end_tick=100, end_tick=200),
+            _RoundWindow(round_number=2, start_tick=300, freeze_end_tick=360, end_tick=460),
+        ],
+        side_map={},
+    )
+
+    assert round_model.round_for_tick(200) == 1
+    assert round_model.round_for_tick(250) == 1
+    assert round_model.round_for_tick(299) == 1
+    assert round_model.round_for_tick(300) == 2
+
+
+def test_kills_after_round_end_before_next_start_are_kept_in_previous_round():
+    players = PlayerDirectory([
+        {"steamId64": "76561198000000001", "name": "attacker", "teamKey": "teamA"},
+        {"steamId64": "76561198000000002", "name": "victim", "teamKey": "teamB"},
+    ])
+    round_model = _RoundModel(
+        windows=[
+            _RoundWindow(round_number=1, start_tick=50, freeze_end_tick=100, end_tick=200),
+            _RoundWindow(round_number=2, start_tick=300, freeze_end_tick=360, end_tick=460),
+        ],
+        side_map={(1, "teamA"): "t", (1, "teamB"): "ct"},
+    )
+    raw = {
+        "deaths": [{
+            "tick": 250,
+            "user_steamid": "76561198000000002",
+            "attacker_steamid": "76561198000000001",
+            "weapon": "ak47",
+            "user_X": 1,
+            "user_Y": 2,
+            "user_Z": 3,
+        }],
+    }
+
+    kills = build_kills(raw, players, round_model)
+
+    assert len(kills) == 1
+    assert kills[0]["roundNumber"] == 1
+    assert kills[0]["tick"] == 250

cs2df-3.0.3/tests/test_version_consistency.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def test_check_versions_script_accepts_current_release_versions():
+    script = ROOT / "tools" / "check_versions.py"
+
+    result = subprocess.run(
+        [sys.executable, str(script)],
+        cwd=ROOT,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stdout + result.stderr

{cs2df-3.0.0 → cs2df-3.0.3}/uv.lock

@@ -30,7 +30,7 @@ wheels = [
 
 [[package]]
 name = "cs2df"
-version = "3.0.0"
+version = "3.0.3"
 source = { editable = "." }
 dependencies = [
     { name = "demoparser2" },