Add race manager

db/db.go

@@ -2,6 +2,7 @@ package db
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 	"log/slog"
 	"os"
@@ -11,6 +12,9 @@ import (
 	_ "github.com/mattn/go-sqlite3"
 )
 
+// ErrNotFound is returned when a requested record is not found
+var ErrNotFound = errors.New("record not found")
+
 // DB represents the database connection
 type DB struct {
 	*sql.DB
@@ -134,6 +138,46 @@ func (db *DB) initSchema() error {
 		return fmt.Errorf("failed to create heats table: %w", err)
 	}
 
+	// Create settings table
+	_, err = db.Exec(`
+		CREATE TABLE IF NOT EXISTS settings (
+			key TEXT PRIMARY KEY,
+			value TEXT NOT NULL
+		);
+	`)
+	if err != nil {
+		return fmt.Errorf("failed to create settings table: %w", err)
+	}
+
+	// Create heat_results table
+	_, err = db.Exec(`
+		CREATE TABLE IF NOT EXISTS heat_results (
+			group_id INTEGER NOT NULL,
+			heat_number INTEGER NOT NULL,
+			lane1_time REAL NOT NULL,
+			lane1_position INTEGER NOT NULL,
+			lane2_time REAL NOT NULL,
+			lane2_position INTEGER NOT NULL,
+			lane3_time REAL NOT NULL,
+			lane3_position INTEGER NOT NULL,
+			lane4_time REAL NOT NULL,
+			lane4_position INTEGER NOT NULL,
+			PRIMARY KEY (group_id, heat_number),
+			FOREIGN KEY (group_id) REFERENCES groups (id) ON DELETE CASCADE
+		);
+	`)
+	if err != nil {
+		return fmt.Errorf("failed to create heat_results table: %w", err)
+	}
+
+	// Add default settings if they don't exist
+	_, err = db.Exec(`
+		INSERT OR IGNORE INTO settings (key, value) VALUES ('current_racing_group', '1');
+	`)
+	if err != nil {
+		return fmt.Errorf("failed to add default settings: %w", err)
+	}
+
 	return nil
 }
 
@@ -220,3 +264,180 @@ func (db *DB) DeleteHeats(groupID int64) error {
 	_, err := db.Exec("DELETE FROM heats WHERE group_id = ?", groupID)
 	return err
 }
