Add race control visuals and driver names in laps view

internal/api/openf1.go

@@ -273,24 +273,12 @@ func (c *OpenF1Client) getLatestRaceSessionKey() (int, error) {
 		return 0, errors.New("no Race sessions found")
 	}
 
-	// Walk backwards to find the most recent completed race.
 	now := time.Now()
-	for i := len(sessions) - 1; i >= 0; i-- {
-		s := sessions[i]
-		if s.DateEnd != "" {
-			endTime, err := time.Parse(time.RFC3339, s.DateEnd)
-			if err == nil && endTime.Before(now) {
-				return s.SessionKey, nil
-			}
-		} else if s.DateStart != "" {
-			startTime, err := time.Parse(time.RFC3339, s.DateStart)
-			if err == nil && startTime.Add(3*time.Hour).Before(now) {
-				return s.SessionKey, nil
-			}
-		}
+	latestKey, ok := latestCompletedRaceSessionKey(sessions, now)
+	if !ok {
+		return 0, errors.New("no completed Race sessions found")
 	}
-
-	return 0, errors.New("no completed Race sessions found")
+	return latestKey, nil
 }
 
 // getLatestRaceSessionKeyForYear returns the session_key of the most recent
@@ -311,25 +299,47 @@ func (c *OpenF1Client) getLatestRaceSessionKeyForYear(year int) (int, error) {
 		return 0, fmt.Errorf("no Race sessions found for year %d", year)
 	}
 
-	// Walk backwards to find the most recent completed race.
 	now := time.Now()
