feat(analyse): review sessions before drilling into laps

.omp/rules/tsx-no-biome-ignore.md

@@ -0,0 +1,8 @@
+---
+name: tsx-no-biome-ignore
+description: "Reject noArrayIndexKey suppressions in affected React components"
+condition: ["GearRatioChart\\.tsx[\\s\\S]*biome-ignore\\s+lint/suspicious/noArrayIndexKey", "InputOverlay\\.tsx[\\s\\S]*biome-ignore\\s+lint/suspicious/noArrayIndexKey"]
+scope: "tool"
+---
+
+Do not suppress `noArrayIndexKey`. Fix identity at source with stable domain IDs or stable source-data keys. If no compliant identity exists, stop before editing: cite Biome’s `noArrayIndexKey` reference, explain concrete tradeoffs, and ask which model change is acceptable.

client/src/components/ChatsPage.tsx

@@ -14,6 +14,8 @@ interface LapSummary {
   isValid: boolean;
   carName: string;
   trackName: string;
+  trackOrdinal: number | null;
+  carOrdinal: number | null;
   gameId: string;
 }
 
@@ -102,9 +104,10 @@ export function ChatsPage() {
       const prefix = `/${game.routePrefix}`;
       if (row.type === "analyse" && row.laps[0]) {
         const lap = row.laps[0];
+        if (lap.trackOrdinal == null || lap.carOrdinal == null) return;
         navigate({
           to: `${prefix}/analyse` as never,
-          search: { lap: lap.id, ai: 1 } as never,
+          search: { track: lap.trackOrdinal, car: lap.carOrdinal, lap: lap.id, ai: 1 } as never,
         });
       } else if (row.type === "compare" && row.laps.length === 2) {
         const [a, b] = row.laps;

client/src/components/RecordedLaps.tsx

@@ -93,8 +93,10 @@ export function RecordedLaps({ laps, trackOrdinal, maxLaps = 15 }: RecordedLapsP
                   <span className={`text-base font-mono font-bold tabular-nums text-right ${timeColor}`}>{formatLapTime(l.lapTime)}</span>
                   <span className="text-xs text-app-text-dim font-mono tabular-nums text-right w-14">{isBest ? "PB" : `+${delta.toFixed(3)}`}</span>
                   <div className="flex items-center gap-1 w-16 justify-end">
-                    <Button // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                      onClick={() => navigate({ to: `${gameRoute}/analyse` as any, search: { track: l.trackOrdinal, car: l.carOrdinal, lap: l.id } as any })}
+                    <Button
+                      disabled={l.trackOrdinal == null || l.carOrdinal == null}
+                      title={l.trackOrdinal == null || l.carOrdinal == null ? "Analyse unavailable: track/car identity unresolved" : undefined}
+                      onClick={() => void navigate({ to: `${gameRoute}/analyse` as never, search: { track: l.trackOrdinal, car: l.carOrdinal, lap: l.id } as never })}
                       variant="app-primary"
                       size="app-sm"
                       className="!px-1.5 !py-0.5"

client/src/components/dev/ImportDumpPanel.tsx

@@ -39,7 +39,7 @@ export function ImportDumpPanel() {
   const navigate = useNavigate();
 
   const openInAnalyse = (lap: ImportedLap) => {
-    if (!result) return;
+    if (!result || lap.trackOrdinal <= 0 || lap.carOrdinal <= 0) return;
     // Route is /{routePrefix}/analyse with ?track&car&lap search params
     navigate({
       to: `/${result.routePrefix}/analyse`,
@@ -185,8 +185,14 @@ export function ImportDumpPanel() {
                       <span className="text-app-text-muted">#{lap.lapNumber}</span> <span>{formatLapTime(lap.lapTime)}</span>
                       {!lap.isValid && <span className="ml-2 px-1.5 py-0.5 rounded bg-status-danger/15 text-status-danger text-app-caption">invalid</span>}
                     </div>
-                    <Button type="button" onClick={() => openInAnalyse(lap)} className="px-2.5 py-1 text-xs rounded bg-app-accent text-app-on-filled hover:opacity-90 transition-opacity">
-                      {m.dev_open_analyse()}
+                    <Button
+                      type="button"
+                      disabled={lap.trackOrdinal <= 0 || lap.carOrdinal <= 0}
+                      title={lap.trackOrdinal <= 0 || lap.carOrdinal <= 0 ? "Analyse unavailable: track/car identity unresolved" : undefined}
+                      onClick={() => openInAnalyse(lap)}
+                      className="px-2.5 py-1 text-xs rounded bg-app-accent text-app-on-filled hover:opacity-90 transition-opacity"
+                    >
+                      {lap.trackOrdinal <= 0 || lap.carOrdinal <= 0 ? "Identity unavailable" : m.dev_open_analyse()}
                     </Button>
                   </div>
                 ))}

client/src/components/tunes/review/AnalysePickerPage.tsx

@@ -0,0 +1,59 @@
+import type { GameId } from "@shared/games/ids";
+import { useNavigate } from "@tanstack/react-router";
+import { useMemo } from "react";
+import { Button } from "@/components/ui/button";
+import { useResolveNames } from "@/hooks/catalog-queries";
+import { useLaps } from "@/hooks/laps";
+
+export function AnalysePickerPage({ gameId }: { gameId: GameId }) {
+  const navigate = useNavigate();
+  const { data: laps = [], isLoading } = useLaps();
+  const trackOrdinals = useMemo(() => [...new Set(laps.map((lap) => lap.trackOrdinal).filter((ordinal): ordinal is number => ordinal != null && ordinal > 0))].sort((a, b) => a - b), [laps]);
+  const carOrdinals = useMemo(() => [...new Set(laps.map((lap) => lap.carOrdinal).filter((ordinal): ordinal is number => ordinal != null && ordinal > 0))].sort((a, b) => a - b), [laps]);
+  const { data: names, isLoading: namesLoading } = useResolveNames(trackOrdinals, carOrdinals);
+  const trackName = (ordinal: number) => names?.trackNames[String(ordinal)] ?? `Track ${ordinal}`;
+  const carName = (ordinal: number) => names?.carNames[String(ordinal)] ?? `Car ${ordinal}`;
+
+  if (isLoading || namesLoading) {
+    return <div role="status" className="p-8 text-sm text-app-text-muted">Loading Analyse selections…</div>;
+  }
+
+  return (
+    <div className="mx-auto flex w-full max-w-3xl flex-col gap-6 p-6">
+      <div>
+        <h1 className="text-xl font-semibold text-app-text">Analyse</h1>
+        <p className="mt-1 text-sm text-app-text-muted">Choose track and car to review recorded laps for {gameId}.</p>
+      </div>
+      {trackOrdinals.length === 0 ? (
+        <div className="rounded-lg border border-app-border p-6 text-sm text-app-text-muted">No recorded laps available for this game.</div>
+      ) : (
+        <div className="grid gap-3 sm:grid-cols-2">
+          {trackOrdinals.map((track) => {
+            const cars = carOrdinals.filter((car) => laps.some((lap) => lap.trackOrdinal === track && lap.carOrdinal === car));
+            return (
+              <div key={track} className="rounded-lg border border-app-border p-4">
+                <div className="font-semibold text-app-text">{trackName(track)}</div>
+                <div className="mt-3 flex flex-wrap gap-2">
+                  {cars.map((car) => {
+                    const count = laps.filter((lap) => lap.trackOrdinal === track && lap.carOrdinal === car && lap.isValid && lap.lapTime > 0).length;
+                    return (
+                      <Button
+                        key={car}
+                        variant="app-outline"
+                        size="app-sm"
+                        aria-label={`Review ${carName(car)} on ${trackName(track)} (${count} valid laps)`}
+                        onClick={() => void navigate({ search: (previous: Record<string, unknown>) => ({ ...previous, track, car, lap: undefined, laps: undefined }) } as never)}
+                      >
+                        {carName(car)} ({count})
+                      </Button>
+                    );
+                  })}
+                </div>
+              </div>
+            );
+          })}
+        </div>
+      )}
+    </div>
+  );
+}

client/src/components/tunes/review/AnalyseRoute.tsx

@@ -0,0 +1,53 @@
+import type { GameId } from "@shared/games/ids";
+import { useNavigate, useSearch } from "@tanstack/react-router";
+import { parseAnalyseLapIds, type AnalyseSearch } from "@/lib/game-routes";
+import { AnalysePickerPage } from "./AnalysePickerPage";
+import { TrackCarAnalyseReviewPage } from "./TrackCarAnalyseReviewPage";
+import { LapAnalyse } from "../../analyse/LapAnalyse";
+
+function InvalidAnalyseSelection({ message }: { message: string }) {
+  const navigate = useNavigate();
+  return (
+    <div className="flex min-h-[18rem] items-center justify-center p-8 text-center">
+      <div>
+        <h1 className="text-lg font-semibold text-app-text">Invalid Analyse selection</h1>
+        <p role="alert" className="mt-2 text-sm text-app-text-muted">{message}</p>
+        <button
+          type="button"
+          className="mt-4 rounded border border-app-border px-3 py-1.5 text-sm text-app-text hover:bg-app-surface-alt"
+          onClick={() => void navigate({ search: (previous: Record<string, unknown>) => ({ ...previous, track: undefined, car: undefined, lap: undefined, laps: undefined }) } as never)}
+        >
+          Back to Analyse picker
+        </button>
+      </div>
+    </div>
+  );
+}
+
+export function AnalyseRoute({ gameId }: { gameId: GameId }) {
+  const search = useSearch({ strict: false }) as AnalyseSearch;
+  const hasTrack = search.track != null;
+  const hasCar = search.car != null;
+  const hasLap = search.lap != null;
+  const hasComparison = search.laps != null;
+  const comparisonLapIds = parseAnalyseLapIds(search.laps);
+  const validTrack = !hasTrack || (Number.isInteger(search.track!) && search.track! > 0);
+  const validCar = !hasCar || (Number.isInteger(search.car!) && search.car! > 0);
+  const validLap = !hasLap || (Number.isInteger(search.lap!) && search.lap! > 0);
+
+  if (!validTrack || !validCar || !validLap) {
+    return <InvalidAnalyseSelection message="Track, car, and lap must be positive numeric selections." />;
+  }
+  if (hasComparison && (comparisonLapIds == null || comparisonLapIds.length === 0)) {
+    return <InvalidAnalyseSelection message="Comparison laps must be a comma-separated list of positive, unique lap IDs." />;
+  }
+  if (hasTrack !== hasCar) {
+    return <InvalidAnalyseSelection message="Choose both track and car before selecting laps." />;
+  }
+  if ((hasLap || hasComparison) && (!hasTrack || !hasCar)) {
+    return <InvalidAnalyseSelection message="A lap selection must include its track and car." />;
+  }
+  if (!hasTrack && !hasCar) return <AnalysePickerPage gameId={gameId} />;
+  if (hasLap) return <LapAnalyse />;
+  return <TrackCarAnalyseReviewPage gameId={gameId} trackOrdinal={search.track!} carOrdinal={search.car!} />;
+}

client/src/components/tunes/review/TestReviewPage.tsx

@@ -71,6 +71,10 @@ export function TestReviewPage({ gameId, experimentId, lapIds, versionId }: { ga
     );
   }
 
+  if (gameId !== "acc" && gameId !== "ac-evo") {
+    return <div role="alert" className="p-8 text-sm text-app-text-muted">Review is unavailable for this game.</div>;
+  }
+
   return (
     // Single page scroll: the app shell's outlet wrapper is the only scroll
     // container. This page just flows — the dashboard grows to its content and
@@ -81,11 +85,8 @@ export function TestReviewPage({ gameId, experimentId, lapIds, versionId }: { ga
           `items-start` lets the sticky chat column pin instead of stretching. */}
       <div className="grid grid-cols-1 items-start gap-3 @5xl/workspace:grid-cols-[1fr_360px]">
         <div className="border border-app-border rounded-lg">
-          {/* TuneReviewDashboard's gameId union is ACC/AC-Evo (setup-engineer
-              panels); F1 rides the ACC path — it never reaches ACC-specific
-              setup data, and the sector/tyre analysis is game-agnostic. */}
           <TuneReviewDashboard
-            gameId={gameId === "f1-2025" ? "acc" : gameId}
+            gameId={gameId}
             laps={laps}
             trackName={session?.trackName ?? undefined}
             onBack={backToWorkspace}

client/src/components/tunes/review/TrackCarAnalyseReviewPage.tsx

@@ -0,0 +1,54 @@
+import type { GameId } from "@shared/games/ids";
+import { selectEvaluationLaps } from "@shared/racing/laps/review-selection";
+import { parseAnalyseLapIds } from "@/lib/game-routes";
+import { useNavigate, useSearch } from "@tanstack/react-router";
+import { useEffect, useMemo } from "react";
+import { useCarName, useResolveNames } from "@/hooks/catalog-queries";
+import { useLaps } from "@/hooks/laps";
+import { useTrackName } from "@/hooks/track-queries";
+import { TuneReviewDashboard } from "./TuneReviewDashboard";
+
+export function TrackCarAnalyseReviewPage({ gameId, trackOrdinal, carOrdinal }: { gameId: GameId; trackOrdinal: number; carOrdinal: number }) {
+  const navigate = useNavigate();
+  const search = useSearch({ strict: false }) as { laps?: string };
+  const { data: laps = [], isLoading: lapsLoading } = useLaps();
+  const { data: trackName, isLoading: trackLoading } = useTrackName(trackOrdinal);
+  const { data: resolvedNames, isLoading: namesLoading } = useResolveNames([trackOrdinal], [carOrdinal]);
+  const { data: carName, isLoading: carLoading } = useCarName(carOrdinal);
+  const groupLaps = useMemo(() => laps.filter((lap) => lap.trackOrdinal === trackOrdinal && lap.carOrdinal === carOrdinal), [carOrdinal, laps, trackOrdinal]);
+  const requestedLapIds = parseAnalyseLapIds(search.laps);
+  const comparisonCandidates = useMemo(() => (requestedLapIds ? groupLaps.filter((lap) => requestedLapIds.includes(lap.id)) : groupLaps), [groupLaps, requestedLapIds]);
+  const evaluationIds = useMemo(() => selectEvaluationLaps(comparisonCandidates).chosen.map((lap) => lap.id), [comparisonCandidates]);
+  const canonicalLaps = evaluationIds.join(",");
+  const resolvedTrackName = trackName ?? resolvedNames?.trackNames[String(trackOrdinal)] ?? `Track ${trackOrdinal}`;
+  const resolvedCarName = carName ?? resolvedNames?.carNames[String(carOrdinal)] ?? `Car ${carOrdinal}`;
+  const backToPicker = () => void navigate({ search: (previous: Record<string, unknown>) => ({ ...previous, track: undefined, car: undefined, lap: undefined, laps: undefined }) } as never);
+
+  useEffect(() => {
+    if (lapsLoading || trackLoading || carLoading || namesLoading || groupLaps.length === 0) return;
+    if (search.laps === canonicalLaps) return;
+    void navigate({ replace: true, search: (previous: Record<string, unknown>) => ({ ...previous, track: trackOrdinal, car: carOrdinal, lap: undefined, laps: canonicalLaps }) } as never);
+  }, [carLoading, carOrdinal, canonicalLaps, groupLaps.length, lapsLoading, namesLoading, navigate, search.laps, trackLoading, trackOrdinal]);
+
+  if (lapsLoading || trackLoading || carLoading || namesLoading) {
+    return <div role="status" aria-live="polite" className="p-8 text-sm text-app-text-muted">Loading Analyse review…</div>;
+  }
+  if (gameId !== "acc" && gameId !== "ac-evo") {
+    return <div role="alert" className="p-8 text-sm text-app-text-muted">Analyse review is unavailable for this game.</div>;
+  }
+
+
+  return (
+    <div className="flex flex-col gap-3 p-3">
+      <div className="px-1 text-sm text-app-text-muted">{resolvedTrackName} · {resolvedCarName}</div>
+      <div className="rounded-lg border border-app-border">
+        <TuneReviewDashboard
+          gameId={gameId}
+          laps={groupLaps}
+          trackName={resolvedTrackName}
+          onBack={backToPicker}
+        />
+      </div>
+    </div>
+  );
+}

client/src/lib/game-routes.ts

@@ -7,9 +7,11 @@ export type AnalyseSearch = {
   track?: number;
   car?: number;
   lap?: number;
+  laps?: string;
   cursor?: number;
   viz?: string;
   ai?: number;
+  view?: string;
 };
 export type CompareSearch = {
   track?: number;
@@ -78,14 +80,27 @@ export function parseOptionalNumber(value: unknown): number | undefined {
   return Number.isFinite(parsed) ? parsed : undefined;
 }
 
+/** Parse the canonical comparison lap list without silently accepting malformed IDs. */
+export function parseAnalyseLapIds(value: string | undefined): number[] | null | undefined {
+  if (value == null) return undefined;
+  const parts = value.split(",");
+  if (parts.length === 0 || parts.some((part) => part.trim() === "")) return null;
+  const ids = parts.map((part) => Number(part));
+  if (ids.some((id) => !Number.isInteger(id) || id <= 0) || new Set(ids).size !== ids.length) return null;
+  return ids;
+}
+
+
 export function validateAnalyseSearch(search: Record<string, unknown>): AnalyseSearch {
   return {
     track: parseOptionalNumber(search.track),
     car: parseOptionalNumber(search.car),
     lap: parseOptionalNumber(search.lap),
+    laps: typeof search.laps === "string" ? search.laps : undefined,
     cursor: parseOptionalNumber(search.cursor),
     viz: typeof search.viz === "string" ? search.viz : undefined,
     ai: parseOptionalNumber(search.ai),
+    view: typeof search.view === "string" ? search.view : undefined,
   };
 }