Trust ticks.parquet `t` and `event_seconds`

Upstream fixed the time bases: ticks `t` is monotonic video time and
`event_seconds` is already on the POV video timeline. So:

- world.ts uses `r.t` directly; drop the tick-derived recompute and
the TICK_RATE constant.
- map-results.ts drops the ×2 multiplier for `event_seconds`.
- Recipes drop `event_seconds * 2.0` and the pov_rounds join that was
only there for path lookups we don't need.

src/lib/api/world.ts

@@ -37,7 +37,7 @@ function chunkBaseUrl(chunk: PreviewChunk): string {
 }
 
 type TickRow = {
-	tick: number;
+	t: number;
 	x: number;
 	y: number;
 	z: number;
@@ -48,9 +48,6 @@ type TickRow = {
 	is_alive: boolean;
 };
 
-// CS2 demo tickrate.
-const TICK_RATE = 64;
-
 async function loadChunkFrames(
 	chunk: PreviewChunk,
 	player: number,
@@ -58,35 +55,24 @@ async function loadChunkFrames(
 ): Promise<WorldFrame[]> {
 	const base = chunkBaseUrl(chunk);
 	const rows = await fetchParquetRows<TickRow>(`${base}/ticks.parquet`, opts);
-	if (!rows.length) return [];
 
 	const steamid = `slot-${player}`;
 	const name = `Player ${player}`;
-	// The ticks.parquet `t` column can be non-monotonic (it resets across
-	// tactical-pause segments), which breaks the binary search in snapshotAt.
-	// `tick` is the absolute demo tick counter and stays monotonic across the
-	// whole round, so derive round-relative time from it.
-	const tick0 = rows[0].tick;
-
-	const frames: WorldFrame[] = new Array(rows.length);
-	for (let i = 0; i < rows.length; i++) {
-		const r = rows[i];
-		frames[i] = {
-			t: (r.tick - tick0) / TICK_RATE,
-			player,
-			steamid,
-			name,
-			team_num: r.team_num,
-			is_alive: r.is_alive,
-			health: r.health,
-			armor_value: r.armor_value,
-			X: r.x,
-			Y: r.y,
-			Z: r.z,
-			yaw: r.yaw
-		};
-	}
-	return frames;
+
+	return rows.map((r) => ({
+		t: r.t,
+		player,
+		steamid,
+		name,
+		team_num: r.team_num,
+		is_alive: r.is_alive,
+		health: r.health,
+		armor_value: r.armor_value,
+		X: r.x,
+		Y: r.y,
+		Z: r.z,
+		yaw: r.yaw
+	}));
 }
 
 export async function loadRoundWorld(

src/lib/components/advanced-filter/map-results.ts

@@ -15,20 +15,18 @@ const PLAYER_KEYS = [
 	'player'
 ] as const;
 
-// Timestamp candidates, ordered by preference. `multiplier` translates from
-// the source's time base into POV video seconds — the events tables store
-// `event_seconds` on a half-rate clock per the dataset README, so they need
-// ×2 to seek correctly. `lead` rolls the seek back so kills/duels open with
-// a couple seconds of context before the actual moment. `start_t` is a
-// user-controlled escape hatch with no lead.
+// Timestamp candidates, ordered by preference. Every column listed here is
+// already in POV-video seconds. `lead` rolls the seek back so kills/duels
+// open with a couple seconds of context before the actual moment; `t` and
+// the explicit `start_t` are interpreted as exact seek points (no lead).
 const LEAD_S = 2.5;
 const TIME_SOURCES = [
-	{ key: 'event_video_seconds', multiplier: 1, lead: LEAD_S },
-	{ key: 'first_kill_video_seconds', multiplier: 1, lead: LEAD_S },
-	{ key: 'last_kill_video_seconds', multiplier: 1, lead: LEAD_S },
-	{ key: 'start_t', multiplier: 1, lead: 0 },
-	{ key: 'event_seconds', multiplier: 2, lead: LEAD_S },
-	{ key: 't', multiplier: 1, lead: 0 }
+	{ key: 'event_video_seconds', lead: LEAD_S },
+	{ key: 'event_seconds', lead: LEAD_S },
+	{ key: 'first_kill_seconds', lead: LEAD_S },
+	{ key: 'last_kill_seconds', lead: LEAD_S },
+	{ key: 'start_t', lead: 0 },
+	{ key: 't', lead: 0 }
 ] as const;
 
 function pickPlayer(row: Record<string, unknown>): number | null {
@@ -43,7 +41,7 @@ function pickStartT(row: Record<string, unknown>): number | undefined {
 	for (const src of TIME_SOURCES) {
 		const v = row[src.key];
 		if (typeof v !== 'number' || !Number.isFinite(v)) continue;
-		return Math.max(0, v * src.multiplier - src.lead);
+		return Math.max(0, v - src.lead);
 	}
 	return undefined;
 }

src/lib/components/advanced-filter/recipes.ts

@@ -1,6 +1,8 @@
 // Curated SQL recipes adapted from the OpenCS2 dataset card. Each query must
 // SELECT match_id / map_name / round / a *player_slot column and a timestamp
 // column the result mapper understands (see ./map-results.ts).
+//
+// event_seconds is in POV video seconds — no rescaling needed.
 
 export type Recipe = {
 	id: string;
@@ -9,7 +11,6 @@ export type Recipe = {
 	sql: string;
 };
 
-const POV = `'hf://datasets/blanchon/opencs2_dataset/index/pov_rounds.parquet'`;
 const KILLS = `'hf://datasets/blanchon/opencs2_dataset/events/kills.parquet'`;
 const DUELS = `'hf://datasets/blanchon/opencs2_dataset/events/duels.parquet'`;
 
@@ -19,23 +20,18 @@ export const RECIPES: Recipe[] = [
 		label: 'AWP 1v1 duel',
 		description: 'Winner POV for AWP kills when the duel started as a 1v1.',
 		sql: `SELECT
-  d.match_id,
-  d.map_name,
-  d.round,
-  d.winner_player_slot AS player_slot,
-  d.event_seconds * 2.0 AS event_video_seconds,
-  d.weapon,
-  d.distance,
-  d.headshot
-FROM ${DUELS} d
-JOIN ${POV} p
-  ON d.match_id = p.match_id
- AND d.map_name = p.map_name
- AND d.round = p.round
- AND d.winner_player_slot = p.player_slot
-WHERE d.weapon = 'awp'
-  AND d.is_1v1_before
-ORDER BY d.event_seconds
+  match_id,
+  map_name,
+  round,
+  winner_player_slot AS player_slot,
+  event_seconds,
+  weapon,
+  distance,
+  headshot
+FROM ${DUELS}
+WHERE weapon = 'awp'
+  AND is_1v1_before
+ORDER BY event_seconds
 LIMIT 50`
 	},
 	{
@@ -43,21 +39,16 @@ LIMIT 50`
 		label: 'Kill through smoke',
 		description: 'Attacker POV when the kill went through a smoke grenade.',
 		sql: `SELECT
-  k.match_id,
-  k.map_name,
-  k.round,
-  k.attacker_player_slot AS player_slot,
-  k.event_seconds * 2.0 AS event_video_seconds,
-  k.weapon,
-  k.distance,
-  k.headshot
-FROM ${KILLS} k
-JOIN ${POV} p
-  ON k.match_id = p.match_id
- AND k.map_name = p.map_name
- AND k.round = p.round
- AND k.attacker_player_slot = p.player_slot
-WHERE k.through_smoke
+  match_id,
+  map_name,
+  round,
+  attacker_player_slot AS player_slot,
+  event_seconds,
+  weapon,
+  distance,
+  headshot
+FROM ${KILLS}
+WHERE through_smoke
 LIMIT 50`
 	},
 	{
@@ -65,23 +56,18 @@ LIMIT 50`
 		label: 'Noscope / wallbang',
 		description: 'Attacker POV for noscope, wallbang or penetration kills.',
 		sql: `SELECT
-  k.match_id,
-  k.map_name,
-  k.round,
-  k.attacker_player_slot AS player_slot,
-  k.event_seconds * 2.0 AS event_video_seconds,
-  k.weapon,
-  k.noscope,
-  k.wallbang,
-  k.penetrated
-FROM ${KILLS} k
-JOIN ${POV} p
-  ON k.match_id = p.match_id
- AND k.map_name = p.map_name
- AND k.round = p.round
- AND k.attacker_player_slot = p.player_slot
-WHERE (k.noscope OR k.wallbang OR k.penetrated > 0)
-ORDER BY k.noscope DESC, k.wallbang DESC, k.penetrated DESC
+  match_id,
+  map_name,
+  round,
+  attacker_player_slot AS player_slot,
+  event_seconds,
+  weapon,
+  noscope,
+  wallbang,
+  penetrated
+FROM ${KILLS}
+WHERE noscope OR wallbang OR penetrated > 0
+ORDER BY noscope DESC, wallbang DESC, penetrated DESC
 LIMIT 50`
 	},
 	{
@@ -89,42 +75,36 @@ LIMIT 50`
 		label: 'Knife kill',
 		description: 'Attacker POV for actual knife kills (not just rounds spent holding a knife).',
 		sql: `SELECT
-  k.match_id,
-  k.map_name,
-  k.round,
-  k.attacker_player_slot AS player_slot,
-  k.event_seconds * 2.0 AS event_video_seconds,
-  k.weapon
-FROM ${KILLS} k
-JOIN ${POV} p
-  ON k.match_id = p.match_id
- AND k.map_name = p.map_name
- AND k.round = p.round
- AND k.attacker_player_slot = p.player_slot
-WHERE lower(k.weapon_class) = 'knife'
-   OR lower(k.weapon) LIKE '%knife%'
-   OR lower(k.weapon) LIKE '%bayonet%'
-   OR lower(k.weapon) LIKE '%karambit%'
+  match_id,
+  map_name,
+  round,
+  attacker_player_slot AS player_slot,
+  event_seconds,
+  weapon
+FROM ${KILLS}
+WHERE lower(weapon_class) = 'knife'
+   OR lower(weapon) LIKE '%knife%'
+   OR lower(weapon) LIKE '%bayonet%'
+   OR lower(weapon) LIKE '%karambit%'
 LIMIT 50`
 	},
 	{
 		id: 'five_kills_under_10s',
 		label: '5 kills in < 10s',
 		description: 'Player POV when the same player got ≥5 kills within a 10-second window.',
-		sql: `WITH streaks AS (
-  SELECT match_id, map_name, round, attacker_player_slot AS player_slot,
-         COUNT(*) AS n_kills,
-         MIN(event_seconds) * 2.0 AS first_kill_video_seconds,
-         MAX(event_seconds) - MIN(event_seconds) AS window_s
-  FROM ${KILLS}
-  GROUP BY match_id, map_name, round, attacker_player_slot
-  HAVING COUNT(*) >= 5 AND MAX(event_seconds) - MIN(event_seconds) < 10.0
-)
-SELECT s.match_id, s.map_name, s.round, s.player_slot,
-       s.first_kill_video_seconds AS event_video_seconds,
-       s.n_kills, s.window_s
-FROM streaks s
-ORDER BY s.window_s
+		sql: `SELECT
+  match_id,
+  map_name,
+  round,
+  attacker_player_slot AS player_slot,
+  MIN(event_seconds) AS first_kill_seconds,
+  MAX(event_seconds) AS last_kill_seconds,
+  COUNT(*) AS n_kills
+FROM ${KILLS}
+GROUP BY match_id, map_name, round, attacker_player_slot
+HAVING COUNT(*) >= 5
+   AND MAX(event_seconds) - MIN(event_seconds) < 10.0
+ORDER BY MAX(event_seconds) - MIN(event_seconds)
 LIMIT 50`
 	},
 	{
@@ -132,21 +112,16 @@ LIMIT 50`
 		label: 'Long-distance kill',
 		description: 'Attacker POV for the longest-recorded kills by in-engine distance.',
 		sql: `SELECT
-  k.match_id,
-  k.map_name,
-  k.round,
-  k.attacker_player_slot AS player_slot,
-  k.event_seconds * 2.0 AS event_video_seconds,
-  k.weapon,
-  k.distance
-FROM ${KILLS} k
-JOIN ${POV} p
-  ON k.match_id = p.match_id
- AND k.map_name = p.map_name
- AND k.round = p.round
- AND k.attacker_player_slot = p.player_slot
-WHERE k.distance IS NOT NULL
-ORDER BY k.distance DESC
+  match_id,
+  map_name,
+  round,
+  attacker_player_slot AS player_slot,
+  event_seconds,
+  weapon,
+  distance
+FROM ${KILLS}
+WHERE distance IS NOT NULL
+ORDER BY distance DESC
 LIMIT 50`
 	}
 ];