+
+// GetCurrentRacingGroup gets the currently racing group
+func (db *DB) GetCurrentRacingGroup() (models.Group, error) {
+	var group models.Group
+
+	// Get the current racing group ID from settings
+	var groupID int64
+	err := db.QueryRow("SELECT value FROM settings WHERE key = 'current_racing_group'").Scan(&groupID)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			// If no group is set, get the first group
+			err = db.QueryRow("SELECT id, name, description FROM groups ORDER BY id LIMIT 1").Scan(
+				&group.ID, &group.Name, &group.Description)
+			if err != nil {
+				return group, err
+			}
+
+			// Set this as the current racing group
+			_, err = db.Exec("INSERT OR REPLACE INTO settings (key, value) VALUES ('current_racing_group', ?)", group.ID)
+			return group, err
+		}
+		return group, err
+	}
+
+	// Get the group details
+	err = db.QueryRow("SELECT id, name, description FROM groups WHERE id = ?", groupID).Scan(
+		&group.ID, &group.Name, &group.Description)
+	return group, err
+}
+
+// SetCurrentRacingGroup sets the currently racing group
+func (db *DB) SetCurrentRacingGroup(groupID int64) error {
+	_, err := db.Exec("INSERT OR REPLACE INTO settings (key, value) VALUES ('current_racing_group', ?)", groupID)
+	return err
+}
+
+// GetCurrentHeatNumber gets the current heat number for a group
+func (db *DB) GetCurrentHeatNumber(groupID int64) (int, error) {
+	var heatNum int
+	key := fmt.Sprintf("current_heat_%d", groupID)
+
+	err := db.QueryRow("SELECT value FROM settings WHERE key = ?", key).Scan(&heatNum)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			// If no heat is set, default to 1
+			_, err = db.Exec("INSERT INTO settings (key, value) VALUES (?, 1)", key)
+			return 1, err
+		}
+		return 0, err
+	}
+
+	return heatNum, nil
+}
+
+// SetCurrentHeatNumber sets the current heat number for a group
+func (db *DB) SetCurrentHeatNumber(groupID int64, heatNum int) error {
+	key := fmt.Sprintf("current_heat_%d", groupID)
+	_, err := db.Exec("INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)", key, heatNum)
+	return err
+}
+
+// SaveHeatResult saves the result of a heat
+func (db *DB) SaveHeatResult(result models.HeatResult) error {
+	// Check if result already exists
+	var count int
+	err := db.QueryRow("SELECT COUNT(*) FROM heat_results WHERE group_id = ? AND heat_number = ?",
+		result.GroupID, result.HeatNumber).Scan(&count)
+	if err != nil {
+		return err
+	}
+
+	if count > 0 {
+		// Update existing result
+		_, err = db.Exec(`
+			UPDATE heat_results SET 
+				lane1_time = ?, lane1_position = ?,
+				lane2_time = ?, lane2_position = ?,
+				lane3_time = ?, lane3_position = ?,
+				lane4_time = ?, lane4_position = ?
+			WHERE group_id = ? AND heat_number = ?`,
+			result.Lane1Time, result.Lane1Position,
+			result.Lane2Time, result.Lane2Position,
+			result.Lane3Time, result.Lane3Position,
+			result.Lane4Time, result.Lane4Position,
+			result.GroupID, result.HeatNumber)
+	} else {
+		// Insert new result
+		_, err = db.Exec(`
+			INSERT INTO heat_results (
+				group_id, heat_number,
+				lane1_time, lane1_position,
+				lane2_time, lane2_position,
+				lane3_time, lane3_position,
+				lane4_time, lane4_position
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			result.GroupID, result.HeatNumber,
+			result.Lane1Time, result.Lane1Position,
+			result.Lane2Time, result.Lane2Position,
+			result.Lane3Time, result.Lane3Position,
+			result.Lane4Time, result.Lane4Position)
+	}
+
+	return err
+}
+
+// GetHeatResult gets the result of a specific heat
+func (db *DB) GetHeatResult(groupID int64, heatNum int) (*models.HeatResult, error) {
+	result := &models.HeatResult{}
+
+	err := db.QueryRow(`
+		SELECT 
+			group_id, heat_number,
+			lane1_time, lane1_position,
+			lane2_time, lane2_position,
+			lane3_time, lane3_position,
+			lane4_time, lane4_position
+		FROM heat_results 
+		WHERE group_id = ? AND heat_number = ?`,
+		groupID, heatNum).Scan(
+		&result.GroupID, &result.HeatNumber,
+		&result.Lane1Time, &result.Lane1Position,
+		&result.Lane2Time, &result.Lane2Position,
+		&result.Lane3Time, &result.Lane3Position,
+		&result.Lane4Time, &result.Lane4Position)
+
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, ErrNotFound
+		}
+		return nil, err
+	}
+
+	return result, nil
+}
+
+// GetHeatResults gets all heat results for a group
+func (db *DB) GetHeatResults(groupID int64) ([]models.HeatResult, error) {
+	rows, err := db.Query(`
+		SELECT 
+			group_id, heat_number,
+			lane1_time, lane1_position,
+			lane2_time, lane2_position,
+			lane3_time, lane3_position,
+			lane4_time, lane4_position
+		FROM heat_results 
+		WHERE group_id = ?
+		ORDER BY heat_number`,
+		groupID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var results []models.HeatResult
+	for rows.Next() {
+		var result models.HeatResult
+		err := rows.Scan(
+			&result.GroupID, &result.HeatNumber,
+			&result.Lane1Time, &result.Lane1Position,
+			&result.Lane2Time, &result.Lane2Position,
+			&result.Lane3Time, &result.Lane3Position,
+			&result.Lane4Time, &result.Lane4Position)
+		if err != nil {
+			return nil, err
+		}
+		results = append(results, result)
+	}
+
+	return results, nil
+}
+
+// DeleteHeatResult deletes a heat result
+func (db *DB) DeleteHeatResult(groupID int64, heatNum int) error {
+	_, err := db.Exec("DELETE FROM heat_results WHERE group_id = ? AND heat_number = ?",
+		groupID, heatNum)
+	return err
+}

models/models.go

@@ -53,3 +53,17 @@ type Heat struct {
 	Lane3ID *int64 `json:"lane3_id"`
 	Lane4ID *int64 `json:"lane4_id"`
 }
+
+// HeatResult represents the result of a heat
+type HeatResult struct {
+	GroupID       int64   `json:"group_id"`
+	HeatNumber    int     `json:"heat_number"`
+	Lane1Time     float64 `json:"lane1_time"`
+	Lane1Position int     `json:"lane1_position"`
+	Lane2Time     float64 `json:"lane2_time"`
+	Lane2Position int     `json:"lane2_position"`
+	Lane3Time     float64 `json:"lane3_time"`
+	Lane3Position int     `json:"lane3_position"`
+	Lane4Time     float64 `json:"lane4_time"`
+	Lane4Position int     `json:"lane4_position"`
+}

web/server.go

@@ -153,6 +153,20 @@ func (s *Server) routes() {
 
 	// Add validate car number route
 	s.router.Get("/api/validate/car-number", s.handleValidateCarNumber())
+
+	// Add race manager routes
+	s.router.Get("/race", s.handleRacePublic())
+	s.router.Get("/race/manage", s.handleRaceManage())
+
+	// Add race API routes
+	s.router.Route("/api/race", func(r chi.Router) {
+		r.Get("/current-heat", s.handleCurrentHeat())
+		r.Post("/next-heat", s.handleNextHeat())
+		r.Post("/previous-heat", s.handlePreviousHeat())
+		r.Post("/save-result", s.handleSaveHeatResult())
+		r.Post("/rerun-heat", s.handleRerunHeat())
+		r.Post("/set-group", s.handleSetRacingGroup())
+	})
 }
 
 // Start starts the web server
@@ -991,3 +1005,503 @@ func (s *Server) handleValidateCarNumber() http.HandlerFunc {
 		}
 	}
 }
+
+// handleRacePublic renders the public race view page
+func (s *Server) handleRacePublic() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Get the currently racing group
+		currentGroup, err := s.db.GetCurrentRacingGroup()
+		if err != nil {
+			s.logger.Error("Failed to get current racing group", "error", err)
+			http.Error(w, "Failed to get current racing group", http.StatusInternalServerError)
+			return
+		}
+
+		// Get current heat number
+		currentHeatNum, err := s.db.GetCurrentHeatNumber(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get current heat number", "error", err)
+			http.Error(w, "Failed to get current heat number", http.StatusInternalServerError)
+			return
+		}
+
+		// Get heats for the group
+		heats, err := s.db.GetHeats(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get heats", "error", err)
+			http.Error(w, "Failed to get heats", http.StatusInternalServerError)
+			return
+		}
+
+		// Get racers for the group
+		racers, err := s.db.GetRacersByGroup(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get racers", "error", err)
+			http.Error(w, "Failed to get racers", http.StatusInternalServerError)
+			return
+		}
+
+		// Get heat results
+		results, err := s.db.GetHeatResults(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get heat results", "error", err)
+			http.Error(w, "Failed to get heat results", http.StatusInternalServerError)
+			return
+		}
+
+		// Render template
+		component := templates.RacePublic(currentGroup, heats, racers, currentHeatNum, results)
+		if err := component.Render(r.Context(), w); err != nil {
+			s.logger.Error("Failed to render race public template", "error", err)
+			http.Error(w, "Failed to render page", http.StatusInternalServerError)
+		}
+	}
+}
+
+// handleRaceManage renders the race management page
+func (s *Server) handleRaceManage() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Get all groups
+		groups, err := s.db.GetGroups()
+		if err != nil {
+			s.logger.Error("Failed to get groups", "error", err)
+			http.Error(w, "Failed to get groups", http.StatusInternalServerError)
+			return
+		}
+
+		// Get the currently racing group
+		currentGroup, err := s.db.GetCurrentRacingGroup()
+		if err != nil {
+			s.logger.Error("Failed to get current racing group", "error", err)
+			http.Error(w, "Failed to get current racing group", http.StatusInternalServerError)
+			return
+		}
+
+		// Get current heat number
+		currentHeatNum, err := s.db.GetCurrentHeatNumber(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get current heat number", "error", err)
+			http.Error(w, "Failed to get current heat number", http.StatusInternalServerError)
+			return
+		}
+
+		// Get heats for the group
+		heats, err := s.db.GetHeats(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get heats", "error", err)
+			http.Error(w, "Failed to get heats", http.StatusInternalServerError)
+			return
+		}
+
+		// Get racers for the group
+		racers, err := s.db.GetRacersByGroup(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get racers", "error", err)
+			http.Error(w, "Failed to get racers", http.StatusInternalServerError)
+			return
+		}
+
+		// Get heat results
+		results, err := s.db.GetHeatResults(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get heat results", "error", err)
+			http.Error(w, "Failed to get heat results", http.StatusInternalServerError)
+			return
+		}
+
+		// Render template
+		component := templates.RaceManage(groups, currentGroup, heats, racers, currentHeatNum, results)
+		if err := component.Render(r.Context(), w); err != nil {
+			s.logger.Error("Failed to render race manage template", "error", err)
+			http.Error(w, "Failed to render page", http.StatusInternalServerError)
+		}
+	}
+}
+
+// API handlers for race management
+
+// handleCurrentHeat returns the current heat data
+func (s *Server) handleCurrentHeat() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Get the currently racing group
+		currentGroup, err := s.db.GetCurrentRacingGroup()
+		if err != nil {
+			s.logger.Error("Failed to get current racing group", "error", err)
+			http.Error(w, "Failed to get current racing group", http.StatusInternalServerError)
+			return
+		}
+
+		// Get current heat number
+		currentHeatNum, err := s.db.GetCurrentHeatNumber(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get current heat number", "error", err)
+			http.Error(w, "Failed to get current heat number", http.StatusInternalServerError)
+			return
+		}
+
+		// Get heats for the group
+		heats, err := s.db.GetHeats(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get heats", "error", err)
+			http.Error(w, "Failed to get heats", http.StatusInternalServerError)
+			return
+		}
+
+		// Get racers for the group
+		racers, err := s.db.GetRacersByGroup(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get racers", "error", err)
+			http.Error(w, "Failed to get racers", http.StatusInternalServerError)
+			return
+		}
+
+		// Find current heat
+		var currentHeat models.Heat
+		for _, heat := range heats {
+			if heat.HeatNum == currentHeatNum {
+				currentHeat = heat
+				break
+			}
+		}
+
+		// Create response with racer details
+		type LaneInfo struct {
+			Lane     int         `json:"lane"`
+			RacerID  int64       `json:"racer_id"`
+			Name     string      `json:"name"`
+			CarNum   string      `json:"car_number"`
+			Time     interface{} `json:"time"`
+			Position interface{} `json:"position"`
+		}
+
+		response := struct {
+			HeatNumber int        `json:"heat_number"`
+			TotalHeats int        `json:"total_heats"`
+			GroupID    int64      `json:"group_id"`
+			GroupName  string     `json:"group_name"`
+			Lanes      []LaneInfo `json:"lanes"`
+		}{
+			HeatNumber: currentHeatNum,
+			TotalHeats: len(heats),
+			GroupID:    currentGroup.ID,
+			GroupName:  currentGroup.Name,
+			Lanes:      make([]LaneInfo, 0),
+		}
+
+		// Get heat result if available
+		result, err := s.db.GetHeatResult(currentGroup.ID, currentHeatNum)
+		if err != nil && err != db.ErrNotFound {
+			s.logger.Error("Failed to get heat result", "error", err)
+		}
+
+		// Add lane 1 info
+		if currentHeat.Lane1ID != nil {
+			lane := LaneInfo{Lane: 1, RacerID: *currentHeat.Lane1ID}
+			for _, racer := range racers {
+				if racer.ID == *currentHeat.Lane1ID {
+					lane.Name = racer.FirstName + " " + racer.LastName
+					lane.CarNum = racer.CarNumber
+					break
+				}
+			}
+			if result != nil {
+				lane.Time = result.Lane1Time
+				lane.Position = result.Lane1Position
+			}
+			response.Lanes = append(response.Lanes, lane)
+		}
+
+		// Add lane 2 info
+		if currentHeat.Lane2ID != nil {
+			lane := LaneInfo{Lane: 2, RacerID: *currentHeat.Lane2ID}
+			for _, racer := range racers {
+				if racer.ID == *currentHeat.Lane2ID {
+					lane.Name = racer.FirstName + " " + racer.LastName
+					lane.CarNum = racer.CarNumber
+					break
+				}
+			}
+			if result != nil {
+				lane.Time = result.Lane2Time
+				lane.Position = result.Lane2Position
+			}
+			response.Lanes = append(response.Lanes, lane)
+		}
+
+		// Add lane 3 info
+		if currentHeat.Lane3ID != nil {
+			lane := LaneInfo{Lane: 3, RacerID: *currentHeat.Lane3ID}
+			for _, racer := range racers {
+				if racer.ID == *currentHeat.Lane3ID {
+					lane.Name = racer.FirstName + " " + racer.LastName
+					lane.CarNum = racer.CarNumber
+					break
+				}
+			}
+			if result != nil {
+				lane.Time = result.Lane3Time
+				lane.Position = result.Lane3Position
+			}
+			response.Lanes = append(response.Lanes, lane)
+		}
+
+		// Add lane 4 info
+		if currentHeat.Lane4ID != nil {
+			lane := LaneInfo{Lane: 4, RacerID: *currentHeat.Lane4ID}
+			for _, racer := range racers {
+				if racer.ID == *currentHeat.Lane4ID {
+					lane.Name = racer.FirstName + " " + racer.LastName
+					lane.CarNum = racer.CarNumber
+					break
+				}
+			}
+			if result != nil {
+				lane.Time = result.Lane4Time
+				lane.Position = result.Lane4Position
+			}
+			response.Lanes = append(response.Lanes, lane)
+		}
+
+		// Return JSON response
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(response)
+	}
+}
+
+// handleNextHeat advances to the next heat
+func (s *Server) handleNextHeat() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Get the currently racing group
+		currentGroup, err := s.db.GetCurrentRacingGroup()
+		if err != nil {
+			s.logger.Error("Failed to get current racing group", "error", err)
+			http.Error(w, "Failed to get current racing group", http.StatusInternalServerError)
+			return
+		}
+
+		// Get current heat number
+		currentHeatNum, err := s.db.GetCurrentHeatNumber(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get current heat number", "error", err)
+			http.Error(w, "Failed to get current heat number", http.StatusInternalServerError)
+			return
+		}
+
+		// Get heats for the group
+		heats, err := s.db.GetHeats(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get heats", "error", err)
+			http.Error(w, "Failed to get heats", http.StatusInternalServerError)
+			return
+		}
+
+		// Check if we're already at the last heat
+		if currentHeatNum >= len(heats) {
+			http.Error(w, "Already at the last heat", http.StatusBadRequest)
+			return
+		}
+
+		// Advance to next heat
+		if err := s.db.SetCurrentHeatNumber(currentGroup.ID, currentHeatNum+1); err != nil {
+			s.logger.Error("Failed to set current heat number", "error", err)
+			http.Error(w, "Failed to advance to next heat", http.StatusInternalServerError)
+			return
+		}
+
+		// Reset the clock
+		if err := s.clock.Reset(); err != nil {
+			s.logger.Error("Failed to reset clock", "error", err)
+		}
+
+		// Broadcast event to admin page
+		select {
+		case s.adminEvents <- "heat-changed":
+			// Event sent
+		default:
+			// Channel full, non-blocking
+		}
+
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{"status": "success"})
+	}
+}
+
+// handlePreviousHeat goes back to the previous heat
+func (s *Server) handlePreviousHeat() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Get the currently racing group
+		currentGroup, err := s.db.GetCurrentRacingGroup()
+		if err != nil {
+			s.logger.Error("Failed to get current racing group", "error", err)
+			http.Error(w, "Failed to get current racing group", http.StatusInternalServerError)
+			return
+		}
+
+		// Get current heat number
+		currentHeatNum, err := s.db.GetCurrentHeatNumber(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get current heat number", "error", err)
+			http.Error(w, "Failed to get current heat number", http.StatusInternalServerError)
+			return
+		}
+
+		// Check if we're already at the first heat
+		if currentHeatNum <= 1 {
+			http.Error(w, "Already at the first heat", http.StatusBadRequest)
+			return
+		}
+
+		// Go back to previous heat
+		if err := s.db.SetCurrentHeatNumber(currentGroup.ID, currentHeatNum-1); err != nil {
+			s.logger.Error("Failed to set current heat number", "error", err)
+			http.Error(w, "Failed to go back to previous heat", http.StatusInternalServerError)
+			return
+		}
+
+		// Reset the clock
+		if err := s.clock.Reset(); err != nil {
+			s.logger.Error("Failed to reset clock", "error", err)
+		}
+
+		// Broadcast event to admin page
+		select {
+		case s.adminEvents <- "heat-changed":
+			// Event sent
+		default:
+			// Channel full, non-blocking
+		}
+
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{"status": "success"})
+	}
+}
+
+// handleSaveHeatResult saves the result of a heat
+func (s *Server) handleSaveHeatResult() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Parse request body
+		var request struct {
+			GroupID       int64   `json:"group_id"`
+			HeatNumber    int     `json:"heat_number"`
+			Lane1Time     float64 `json:"lane1_time"`
+			Lane1Position int     `json:"lane1_position"`
+			Lane2Time     float64 `json:"lane2_time"`
+			Lane2Position int     `json:"lane2_position"`
+			Lane3Time     float64 `json:"lane3_time"`
+			Lane3Position int     `json:"lane3_position"`
+			Lane4Time     float64 `json:"lane4_time"`
+			Lane4Position int     `json:"lane4_position"`
+		}
+
+		if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+			http.Error(w, "Invalid request body", http.StatusBadRequest)
+			return
+		}
+
+		// Create heat result
+		result := models.HeatResult{
+			GroupID:       request.GroupID,
+			HeatNumber:    request.HeatNumber,
+			Lane1Time:     request.Lane1Time,
+			Lane1Position: request.Lane1Position,
+			Lane2Time:     request.Lane2Time,
+			Lane2Position: request.Lane2Position,
+			Lane3Time:     request.Lane3Time,
+			Lane3Position: request.Lane3Position,
+			Lane4Time:     request.Lane4Time,
+			Lane4Position: request.Lane4Position,
+		}
+
+		// Save heat result
+		if err := s.db.SaveHeatResult(result); err != nil {
+			s.logger.Error("Failed to save heat result", "error", err)
+			http.Error(w, "Failed to save heat result", http.StatusInternalServerError)
+			return
+		}
+
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{"status": "success"})
+	}
+}
+
+// handleRerunHeat marks a heat for rerun
+func (s *Server) handleRerunHeat() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Get the currently racing group
+		currentGroup, err := s.db.GetCurrentRacingGroup()
+		if err != nil {
+			s.logger.Error("Failed to get current racing group", "error", err)
+			http.Error(w, "Failed to get current racing group", http.StatusInternalServerError)
+			return
+		}
+
+		// Get current heat number
+		currentHeatNum, err := s.db.GetCurrentHeatNumber(currentGroup.ID)
+		if err != nil {
+			s.logger.Error("Failed to get current heat number", "error", err)
+			http.Error(w, "Failed to get current heat number", http.StatusInternalServerError)
+			return
+		}
+
+		// Delete any existing result for this heat
+		if err := s.db.DeleteHeatResult(currentGroup.ID, currentHeatNum); err != nil {
+			s.logger.Error("Failed to delete heat result", "error", err)
+			http.Error(w, "Failed to mark heat for rerun", http.StatusInternalServerError)
+			return
+		}
+
+		// Reset the clock
+		if err := s.clock.Reset(); err != nil {
+			s.logger.Error("Failed to reset clock", "error", err)
+		}
+
+		// Broadcast event to admin page
+		select {
+		case s.adminEvents <- "heat-rerun":
+			// Event sent
+		default:
+			// Channel full, non-blocking
+		}
+
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{"status": "success"})
+	}
+}
+
+// handleSetRacingGroup sets the currently racing group
+func (s *Server) handleSetRacingGroup() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Parse request body
+		var request struct {
+			GroupID int64 `json:"group_id"`
+		}
+
+		if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+			http.Error(w, "Invalid request body", http.StatusBadRequest)
+			return
+		}
+
+		// Set current racing group
+		if err := s.db.SetCurrentRacingGroup(request.GroupID); err != nil {
+			s.logger.Error("Failed to set current racing group", "error", err)
+			http.Error(w, "Failed to set current racing group", http.StatusInternalServerError)
+			return
+		}
+
+		// Reset the clock
+		if err := s.clock.Reset(); err != nil {
+			s.logger.Error("Failed to reset clock", "error", err)
+		}
+
+		// Broadcast event to admin page
+		select {
+		case s.adminEvents <- "group-changed":
+			// Event sent
+		default:
+			// Channel full, non-blocking
+		}
+
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{"status": "success"})
+	}
+}

web/templates/race_manage.templ

@@ -0,0 +1,449 @@
+package templates
+
+import (
+    "track-gopher/models"
+    "fmt"
+    "strconv"
+)
+
+// RaceManage renders the race management view
+templ RaceManage(groups []models.Group, currentGroup models.Group, heats []models.Heat, racers []models.Racer, currentHeatNum int, results []models.HeatResult) {
+    @Layout("Race Management") {
+        <div class="container-fluid mt-3">
+            <div class="row mb-4">
+                <div class="col-md-6">
+                    <div class="card">
+                        <div class="card-header bg-primary text-white">
+                            <h3 class="mb-0">Race Controls</h3>
+                        </div>
+                        <div class="card-body">
+                            <div class="mb-3">
+                                <label for="group-select" class="form-label">Racing Group</label>
+                                <select id="group-select" class="form-select" hx-post="/api/race/set-group" hx-trigger="change" hx-vals='js:{"group_id": parseInt(this.value)}' hx-swap="none">
+                                    for _, group := range groups {
+                                        <option value={ fmt.Sprintf("%d", group.ID) } selected?={ group.ID == currentGroup.ID }>
+                                            { group.Name }
+                                        </option>
+                                    }
+                                </select>
+                            </div>
+                            
+                            <div class="d-flex justify-content-between mb-3">
+                                <button id="prev-heat-btn" class="btn btn-secondary" hx-post="/api/race/previous-heat" hx-swap="none" disabled?={ currentHeatNum <= 1 }>
+                                    <i class="bi bi-arrow-left"></i> Previous Heat
+                                </button>
+                                <span class="align-self-center">
+                                    <strong>Heat { strconv.Itoa(currentHeatNum) } of { strconv.Itoa(len(heats)) }</strong>
+                                </span>
+                                <button id="next-heat-btn" class="btn btn-secondary" hx-post="/api/race/next-heat" hx-swap="none" disabled?={ currentHeatNum >= len(heats) }>
+                                    Next Heat <i class="bi bi-arrow-right"></i>
+                                </button>
+                            </div>
+                            
+                            <div class="d-flex justify-content-between">
+                                <button id="reset-timer-btn" class="btn btn-warning" onclick="resetTimer()">
+                                    <i class="bi bi-arrow-clockwise"></i> Reset Timer
+                                </button>
+                                <button id="force-end-btn" class="btn btn-danger" onclick="forceEndHeat()">
+                                    <i class="bi bi-flag-fill"></i> Force End Heat
+                                </button>
+                                <button id="rerun-heat-btn" class="btn btn-info" hx-post="/api/race/rerun-heat" hx-swap="none">
+                                    <i class="bi bi-arrow-repeat"></i> Re-run Heat
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="col-md-6">
+                    <div class="card">
+                        <div class="card-header bg-primary text-white">
+                            <h3 class="mb-0">Timer</h3>
+                        </div>
+                        <div class="card-body">
+                            <div class="timer-display text-center">
+                                <div id="timer" class="display-1 fw-bold">0.000</div>
+                                <div id="status-indicator" class="badge bg-secondary mb-3">Ready</div>
+                            </div>
+                            
+                            <div class="d-flex justify-content-center">
+                                <div id="gate-status" class="alert alert-secondary">
+                                    Gate Status: <span id="gate-status-text">Unknown</span>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            
+            <div class="row">
+                <div class="col-12">
+                    <div class="card mb-4">
+                        <div class="card-header bg-primary text-white">
+                            <h3 class="mb-0">Current Heat</h3>
+                        </div>
+                        <div class="card-body">
+                            <div id="current-heat">
+                                @raceManageCurrentHeat(heats, racers, currentHeatNum, results)
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            
+            <div class="row">
+                <div class="col-md-6">
+                    <div class="card mb-4">
+                        <div class="card-header bg-info text-white">
+                            <h3 class="mb-0">Next Heat</h3>
+                        </div>
+                        <div class="card-body">
+                            if currentHeatNum < len(heats) {
+                                @raceManageNextHeat(heats, racers, currentHeatNum+1)
+                            } else {
+                                <div class="alert alert-info">No more heats in this group</div>
+                            }
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="col-md-6">
+                    <div class="card mb-4">
+                        <div class="card-header bg-secondary text-white">
+                            <h3 class="mb-0">Heat Results</h3>
+                        </div>
+                        <div class="card-body">
+                            <div class="table-responsive">
+                                <table class="table table-striped table-sm">
+                                    <thead>
+                                        <tr>
+                                            <th>Heat</th>
+                                            <th>Lane 1</th>
+                                            <th>Lane 2</th>
+                                            <th>Lane 3</th>
+                                            <th>Lane 4</th>
+                                        </tr>
+                                    </thead>
+                                    <tbody>
+                                        for _, result := range results {
+                                            <tr>
+                                                <td>{ strconv.Itoa(result.HeatNumber) }</td>
+                                                <td>{ fmt.Sprintf("%.3f (#%d)", result.Lane1Time, result.Lane1Position) }</td>
+                                                <td>{ fmt.Sprintf("%.3f (#%d)", result.Lane2Time, result.Lane2Position) }</td>
+                                                <td>{ fmt.Sprintf("%.3f (#%d)", result.Lane3Time, result.Lane3Position) }</td>
+                                                <td>{ fmt.Sprintf("%.3f (#%d)", result.Lane4Time, result.Lane4Position) }</td>
+                                            </tr>
+                                        }
+                                    </tbody>
+                                </table>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <script>
+            // WebSocket connections
+            const timerSocket = new WebSocket(`${window.location.protocol === 'https:' ? 'wss:' : 'ws:'}//${window.location.host}/ws/timer`);
+            const adminSocket = new WebSocket(`${window.location.protocol === 'https:' ? 'wss:' : 'ws:'}//${window.location.host}/ws/admin`);
+            
+            const timerDisplay = document.getElementById('timer');
+            const statusIndicator = document.getElementById('status-indicator');
+            const gateStatus = document.getElementById('gate-status');
+            const gateStatusText = document.getElementById('gate-status-text');
+            
+            // Timer socket handling
+            timerSocket.onmessage = function(event) {
+                const data = JSON.parse(event.data);
+                
+                if (data.type === 'time') {
+                    timerDisplay.textContent = data.time.toFixed(3);
+                } else if (data.type === 'status') {
+                    statusIndicator.textContent = data.status;
+                    
+                    // Update status indicator color
+                    statusIndicator.className = 'badge mb-3 ';
+                    if (data.status === 'Ready') {
+                        statusIndicator.className += 'bg-secondary';
+                    } else if (data.status === 'Running') {
+                        statusIndicator.className += 'bg-success';
+                    } else if (data.status === 'Finished') {
+                        statusIndicator.className += 'bg-primary';
+                        
+                        // Auto-save results when race finishes
+                        saveHeatResults();
+                    }
+                } else if (data.type === 'gate') {
+                    gateStatusText.textContent = data.status;
+                    
+                    // Update gate status color
+                    gateStatus.className = 'alert ';
+                    if (data.status === 'Open') {
+                        gateStatus.className += 'alert-danger';
+                    } else if (data.status === 'Closed') {
+                        gateStatus.className += 'alert-success';
+                    } else {
+                        gateStatus.className += 'alert-secondary';
+                    }
+                } else if (data.type === 'lane-time') {
+                    // Update lane time display
+                    const laneTimeElement = document.getElementById(`lane-${data.lane}-time`);
+                    if (laneTimeElement) {
+                        laneTimeElement.textContent = data.time.toFixed(3);
+                    }
+                } else if (data.type === 'lane-position') {
+                    // Update lane position display
+                    const lanePositionElement = document.getElementById(`lane-${data.lane}-position`);
+                    if (lanePositionElement) {
+                        lanePositionElement.textContent = data.position;
+                    }
+                }
+            };
+            
+            // Admin socket handling
+            adminSocket.onmessage = function(event) {
+                const data = JSON.parse(event.data);
+                
+                if (data === 'heat-changed' || data === 'group-changed' || data === 'heat-rerun') {
+                    // Reload the page when heat or group changes
+                    window.location.reload();
+                }
+            };
+            
+            // Function to reset the timer
+            function resetTimer() {
+                fetch('/api/timer/reset', { method: 'POST' })
+                    .then(response => {
+                        if (!response.ok) {
+                            console.error('Failed to reset timer');
+                        }
+                    })
+                    .catch(error => {
+                        console.error('Error:', error);
+                    });
+            }
+            
+            // Function to force end the current heat
+            function forceEndHeat() {
+                fetch('/api/timer/force-end', { method: 'POST' })
+                    .then(response => {
+                        if (!response.ok) {
+                            console.error('Failed to force end heat');
+                        }
+                    })
+                    .catch(error => {
+                        console.error('Error:', error);
+                    });
+            }
+            
+            // Function to save heat results
+            function saveHeatResults() {
+                // Get lane times and positions from the UI
+                const lanes = [1, 2, 3, 4];
+                const results = {
+                    group_id: parseInt(document.getElementById('group-select').value),
+                    heat_number: parseInt('{ strconv.Itoa(currentHeatNum) }'),
+                };
+                
+                lanes.forEach(lane => {
+                    const timeElement = document.getElementById(`lane-${lane}-time`);
+                    const positionElement = document.getElementById(`lane-${lane}-position`);
+                    
+                    if (timeElement && positionElement) {
+                        const timeText = timeElement.textContent.trim();
+                        const positionText = positionElement.textContent.trim();
+                        
+                        results[`lane${lane}_time`] = timeText !== '--.-' ? parseFloat(timeText) : 0;
+                        results[`lane${lane}_position`] = positionText !== '-' ? parseInt(positionText) : 0;
+                    }
+                });
+                
+                // Save results to the server
+                fetch('/api/race/save-result', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify(results),
+                })
+                .then(response => {
+                    if (!response.ok) {
+                        console.error('Failed to save heat results');
+                    }
+                })
+                .catch(error => {
+                    console.error('Error:', error);
+                });
+            }
+        </script>
+    }
+}
+
+// Helper template for displaying current heat in the management view
+templ raceManageCurrentHeat(heats []models.Heat, racers []models.Racer, currentHeatNum int, results []models.HeatResult) {
+    {{
+    // Find current heat
+    var currentHeat models.Heat
+    for _, heat := range heats {
+        if heat.HeatNum == currentHeatNum {
+            currentHeat = heat
+            break
+        }
+    }
+    
+    // Find heat result if available
+    var currentResult *models.HeatResult
+    for _, result := range results {
+        if result.HeatNumber == currentHeatNum {
+            currentResult = &result
+            break
+        }
+    }
+    }}
+    
+    <div class="table-responsive">
+        <table class="table table-bordered">
+            <thead>
+                <tr>
+                    <th>Lane</th>
+                    <th>Racer</th>
+                    <th>Car #</th>
+                    <th>Time</th>
+                    <th>Position</th>
+                </tr>
+            </thead>
+            <tbody>
+                if currentHeat.Lane1ID != nil {
+                    @raceManageLaneRow(1, *currentHeat.Lane1ID, racers, currentResult)
+                }
+                if currentHeat.Lane2ID != nil {
+                    @raceManageLaneRow(2, *currentHeat.Lane2ID, racers, currentResult)
+                }
+                if currentHeat.Lane3ID != nil {
+                    @raceManageLaneRow(3, *currentHeat.Lane3ID, racers, currentResult)
+                }
+                if currentHeat.Lane4ID != nil {
+                    @raceManageLaneRow(4, *currentHeat.Lane4ID, racers, currentResult)
+                }
+            </tbody>
+        </table>
+    </div>
+}
+
+// Helper template for displaying a lane row in the management view
+templ raceManageLaneRow(lane int, racerID int64, racers []models.Racer, result *models.HeatResult) {
+    {{
+    // Find racer
+    var racer models.Racer
+    for _, r := range racers {
+        if r.ID == racerID {
+            racer = r
+            break
+        }
+    }
+    
+    // Get time and position from result if available
+    var time float64
+    var position int
+    var hasResult bool
+    
+    if result != nil {
+        hasResult = true
+        switch lane {
+        case 1:
+            time = result.Lane1Time
+            position = result.Lane1Position
+        case 2:
+            time = result.Lane2Time
+            position = result.Lane2Position
+        case 3:
+            time = result.Lane3Time
+            position = result.Lane3Position
+        case 4:
+            time = result.Lane4Time
+            position = result.Lane4Position
+        }
+    }
+    }}
+
+    <tr>
+        <td>{ strconv.Itoa(lane) }</td>
+        <td>{ racer.FirstName } { racer.LastName }</td>
+        <td>{ racer.CarNumber }</td>
+        <td id={ fmt.Sprintf("lane-%d-time", lane) }>
+            if hasResult {
+                { fmt.Sprintf("%.3f", time) }
+            } else {
+                --.-
+            }
+        </td>
+        <td id={ fmt.Sprintf("lane-%d-position", lane) }>
+            if hasResult {
+                { strconv.Itoa(position) }
+            } else {
+                -
+            }
+        </td>
+    </tr>
+}
+
+// Helper template for displaying next heat in the management view
+templ raceManageNextHeat(heats []models.Heat, racers []models.Racer, heatNum int) {
+    {{
+    // Find the heat
+    var nextHeat models.Heat
+    for _, heat := range heats {
+        if heat.HeatNum == heatNum {
+            nextHeat = heat
+            break
+        }
+    }
+    }}
+    
+    <div class="table-responsive">
+        <table class="table table-striped table-sm">
+            <thead>
+                <tr>
+                    <th>Lane</th>
+                    <th>Racer</th>
+                    <th>Car #</th>
+                </tr>
+            </thead>
+            <tbody>
+                if nextHeat.Lane1ID != nil {
+                    @raceManageNextHeatRow(1, *nextHeat.Lane1ID, racers)
+                }
+                if nextHeat.Lane2ID != nil {
+                    @raceManageNextHeatRow(2, *nextHeat.Lane2ID, racers)
+                }
+                if nextHeat.Lane3ID != nil {
+                    @raceManageNextHeatRow(3, *nextHeat.Lane3ID, racers)
+                }
+                if nextHeat.Lane4ID != nil {
+                    @raceManageNextHeatRow(4, *nextHeat.Lane4ID, racers)
+                }
+            </tbody>
+        </table>
+    </div>
+}
+
+// Helper template for displaying a row in the next heat preview
+templ raceManageNextHeatRow(lane int, racerID int64, racers []models.Racer) {
+    {{
+    // Find racer
+    var racer models.Racer
+    for _, r := range racers {
+        if r.ID == racerID {
+            racer = r
+            break
+        }
+    }
+    }}
+
+    <tr>
+        <td>{ strconv.Itoa(lane) }</td>
+        <td>{ racer.FirstName } { racer.LastName }</td>
+        <td>{ racer.CarNumber }</td>
+    </tr>
+} 