-	for i := len(sessions) - 1; i >= 0; i-- {
-		s := sessions[i]
-		if s.DateEnd != "" {
-			endTime, err := time.Parse(time.RFC3339, s.DateEnd)
-			if err == nil && endTime.Before(now) {
-				return s.SessionKey, nil
-			}
-		} else if s.DateStart != "" {
-			// Fallback: if no DateEnd, check DateStart + 3 hours as a rough estimate.
-			startTime, err := time.Parse(time.RFC3339, s.DateStart)
-			if err == nil && startTime.Add(3*time.Hour).Before(now) {
-				return s.SessionKey, nil
-			}
+	latestKey, ok := latestCompletedRaceSessionKey(sessions, now)
+	if !ok {
+		return 0, fmt.Errorf("no completed Race sessions found for year %d", year)
+	}
+	return latestKey, nil
+}
+
+func latestCompletedRaceSessionKey(sessions []models.Session, now time.Time) (int, bool) {
+	var latestKey int
+	var latestTime time.Time
+
+	for _, s := range sessions {
+		completedAt, ok := completedRaceTime(s)
+		if !ok || !completedAt.Before(now) {
+			continue
+		}
+		if latestKey == 0 || completedAt.After(latestTime) {
+			latestKey = s.SessionKey
+			latestTime = completedAt
 		}
 	}
 
-	return 0, fmt.Errorf("no completed Race sessions found for year %d", year)
+	return latestKey, latestKey != 0
+}
+
+func completedRaceTime(s models.Session) (time.Time, bool) {
+	if s.DateEnd != "" {
+		endTime, err := time.Parse(time.RFC3339, s.DateEnd)
+		if err == nil {
+			return endTime, true
+		}
+	}
+	if s.DateStart == "" {
+		return time.Time{}, false
+	}
+	startTime, err := time.Parse(time.RFC3339, s.DateStart)
+	if err != nil {
+		return time.Time{}, false
+	}
+	return startTime.Add(3 * time.Hour), true
 }
 
 // GetLatestDriverChampionship returns championship standings for the most recent

internal/api/session_selection_test.go

@@ -0,0 +1,60 @@
+package api
+
+import (
+	"testing"
+	"time"
+
+	"github.com/AmanTahiliani/box-box/internal/models"
+)
+
+func TestLatestCompletedRaceSessionKeyUsesDatesNotInputOrder(t *testing.T) {
+	now := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
+	sessions := []models.Session{
+		{
+			SessionKey:  1,
+			SessionName: "Race",
+			DateStart:   "2025-12-01T13:00:00+00:00",
+			DateEnd:     "2025-12-01T15:00:00+00:00",
+		},
+		{
+			SessionKey:  2,
+			SessionName: "Race",
+			DateStart:   "2025-03-01T13:00:00+00:00",
+			DateEnd:     "2025-03-01T15:00:00+00:00",
+		},
+	}
+
+	sessionKey, ok := latestCompletedRaceSessionKey(sessions, now)
+	if !ok {
+		t.Fatal("expected a completed race")
+	}
+	if sessionKey != 1 {
+		t.Fatalf("sessionKey = %d, want 1", sessionKey)
+	}
+}
+
+func TestLatestCompletedRaceSessionKeyIgnoresFutureSessions(t *testing.T) {
+	now := time.Date(2025, 6, 1, 0, 0, 0, 0, time.UTC)
+	sessions := []models.Session{
+		{
+			SessionKey:  1,
+			SessionName: "Race",
+			DateStart:   "2025-12-01T13:00:00+00:00",
+			DateEnd:     "2025-12-01T15:00:00+00:00",
+		},
+		{
+			SessionKey:  2,
+			SessionName: "Race",
+			DateStart:   "2025-05-01T13:00:00+00:00",
+			DateEnd:     "2025-05-01T15:00:00+00:00",
+		},
+	}
+
+	sessionKey, ok := latestCompletedRaceSessionKey(sessions, now)
+	if !ok {
+		t.Fatal("expected a completed race")
+	}
+	if sessionKey != 2 {
+		t.Fatalf("sessionKey = %d, want 2", sessionKey)
+	}
+}

internal/ingest/openf1.go

@@ -357,11 +357,17 @@ func driverToStore(d models.Driver) store.Driver {
 
 func sessionDriverToStore(d models.Driver) store.SessionDriver {
 	return store.SessionDriver{
-		SessionKey:   d.SessionKey,
-		DriverNumber: d.DriverNumber,
-		MeetingKey:   d.MeetingKey,
-		TeamName:     d.TeamName,
-		TeamColour:   d.TeamColour,
+		SessionKey:    d.SessionKey,
+		DriverNumber:  d.DriverNumber,
+		MeetingKey:    d.MeetingKey,
+		BroadcastName: d.BroadcastName,
+		FirstName:     d.FirstName,
+		FullName:      d.FullName,
+		LastName:      d.LastName,
+		NameAcronym:   d.NameAcronym,
+		HeadshotURL:   d.HeadshotURL,
+		TeamName:      d.TeamName,
+		TeamColour:    d.TeamColour,
 	}
 }
 

internal/query/convert.go

@@ -40,6 +40,30 @@ func sessionToModel(s store.Session) models.Session {
 }
 
 func driverToModel(sessionKey, meetingKey int, sd store.SessionDriver, d store.Driver) models.Driver {
+	broadcastName := sd.BroadcastName
+	if broadcastName == "" {
+		broadcastName = d.BroadcastName
+	}
+	firstName := sd.FirstName
+	if firstName == "" {
+		firstName = d.FirstName
+	}
+	fullName := sd.FullName
+	if fullName == "" {
+		fullName = d.FullName
+	}
+	lastName := sd.LastName
+	if lastName == "" {
+		lastName = d.LastName
+	}
+	nameAcronym := sd.NameAcronym
+	if nameAcronym == "" {
+		nameAcronym = d.NameAcronym
+	}
+	headshotURL := sd.HeadshotURL
+	if headshotURL == "" {
+		headshotURL = d.HeadshotURL
+	}
 	teamName := sd.TeamName
 	if teamName == "" {
 		teamName = d.TeamName
@@ -49,14 +73,14 @@ func driverToModel(sessionKey, meetingKey int, sd store.SessionDriver, d store.D
 		teamColour = d.TeamColour
 	}
 	return models.Driver{
-		BroadcastName: d.BroadcastName,
+		BroadcastName: broadcastName,
 		DriverNumber:  sd.DriverNumber,
-		FirstName:     d.FirstName,
-		FullName:      d.FullName,
-		HeadshotURL:   d.HeadshotURL,
-		LastName:      d.LastName,
+		FirstName:     firstName,
+		FullName:      fullName,
+		HeadshotURL:   headshotURL,
+		LastName:      lastName,
 		MeetingKey:    meetingKey,
-		NameAcronym:   d.NameAcronym,
+		NameAcronym:   nameAcronym,
 		SessionKey:    sessionKey,
 		TeamColour:    teamColour,
 		TeamName:      teamName,

internal/store/coverage_test.go

@@ -7,13 +7,13 @@ import (
 func TestCoverageCRUD(t *testing.T) {
 	s := openTestStore(t)
 
-	// Verify schema migration version is 5 (since we added 005_news_enriched.sql)
+	// Verify all migrations are applied.
 	version, err := s.SchemaVersion()
 	if err != nil {
 		t.Fatalf("SchemaVersion() error = %v", err)
 	}
-	if version != 5 {
-		t.Fatalf("SchemaVersion() = %d, want 5", version)
+	if version != 6 {
+		t.Fatalf("SchemaVersion() = %d, want 6", version)
 	}
 
 	// Verify session_coverage table exists

internal/store/migrations/006_session_driver_identity.sql

@@ -0,0 +1,6 @@
+ALTER TABLE session_drivers ADD COLUMN broadcast_name TEXT;
+ALTER TABLE session_drivers ADD COLUMN first_name TEXT;
+ALTER TABLE session_drivers ADD COLUMN full_name TEXT;
+ALTER TABLE session_drivers ADD COLUMN last_name TEXT;
+ALTER TABLE session_drivers ADD COLUMN name_acronym TEXT;
+ALTER TABLE session_drivers ADD COLUMN headshot_url TEXT;

internal/store/models.go

@@ -42,16 +42,16 @@ type NewsSource struct {
 
 // NewsItem stores a normalized feed item deduplicated by URL.
 type NewsItem struct {
-	URL            string
-	Source         string
-	Title          string
-	PublishedAt    *time.Time
-	Summary        string
-	Category       string
-	FetchedAt      time.Time
-	OGImageURL     string
-	OGDescription  string
-	ReadAt         *time.Time
+	URL           string
+	Source        string
+	Title         string
+	PublishedAt   *time.Time
+	Summary       string
+	Category      string
+	FetchedAt     time.Time
+	OGImageURL    string
+	OGDescription string
+	ReadAt        *time.Time
 }
 
 // Meeting is a race weekend record.
@@ -100,11 +100,17 @@ type Driver struct {
 
 // SessionDriver links a driver to a session with session-specific team info.
 type SessionDriver struct {
-	SessionKey   int
-	DriverNumber int
-	MeetingKey   int
-	TeamName     string
-	TeamColour   string
+	SessionKey    int
+	DriverNumber  int
+	MeetingKey    int
+	BroadcastName string
+	FirstName     string
+	FullName      string
+	LastName      string
+	NameAcronym   string
+	HeadshotURL   string
+	TeamName      string
+	TeamColour    string
 }
 
 // SessionResult is a final classification row for a session.

internal/store/results.go

@@ -88,16 +88,29 @@ func (s *Store) GetDriver(driverNumber int) (Driver, error) {
 func (s *Store) UpsertSessionDriver(sd SessionDriver) error {
 	_, err := s.db.Exec(`
 		INSERT INTO session_drivers (
-			session_key, driver_number, meeting_key, team_name, team_colour
-		) VALUES (?, ?, ?, ?, ?)
+			session_key, driver_number, meeting_key, broadcast_name, first_name,
+			full_name, last_name, name_acronym, headshot_url, team_name, team_colour
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 		ON CONFLICT(session_key, driver_number) DO UPDATE SET
 			meeting_key = excluded.meeting_key,
+			broadcast_name = excluded.broadcast_name,
+			first_name = excluded.first_name,
+			full_name = excluded.full_name,
+			last_name = excluded.last_name,
+			name_acronym = excluded.name_acronym,
+			headshot_url = excluded.headshot_url,
 			team_name = excluded.team_name,
 			team_colour = excluded.team_colour
 	`,
 		sd.SessionKey,
 		sd.DriverNumber,
 		sd.MeetingKey,
+		nullString(sd.BroadcastName),
+		nullString(sd.FirstName),
+		nullString(sd.FullName),
+		nullString(sd.LastName),
+		nullString(sd.NameAcronym),
+		nullString(sd.HeadshotURL),
 		nullString(sd.TeamName),
 		nullString(sd.TeamColour),
 	)
@@ -110,7 +123,8 @@ func (s *Store) UpsertSessionDriver(sd SessionDriver) error {
 // ListSessionDrivers returns drivers entered for a session ordered by number.
 func (s *Store) ListSessionDrivers(sessionKey int) ([]SessionDriver, error) {
 	rows, err := s.db.Query(`
-		SELECT session_key, driver_number, meeting_key, team_name, team_colour
+		SELECT session_key, driver_number, meeting_key, broadcast_name, first_name,
+		       full_name, last_name, name_acronym, headshot_url, team_name, team_colour
 		FROM session_drivers
 		WHERE session_key = ?
 		ORDER BY driver_number ASC
@@ -123,16 +137,29 @@ func (s *Store) ListSessionDrivers(sessionKey int) ([]SessionDriver, error) {
 	var out []SessionDriver
 	for rows.Next() {
 		var sd SessionDriver
+		var broadcastName, firstName, fullName, lastName, nameAcronym, headshotURL sql.NullString
 		var teamName, teamColour sql.NullString
 		if err := rows.Scan(
 			&sd.SessionKey,
 			&sd.DriverNumber,
 			&sd.MeetingKey,
+			&broadcastName,
+			&firstName,
+			&fullName,
+			&lastName,
+			&nameAcronym,
+			&headshotURL,
 			&teamName,
 			&teamColour,
 		); err != nil {
 			return nil, err
 		}
+		sd.BroadcastName = broadcastName.String
+		sd.FirstName = firstName.String
+		sd.FullName = fullName.String
+		sd.LastName = lastName.String
+		sd.NameAcronym = nameAcronym.String
+		sd.HeadshotURL = headshotURL.String
 		sd.TeamName = teamName.String
 		sd.TeamColour = teamColour.String
 		out = append(out, sd)

internal/store/store_test.go

@@ -28,8 +28,8 @@ func TestOpenAppliesMigrations(t *testing.T) {
 	if err != nil {
 		t.Fatalf("SchemaVersion() error = %v", err)
 	}
-	if version != 5 {
-		t.Fatalf("SchemaVersion() = %d, want 5", version)
+	if version != 6 {
+		t.Fatalf("SchemaVersion() = %d, want 6", version)
 	}
 
 	tables := []string{

internal/ui/app.go

@@ -272,6 +272,13 @@ func (m AppModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.calendar.loading = true
 			m.standings.year = m.year
 			m.standings.loading = true
+			m.standings.err = nil
+			m.standings.stale = false
+			m.standings.driverStandings = nil
+			m.standings.teamStandings = nil
+			m.standings.drivers = make(map[int]models.Driver)
+			m.standings.cursor = 0
+			m.standings.scroll = 0
 
 			return m, tea.Batch(
 				m.calendar.Init(),

internal/ui/messages.go

@@ -5,19 +5,23 @@ import "github.com/AmanTahiliani/box-box/internal/models"
 // driverChampionshipLoadedMsg carries the loaded driver championship data.
 type driverChampionshipLoadedMsg struct {
 	standings []models.ChampionshipDriver
+	year      int
 	err       error
 }
 
 // teamChampionshipLoadedMsg carries the loaded team championship data.
 type teamChampionshipLoadedMsg struct {
 	standings []models.ChampionshipTeam
+	year      int
 	err       error
 }
 
 // standingsDriversLoadedMsg carries drivers for the standings join.
 type standingsDriversLoadedMsg struct {
-	drivers []models.Driver
-	err     error
+	drivers    []models.Driver
+	year       int
+	sessionKey int
+	err        error
 }
 
 // meetingsLoadedMsg carries the full meeting list for the calendar.

internal/ui/replay.go

@@ -499,7 +499,13 @@ func (m ReplayModel) renderReplay() string {
 		name := fmt.Sprintf("#%d", dp.driverNum)
 		teamColor := colorMuted
 		if ok {
-			name = d.NameAcronym
+			name = d.FullName
+			if name == "" {
+				name = d.BroadcastName
+			}
+			if name == "" {
+				name = d.NameAcronym
+			}
 			if d.TeamColour != "" {
 				teamColor = "#" + d.TeamColour
 			} else {
@@ -508,7 +514,10 @@ func (m ReplayModel) renderReplay() string {
 		}
 
 		colorBar := lipgloss.NewStyle().Foreground(lipgloss.Color(teamColor)).Render("┃")
-		nameStyled := lipgloss.NewStyle().Foreground(lipgloss.Color(teamColor)).Bold(true).Render(padRight(name, 4))
+		numberStyled := lipgloss.NewStyle().Foreground(lipgloss.Color(teamColor)).Bold(true).
+			Render(padRight(fmt.Sprintf("%d", dp.driverNum), 4))
+		nameStyled := lipgloss.NewStyle().Foreground(lipgloss.Color(teamColor)).Bold(true).
+			Render(padRight(truncate(name, 18), 18))
 		posStyled := renderPosition(dp.pos)
 
 		// Lap time
@@ -524,9 +533,10 @@ func (m ReplayModel) renderReplay() string {
 				Render(fmt.Sprintf("PIT %.1fs", dur))
 		}
 
-		sb.WriteString(fmt.Sprintf("  %s  %s  %s  %s  %s\n",
+		sb.WriteString(fmt.Sprintf("  %s  %s%s  %s  %s  %s\n",
 			padRightVisible(posStyled, 4),
 			colorBar,
+			numberStyled,
 			nameStyled,
 			ltStr,
 			pitStr,

internal/ui/standings.go

@@ -65,21 +65,21 @@ func (m StandingsModel) Init() tea.Cmd {
 func fetchDriverChampionship(client *api.OpenF1Client, year int) tea.Cmd {
 	return func() tea.Msg {
 		standings, err := client.GetDriverChampionshipForYear(year)
-		return driverChampionshipLoadedMsg{standings: standings, err: err}
+		return driverChampionshipLoadedMsg{standings: standings, year: year, err: err}
 	}
 }
 
 func fetchTeamChampionship(client *api.OpenF1Client, year int) tea.Cmd {
 	return func() tea.Msg {
 		standings, err := client.GetTeamChampionshipForYear(year)
-		return teamChampionshipLoadedMsg{standings: standings, err: err}
+		return teamChampionshipLoadedMsg{standings: standings, year: year, err: err}
 	}
 }
 
-func fetchStandingsDrivers(client *api.OpenF1Client, sessionKey int) tea.Cmd {
+func fetchStandingsDrivers(client *api.OpenF1Client, year, sessionKey int) tea.Cmd {
 	return func() tea.Msg {
 		drivers, err := client.GetDriversForSession(sessionKey)
-		return standingsDriversLoadedMsg{drivers: drivers, err: err}
+		return standingsDriversLoadedMsg{drivers: drivers, year: year, sessionKey: sessionKey, err: err}
 	}
 }
 
@@ -99,21 +99,28 @@ func (m StandingsModel) Update(msg tea.Msg) (StandingsModel, tea.Cmd) {
 		}
 
 	case driverChampionshipLoadedMsg:
+		if msg.year != m.year {
+			return m, nil
+		}
 		if msg.err != nil {
 			m.err = msg.err
 			m.loading = false
 			return m, nil
 		}
 		m.driverStandings = msg.standings
+		m.drivers = make(map[int]models.Driver)
 		if m.client.LastResponseWasStale() {
 			m.stale = true
 		}
 		if len(msg.standings) > 0 {
-			return m, fetchStandingsDrivers(m.client, msg.standings[0].SessionKey)
+			return m, fetchStandingsDrivers(m.client, msg.year, msg.standings[0].SessionKey)
 		}
 		m.loading = false
 
 	case teamChampionshipLoadedMsg:
+		if msg.year != m.year {
+			return m, nil
+		}
 		if msg.err != nil {
 			m.err = msg.err
 			return m, nil
@@ -124,6 +131,12 @@ func (m StandingsModel) Update(msg tea.Msg) (StandingsModel, tea.Cmd) {
 		}
 
 	case standingsDriversLoadedMsg:
+		if msg.year != m.year {
+			return m, nil
+		}
+		if len(m.driverStandings) > 0 && msg.sessionKey != m.driverStandings[0].SessionKey {
+			return m, nil
+		}
 		if msg.err != nil {
 			m.err = msg.err
 			m.loading = false

internal/web/api.go

@@ -557,12 +557,13 @@ func (s *Server) handleChampionshipDrivers(w http.ResponseWriter, r *http.Reques
 	}
 
 	drivers, _ := s.client.GetDriversForSession(champ[0].SessionKey)
-	driverMap := buildDriverMap(drivers)
+	driverMap := buildDriverMapFirst(drivers)
 
 	enriched := make([]champDriverWithInfo, 0, len(champ))
 	for _, c := range champ {
 		e := champDriverWithInfo{ChampionshipDriver: c}
-		if d, ok := driverMap[c.DriverNumber]; ok {
+		d, ok := s.championshipDriverInfo(c.SessionKey, c.DriverNumber, driverMap)
+		if ok {
 			e.NameAcronym = d.NameAcronym
 			e.FullName = d.FullName
 			e.TeamName = d.TeamName
@@ -573,6 +574,14 @@ func (s *Server) handleChampionshipDrivers(w http.ResponseWriter, r *http.Reques
 	writeJSON(w, enriched)
 }
 
+func (s *Server) championshipDriverInfo(sessionKey, driverNumber int, fallback map[int]models.Driver) (models.Driver, bool) {
+	if d, err := s.client.GetDriver(sessionKey, driverNumber); err == nil && d != nil {
+		return *d, true
+	}
+	d, ok := fallback[driverNumber]
+	return d, ok
+}
+
 // --- /api/v1/championship/teams ---
 
 func (s *Server) handleChampionshipTeams(w http.ResponseWriter, r *http.Request) {
@@ -1026,6 +1035,16 @@ func buildDriverMap(drivers []models.Driver) map[int]models.Driver {
 	return m
 }
 
+func buildDriverMapFirst(drivers []models.Driver) map[int]models.Driver {
+	m := make(map[int]models.Driver, len(drivers))
+	for _, d := range drivers {
+		if _, exists := m[d.DriverNumber]; !exists {
+			m[d.DriverNumber] = d
+		}
+	}
+	return m
+}
+
 func enrichedResultsToAPI(results []query.EnrichedResult) []resultWithDriver {
 	out := make([]resultWithDriver, 0, len(results))
 	for _, res := range results {

internal/web/racehub_test.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/AmanTahiliani/box-box/internal/api"
+	"github.com/AmanTahiliani/box-box/internal/models"
 	"github.com/AmanTahiliani/box-box/internal/query"
 	"github.com/AmanTahiliani/box-box/internal/store"
 )
@@ -151,6 +152,19 @@ func TestHandleRaceHubRequiresSessionKey(t *testing.T) {
 	}
 }
 
+func TestBuildDriverMapFirstKeepsFirstDuplicateDriverNumber(t *testing.T) {
+	drivers := []models.Driver{
+		{DriverNumber: 4, NameAcronym: "NOR", TeamName: "McLaren"},
+		{DriverNumber: 4, NameAcronym: "NOR", TeamName: "Red Bull Racing"},
+	}
+
+	driverMap := buildDriverMapFirst(drivers)
+	driver := driverMap[4]
+	if driver.TeamName != "McLaren" {
+		t.Fatalf("team = %q, want McLaren", driver.TeamName)
+	}
+}
+
 func TestHandleSeasonsEmpty(t *testing.T) {
 	srv := testServer(t, nil)
 	req := httptest.NewRequest(http.MethodGet, "/api/v1/seasons", nil)