web/templates/race_public.templ

@@ -0,0 +1,297 @@
+package templates
+
+import (
+    "track-gopher/models"
+    "fmt"
+    "strconv"
+)
+
+// RacePublic renders the public race view
+templ RacePublic(currentGroup models.Group, heats []models.Heat, racers []models.Racer, currentHeatNum int, results []models.HeatResult) {
+    @Layout("Race - " + currentGroup.Name) {
+        <div class="container-fluid mt-3">
+            <div class="row">
+                <div class="col-12">
+                    <div class="card mb-4">
+                        <div class="card-header bg-primary text-white">
+                            <h2 class="mb-0 text-center">{ currentGroup.Name } - Heat { strconv.Itoa(currentHeatNum) } of { strconv.Itoa(len(heats)) }</h2>
+                        </div>
+                        <div class="card-body">
+                            <div id="current-heat" class="mb-4">
+                                <div class="row">
+                                    <div class="col-12">
+                                        <div class="timer-display text-center mb-4">
+                                            <div id="timer" class="display-1 fw-bold">0.000</div>
+                                            <div id="status-indicator" class="badge bg-secondary">Ready</div>
+                                        </div>
+                                        
+                                        <div class="lanes-container">
+                                            @raceCurrentHeatLanes(heats, racers, currentHeatNum, results)
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            
+            <div class="row">
+                <div class="col-md-6">
+                    <div class="card mb-4">
+                        <div class="card-header bg-info text-white">
+                            <h3 class="mb-0">Next Heat</h3>
+                        </div>
+                        <div class="card-body">
+                            if currentHeatNum < len(heats) {
+                                @raceNextHeatPreview(heats, racers, currentHeatNum+1)
+                            } else {
+                                <div class="alert alert-info">No more heats in this group</div>
+                            }
+                        </div>
+                    </div>
+                </div>
+                <div class="col-md-6">
+                    <div class="card mb-4">
+                        <div class="card-header bg-info text-white">
+                            <h3 class="mb-0">Upcoming Heat</h3>
+                        </div>
+                        <div class="card-body">
+                            if currentHeatNum+1 < len(heats) {
+                                @raceNextHeatPreview(heats, racers, currentHeatNum+2)
+                            } else {
+                                <div class="alert alert-info">No more heats in this group</div>
+                            }
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <script>
+            // WebSocket connection for timer updates
+            const timerSocket = new WebSocket(`${window.location.protocol === 'https:' ? 'wss:' : 'ws:'}//${window.location.host}/ws/timer`);
+            const timerDisplay = document.getElementById('timer');
+            const statusIndicator = document.getElementById('status-indicator');
+            
+            timerSocket.onmessage = function(event) {
+                const data = JSON.parse(event.data);
+                
+                if (data.type === 'time') {
+                    timerDisplay.textContent = data.time.toFixed(3);
+                } else if (data.type === 'status') {
+                    statusIndicator.textContent = data.status;
+                    
+                    // Update status indicator color
+                    statusIndicator.className = 'badge ';
+                    if (data.status === 'Ready') {
+                        statusIndicator.className += 'bg-secondary';
+                    } else if (data.status === 'Running') {
+                        statusIndicator.className += 'bg-success';
+                    } else if (data.status === 'Finished') {
+                        statusIndicator.className += 'bg-primary';
+                    }
+                } else if (data.type === 'lane-time') {
+                    // Update lane time display
+                    const laneTimeElement = document.getElementById(`lane-${data.lane}-time`);
+                    if (laneTimeElement) {
+                        laneTimeElement.textContent = data.time.toFixed(3);
+                    }
+                } else if (data.type === 'lane-position') {
+                    // Update lane position display
+                    const lanePositionElement = document.getElementById(`lane-${data.lane}-position`);
+                    if (lanePositionElement) {
+                        lanePositionElement.textContent = data.position;
+                    }
+                } else if (data.type === 'reload') {
+                    // Reload the page when heat changes
+                    window.location.reload();
+                }
+            };
+            
+            // Auto-refresh the page every 30 seconds to keep data current
+            setTimeout(() => {
+                window.location.reload();
+            }, 30000);
+        </script>
+    }
+}
+
+// Helper template for displaying current heat lanes
+templ raceCurrentHeatLanes(heats []models.Heat, racers []models.Racer, currentHeatNum int, results []models.HeatResult) {
+    {{
+    // Find current heat
+    var currentHeat models.Heat
+    for _, heat := range heats {
+        if heat.HeatNum == currentHeatNum {
+            currentHeat = heat
+            break
+        }
+    }
+    
+    // Find heat result if available
+    var currentResult *models.HeatResult
+    for _, result := range results {
+        if result.HeatNumber == currentHeatNum {
+            currentResult = &result
+            break
+        }
+    }
+    }}
+    
+    <div class="row row-cols-1 row-cols-md-4 g-4">
+        if currentHeat.Lane1ID != nil {
+            @raceLaneCard(1, *currentHeat.Lane1ID, racers, currentResult)
+        }
+        if currentHeat.Lane2ID != nil {
+            @raceLaneCard(2, *currentHeat.Lane2ID, racers, currentResult)
+        }
+        if currentHeat.Lane3ID != nil {
+            @raceLaneCard(3, *currentHeat.Lane3ID, racers, currentResult)
+        }
+        if currentHeat.Lane4ID != nil {
+            @raceLaneCard(4, *currentHeat.Lane4ID, racers, currentResult)
+        }
+    </div>
+}
+
+// Helper template for displaying a lane card
+templ raceLaneCard(lane int, racerID int64, racers []models.Racer, result *models.HeatResult) {
+    {{
+    // Find racer
+    var racer models.Racer
+    for _, r := range racers {
+        if r.ID == racerID {
+            racer = r
+            break
+        }
+    }
+    
+    // Get time and position from result if available
+    var time float64
+    var position int
+    var hasResult bool
+    
+    if result != nil {
+        hasResult = true
+        switch lane {
+        case 1:
+            time = result.Lane1Time
+            position = result.Lane1Position
+        case 2:
+            time = result.Lane2Time
+            position = result.Lane2Position
+        case 3:
+            time = result.Lane3Time
+            position = result.Lane3Position
+        case 4:
+            time = result.Lane4Time
+            position = result.Lane4Position
+        }
+    }
+    }}
+    
+    <div class="col">
+        <div class="card h-100 lane-card">
+            <div class="card-header bg-primary text-white">
+                <h4 class="mb-0">Lane { strconv.Itoa(lane) }</h4>
+            </div>
+            <div class="card-body">
+                <h5 class="card-title">{ racer.FirstName } { racer.LastName }</h5>
+                <p class="card-text">
+                    <strong>Car #:</strong> { racer.CarNumber }<br/>
+                    <strong>Weight:</strong> { fmt.Sprintf("%.1f oz", racer.CarWeight) }
+                </p>
+                <div class="result-area">
+                    <div class="row">
+                        <div class="col-6">
+                            <div class="text-center">
+                                <h6>Time</h6>
+                                <div id={ fmt.Sprintf("lane-%d-time", lane) } class="display-6">
+                                    if hasResult {
+                                        { fmt.Sprintf("%.3f", time) }
+                                    } else {
+                                        --.-
+                                    }
+                                </div>
+                            </div>
+                        </div>
+                        <div class="col-6">
+                            <div class="text-center">
+                                <h6>Position</h6>
+                                <div id={ fmt.Sprintf("lane-%d-position", lane) } class="display-6">
+                                    if hasResult {
+                                        { strconv.Itoa(position) }
+                                    } else {
+                                        -
+                                    }
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+}
+
+// Helper template for displaying next heat preview
+templ raceNextHeatPreview(heats []models.Heat, racers []models.Racer, heatNum int) {
+    {{
+    // Find the heat
+    var nextHeat models.Heat
+    for _, heat := range heats {
+        if heat.HeatNum == heatNum {
+            nextHeat = heat
+            break
+        }
+    }
+    }}
+
+    <h4 class="mb-3">Heat { strconv.Itoa(heatNum) }</h4>
+    <div class="table-responsive">
+        <table class="table table-striped">
+            <thead>
+                <tr>
+                    <th>Lane</th>
+                    <th>Racer</th>
+                    <th>Car #</th>
+                </tr>
+            </thead>
+            <tbody>
+                if nextHeat.Lane1ID != nil {
+                    @raceNextHeatRow(1, *nextHeat.Lane1ID, racers)
+                }
+                if nextHeat.Lane2ID != nil {
+                    @raceNextHeatRow(2, *nextHeat.Lane2ID, racers)
+                }
+                if nextHeat.Lane3ID != nil {
+                    @raceNextHeatRow(3, *nextHeat.Lane3ID, racers)
+                }
+                if nextHeat.Lane4ID != nil {
+                    @raceNextHeatRow(4, *nextHeat.Lane4ID, racers)
+                }
+            </tbody>
+        </table>
+    </div>
+}
+
+// Helper template for displaying a row in the next heat preview
+templ raceNextHeatRow(lane int, racerID int64, racers []models.Racer) {
+    {{
+    // Find racer
+    var racer models.Racer
+    for _, r := range racers {
+        if r.ID == racerID {
+            racer = r
+            break
+        }
+    }
+    }}
+    
+    <tr>
+        <td>{ strconv.Itoa(lane) }</td>
+        <td>{ racer.FirstName } { racer.LastName }</td>
+        <td>{ racer.CarNumber }</td>
+    </tr>
+} 

web/templates/race_public_templ.go

@@ -0,0 +1,582 @@
+// Code generated by templ - DO NOT EDIT.
+
+// templ: version: v0.3.833
+package templates
+
+//lint:file-ignore SA4006 This context is only used if a nested component is present.
+
+import "github.com/a-h/templ"
+import templruntime "github.com/a-h/templ/runtime"
+
+import (
+	"fmt"
+	"strconv"
+	"track-gopher/models"
+)
+
+// RacePublic renders the public race view
+func RacePublic(currentGroup models.Group, heats []models.Heat, racers []models.Racer, currentHeatNum int, results []models.HeatResult) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
+			return templ_7745c5c3_CtxErr
+		}
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var1 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var1 == nil {
+			templ_7745c5c3_Var1 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+		templ_7745c5c3_Var2 := templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+			templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+			templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+			if !templ_7745c5c3_IsBuffer {
+				defer func() {
+					templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+					if templ_7745c5c3_Err == nil {
+						templ_7745c5c3_Err = templ_7745c5c3_BufErr
+					}
+				}()
+			}
+			ctx = templ.InitializeContext(ctx)
+			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 1, "<div class=\"container-fluid mt-3\"><div class=\"row\"><div class=\"col-12\"><div class=\"card mb-4\"><div class=\"card-header bg-primary text-white\"><h2 class=\"mb-0 text-center\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var3 string
+			templ_7745c5c3_Var3, templ_7745c5c3_Err = templ.JoinStringErrs(currentGroup.Name)
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 17, Col: 76}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var3))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 2, " - Heat ")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var4 string
+			templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(strconv.Itoa(currentHeatNum))
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 17, Col: 116}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 3, " of ")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			var templ_7745c5c3_Var5 string
+			templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(strconv.Itoa(len(heats)))
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 17, Col: 148}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 4, "</h2></div><div class=\"card-body\"><div id=\"current-heat\" class=\"mb-4\"><div class=\"row\"><div class=\"col-12\"><div class=\"timer-display text-center mb-4\"><div id=\"timer\" class=\"display-1 fw-bold\">0.000</div><div id=\"status-indicator\" class=\"badge bg-secondary\">Ready</div></div><div class=\"lanes-container\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			templ_7745c5c3_Err = raceCurrentHeatLanes(heats, racers, currentHeatNum, results).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 5, "</div></div></div></div></div></div></div></div><div class=\"row\"><div class=\"col-md-6\"><div class=\"card mb-4\"><div class=\"card-header bg-info text-white\"><h3 class=\"mb-0\">Next Heat</h3></div><div class=\"card-body\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			if currentHeatNum < len(heats) {
+				templ_7745c5c3_Err = raceNextHeatPreview(heats, racers, currentHeatNum+1).Render(ctx, templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err != nil {
+					return templ_7745c5c3_Err
+				}
+			} else {
+				templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 6, "<div class=\"alert alert-info\">No more heats in this group</div>")
+				if templ_7745c5c3_Err != nil {
+					return templ_7745c5c3_Err
+				}
+			}
+			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 7, "</div></div></div><div class=\"col-md-6\"><div class=\"card mb-4\"><div class=\"card-header bg-info text-white\"><h3 class=\"mb-0\">Upcoming Heat</h3></div><div class=\"card-body\">")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			if currentHeatNum+1 < len(heats) {
+				templ_7745c5c3_Err = raceNextHeatPreview(heats, racers, currentHeatNum+2).Render(ctx, templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err != nil {
+					return templ_7745c5c3_Err
+				}
+			} else {
+				templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 8, "<div class=\"alert alert-info\">No more heats in this group</div>")
+				if templ_7745c5c3_Err != nil {
+					return templ_7745c5c3_Err
+				}
+			}
+			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 9, "</div></div></div></div></div><script>\r\n            // WebSocket connection for timer updates\r\n            const timerSocket = new WebSocket(`${window.location.protocol === 'https:' ? 'wss:' : 'ws:'}//${window.location.host}/ws/timer`);\r\n            const timerDisplay = document.getElementById('timer');\r\n            const statusIndicator = document.getElementById('status-indicator');\r\n            \r\n            timerSocket.onmessage = function(event) {\r\n                const data = JSON.parse(event.data);\r\n                \r\n                if (data.type === 'time') {\r\n                    timerDisplay.textContent = data.time.toFixed(3);\r\n                } else if (data.type === 'status') {\r\n                    statusIndicator.textContent = data.status;\r\n                    \r\n                    // Update status indicator color\r\n                    statusIndicator.className = 'badge ';\r\n                    if (data.status === 'Ready') {\r\n                        statusIndicator.className += 'bg-secondary';\r\n                    } else if (data.status === 'Running') {\r\n                        statusIndicator.className += 'bg-success';\r\n                    } else if (data.status === 'Finished') {\r\n                        statusIndicator.className += 'bg-primary';\r\n                    }\r\n                } else if (data.type === 'lane-time') {\r\n                    // Update lane time display\r\n                    const laneTimeElement = document.getElementById(`lane-${data.lane}-time`);\r\n                    if (laneTimeElement) {\r\n                        laneTimeElement.textContent = data.time.toFixed(3);\r\n                    }\r\n                } else if (data.type === 'lane-position') {\r\n                    // Update lane position display\r\n                    const lanePositionElement = document.getElementById(`lane-${data.lane}-position`);\r\n                    if (lanePositionElement) {\r\n                        lanePositionElement.textContent = data.position;\r\n                    }\r\n                } else if (data.type === 'reload') {\r\n                    // Reload the page when heat changes\r\n                    window.location.reload();\r\n                }\r\n            };\r\n            \r\n            // Auto-refresh the page every 30 seconds to keep data current\r\n            setTimeout(() => {\r\n                window.location.reload();\r\n            }, 30000);\r\n        </script>")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+			return nil
+		})
+		templ_7745c5c3_Err = Layout("Race - "+currentGroup.Name).Render(templ.WithChildren(ctx, templ_7745c5c3_Var2), templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return nil
+	})
+}
+
+// Helper template for displaying current heat lanes
+func raceCurrentHeatLanes(heats []models.Heat, racers []models.Racer, currentHeatNum int, results []models.HeatResult) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
+			return templ_7745c5c3_CtxErr
+		}
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var6 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var6 == nil {
+			templ_7745c5c3_Var6 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+
+		// Find current heat
+		var currentHeat models.Heat
+		for _, heat := range heats {
+			if heat.HeatNum == currentHeatNum {
+				currentHeat = heat
+				break
+			}
+		}
+
+		// Find heat result if available
+		var currentResult *models.HeatResult
+		for _, result := range results {
+			if result.HeatNumber == currentHeatNum {
+				currentResult = &result
+				break
+			}
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 10, "<div class=\"row row-cols-1 row-cols-md-4 g-4\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if currentHeat.Lane1ID != nil {
+			templ_7745c5c3_Err = raceLaneCard(1, *currentHeat.Lane1ID, racers, currentResult).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		if currentHeat.Lane2ID != nil {
+			templ_7745c5c3_Err = raceLaneCard(2, *currentHeat.Lane2ID, racers, currentResult).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		if currentHeat.Lane3ID != nil {
+			templ_7745c5c3_Err = raceLaneCard(3, *currentHeat.Lane3ID, racers, currentResult).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		if currentHeat.Lane4ID != nil {
+			templ_7745c5c3_Err = raceLaneCard(4, *currentHeat.Lane4ID, racers, currentResult).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 11, "</div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return nil
+	})
+}
+
+// Helper template for displaying a lane card
+func raceLaneCard(lane int, racerID int64, racers []models.Racer, result *models.HeatResult) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
+			return templ_7745c5c3_CtxErr
+		}
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var7 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var7 == nil {
+			templ_7745c5c3_Var7 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+
+		// Find racer
+		var racer models.Racer
+		for _, r := range racers {
+			if r.ID == racerID {
+				racer = r
+				break
+			}
+		}
+
+		// Get time and position from result if available
+		var time float64
+		var position int
+		var hasResult bool
+
+		if result != nil {
+			hasResult = true
+			switch lane {
+			case 1:
+				time = result.Lane1Time
+				position = result.Lane1Position
+			case 2:
+				time = result.Lane2Time
+				position = result.Lane2Position
+			case 3:
+				time = result.Lane3Time
+				position = result.Lane3Position
+			case 4:
+				time = result.Lane4Time
+				position = result.Lane4Position
+			}
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 12, "<div class=\"col\"><div class=\"card h-100 lane-card\"><div class=\"card-header bg-primary text-white\"><h4 class=\"mb-0\">Lane ")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var8 string
+		templ_7745c5c3_Var8, templ_7745c5c3_Err = templ.JoinStringErrs(strconv.Itoa(lane))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 197, Col: 58}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var8))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 13, "</h4></div><div class=\"card-body\"><h5 class=\"card-title\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var9 string
+		templ_7745c5c3_Var9, templ_7745c5c3_Err = templ.JoinStringErrs(racer.FirstName)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 200, Col: 56}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var9))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 14, " ")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var10 string
+		templ_7745c5c3_Var10, templ_7745c5c3_Err = templ.JoinStringErrs(racer.LastName)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 200, Col: 75}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var10))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 15, "</h5><p class=\"card-text\"><strong>Car #:</strong> ")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var11 string
+		templ_7745c5c3_Var11, templ_7745c5c3_Err = templ.JoinStringErrs(racer.CarNumber)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 202, Col: 61}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var11))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 16, "<br><strong>Weight:</strong> ")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var12 string
+		templ_7745c5c3_Var12, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%.1f oz", racer.CarWeight))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 203, Col: 86}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var12))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 17, "</p><div class=\"result-area\"><div class=\"row\"><div class=\"col-6\"><div class=\"text-center\"><h6>Time</h6><div id=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var13 string
+		templ_7745c5c3_Var13, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("lane-%d-time", lane))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 210, Col: 75}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var13))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 18, "\" class=\"display-6\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if hasResult {
+			var templ_7745c5c3_Var14 string
+			templ_7745c5c3_Var14, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%.3f", time))
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 212, Col: 67}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var14))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		} else {
+			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 19, "--.-")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 20, "</div></div></div><div class=\"col-6\"><div class=\"text-center\"><h6>Position</h6><div id=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var15 string
+		templ_7745c5c3_Var15, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("lane-%d-position", lane))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 222, Col: 79}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var15))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 21, "\" class=\"display-6\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if hasResult {
+			var templ_7745c5c3_Var16 string
+			templ_7745c5c3_Var16, templ_7745c5c3_Err = templ.JoinStringErrs(strconv.Itoa(position))
+			if templ_7745c5c3_Err != nil {
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 224, Col: 64}
+			}
+			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var16))
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		} else {
+			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 22, "-")
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 23, "</div></div></div></div></div></div></div></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return nil
+	})
+}
+
+// Helper template for displaying next heat preview
+func raceNextHeatPreview(heats []models.Heat, racers []models.Racer, heatNum int) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
+			return templ_7745c5c3_CtxErr
+		}
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var17 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var17 == nil {
+			templ_7745c5c3_Var17 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+
+		// Find the heat
+		var nextHeat models.Heat
+		for _, heat := range heats {
+			if heat.HeatNum == heatNum {
+				nextHeat = heat
+				break
+			}
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 24, "<h4 class=\"mb-3\">Heat ")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var18 string
+		templ_7745c5c3_Var18, templ_7745c5c3_Err = templ.JoinStringErrs(strconv.Itoa(heatNum))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 251, Col: 49}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var18))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 25, "</h4><div class=\"table-responsive\"><table class=\"table table-striped\"><thead><tr><th>Lane</th><th>Racer</th><th>Car #</th></tr></thead> <tbody>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		if nextHeat.Lane1ID != nil {
+			templ_7745c5c3_Err = raceNextHeatRow(1, *nextHeat.Lane1ID, racers).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		if nextHeat.Lane2ID != nil {
+			templ_7745c5c3_Err = raceNextHeatRow(2, *nextHeat.Lane2ID, racers).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		if nextHeat.Lane3ID != nil {
+			templ_7745c5c3_Err = raceNextHeatRow(3, *nextHeat.Lane3ID, racers).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		if nextHeat.Lane4ID != nil {
+			templ_7745c5c3_Err = raceNextHeatRow(4, *nextHeat.Lane4ID, racers).Render(ctx, templ_7745c5c3_Buffer)
+			if templ_7745c5c3_Err != nil {
+				return templ_7745c5c3_Err
+			}
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 26, "</tbody></table></div>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return nil
+	})
+}
+
+// Helper template for displaying a row in the next heat preview
+func raceNextHeatRow(lane int, racerID int64, racers []models.Racer) templ.Component {
+	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
+		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
+		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
+			return templ_7745c5c3_CtxErr
+		}
+		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
+		if !templ_7745c5c3_IsBuffer {
+			defer func() {
+				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
+				if templ_7745c5c3_Err == nil {
+					templ_7745c5c3_Err = templ_7745c5c3_BufErr
+				}
+			}()
+		}
+		ctx = templ.InitializeContext(ctx)
+		templ_7745c5c3_Var19 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var19 == nil {
+			templ_7745c5c3_Var19 = templ.NopComponent
+		}
+		ctx = templ.ClearChildren(ctx)
+
+		// Find racer
+		var racer models.Racer
+		for _, r := range racers {
+			if r.ID == racerID {
+				racer = r
+				break
+			}
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 27, "<tr><td>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var20 string
+		templ_7745c5c3_Var20, templ_7745c5c3_Err = templ.JoinStringErrs(strconv.Itoa(lane))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 293, Col: 32}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var20))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 28, "</td><td>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var21 string
+		templ_7745c5c3_Var21, templ_7745c5c3_Err = templ.JoinStringErrs(racer.FirstName)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 294, Col: 29}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var21))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 29, " ")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var22 string
+		templ_7745c5c3_Var22, templ_7745c5c3_Err = templ.JoinStringErrs(racer.LastName)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 294, Col: 48}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var22))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 30, "</td><td>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var23 string
+		templ_7745c5c3_Var23, templ_7745c5c3_Err = templ.JoinStringErrs(racer.CarNumber)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `web/templates/race_public.templ`, Line: 295, Col: 29}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var23))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 31, "</td></tr>")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		return nil
+	})
+}
+
+var _ = templruntime.GeneratedTemplate